Changeset 270130 in webkit


Ignore:
Timestamp:
Nov 20, 2020 1:21:25 PM (3 years ago)
Author:
Simon Fraser
Message:

Dispatch main-thread overflow scrolls to the scrolling thread as we do for page scrolls
​https://bugs.webkit.org/show_bug.cgi?id=219213

Reviewed by Tim Horton.
Source/WebCore:

Unify the behavior of overflow scrolling and page scrolling for synchronous scrolls.

Somewhat surprisingly, synchronous page scrolls move layers via a dispatch to the scrolling thread in
FrameView::handleWheelEventForScrolling(), but overflow scrolls just did main thread compositing updates
to set the new layer positions.

A future patch will require that the "began" event for a synchronous scroll gets back to the scrolling thread,
so unify these code paths to have overflow scrolls also leverage handleWheelEventAfterMainThread(), via
RenderLayer::handleWheelEventForScrolling().

There's some fallout from this. ThreadedScrollingTree::handleWheelEventAfterMainThread() calls into handleWheelEventWithNode(),
but in this special case that codepath needs to know that we're in a special "post main thread" mode that should

  1. Behave as if the node is latched, i.e. don't propagate to parent nodes, and target the node if if it's scrolled to a the min or max to allow rubberbanding
  2. Scroll even if the node has synchronous scrolling reasons

This mode is represented by the EventTargeting value.

Finally, EventHandler::handleWheelEventInternal() should only clear latching state if the content has called preventDefault()
on the event.

  • page/EventHandler.cpp:

(WebCore::EventHandler::handleWheelEventInternal):

  • page/scrolling/ScrollLatchingController.cpp:

(WebCore::ScrollLatchingController::updateAndFetchLatchingStateForFrame):

  • page/scrolling/ScrollingTree.cpp:

(WebCore::ScrollingTree::handleWheelEventWithNode):

  • page/scrolling/ScrollingTree.h:
  • page/scrolling/ScrollingTreeScrollingNode.cpp:

(WebCore::ScrollingTreeScrollingNode::canHandleWheelEvent const):
(WebCore::ScrollingTreeScrollingNode::handleWheelEvent):

  • page/scrolling/ScrollingTreeScrollingNode.h:
  • page/scrolling/ThreadedScrollingTree.cpp:

(WebCore::ThreadedScrollingTree::handleWheelEventAfterMainThread):

  • page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h:
  • page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm:

(WebCore::ScrollingTreeFrameScrollingNodeMac::handleWheelEvent):

  • page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.h:
  • page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.mm:

(WebCore::ScrollingTreeOverflowScrollingNodeMac::handleWheelEvent):

  • platform/cocoa/ScrollController.mm:

(WebCore::ScrollController::handleWheelEvent):

  • rendering/RenderLayer.cpp:

(WebCore::RenderLayer::handleWheelEventForScrolling):

  • rendering/RenderLayer.h:

Source/WebKit:

Unify the behavior of overflow scrolling and page scrolling for synchronous scrolls.

Somewhat surprisingly, synchronous page scrolls move layers via a dispatch to the scrolling thread in
FrameView::handleWheelEventForScrolling(), but overflow scrolls just did main thread compositing updates
to set the new layer positions.

A future patch will require that the "began" event for a synchronous scroll gets back to the scrolling thread,
so unify these code paths to have overflow scrolls also leverage handleWheelEventAfterMainThread(), via
RenderLayer::handleWheelEventForScrolling().

There's some fallout from this. ThreadedScrollingTree::handleWheelEventAfterMainThread() calls into handleWheelEventWithNode(),
but in this special case that codepath needs to know that we're in a special "post main thread" mode that should

  1. Behave as if the node is latched, i.e. don't propagate to parent nodes, and target the node if if it's scrolled to a the min or max to allow rubberbanding
  2. Scroll even if the node has synchronous scrolling reasons

This mode is represented by the EventTargeting value.

Finally, EventHandler::handleWheelEventInternal() should only clear latching state if the content has called preventDefault()
on the event.

  • UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.cpp:

(WebKit::ScrollingTreeFrameScrollingNodeRemoteMac::handleWheelEvent):

  • UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.h:
  • UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.cpp:

(WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::handleWheelEvent):

  • UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.h:
Location:
trunk/Source
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r270128 r270130  
     12020-11-20  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Dispatch main-thread overflow scrolls to the scrolling thread as we do for page scrolls
     4        https://bugs.webkit.org/show_bug.cgi?id=219213
     5
     6        Reviewed by Tim Horton.
     7
     8        Unify the behavior of overflow scrolling and page scrolling for synchronous scrolls.
     9
     10        Somewhat surprisingly, synchronous page scrolls move layers via a dispatch to the scrolling thread in
     11        FrameView::handleWheelEventForScrolling(), but overflow scrolls just did main thread compositing updates
     12        to set the new layer positions.
     13
     14        A future patch will require that the "began" event for a synchronous scroll gets back to the scrolling thread,
     15        so unify these code paths to have overflow scrolls also leverage handleWheelEventAfterMainThread(), via
     16        RenderLayer::handleWheelEventForScrolling().
     17
     18        There's some fallout from this. ThreadedScrollingTree::handleWheelEventAfterMainThread() calls into handleWheelEventWithNode(),
     19        but in this special case that codepath needs to know that we're in a special "post main thread" mode that should
     20            1. Behave as if the node is latched, i.e. don't propagate to parent nodes,
     21               and target the node if if it's scrolled to a the min or max to allow rubberbanding
     22            2. Scroll even if the node has synchronous scrolling reasons
     23        This mode is represented by the EventTargeting value.
     24
     25        Finally, EventHandler::handleWheelEventInternal() should only clear latching state if the content has called preventDefault()
     26        on the event.
     27
     28        * page/EventHandler.cpp:
     29        (WebCore::EventHandler::handleWheelEventInternal):
     30        * page/scrolling/ScrollLatchingController.cpp:
     31        (WebCore::ScrollLatchingController::updateAndFetchLatchingStateForFrame):
     32        * page/scrolling/ScrollingTree.cpp:
     33        (WebCore::ScrollingTree::handleWheelEventWithNode):
     34        * page/scrolling/ScrollingTree.h:
     35        * page/scrolling/ScrollingTreeScrollingNode.cpp:
     36        (WebCore::ScrollingTreeScrollingNode::canHandleWheelEvent const):
     37        (WebCore::ScrollingTreeScrollingNode::handleWheelEvent):
     38        * page/scrolling/ScrollingTreeScrollingNode.h:
     39        * page/scrolling/ThreadedScrollingTree.cpp:
     40        (WebCore::ThreadedScrollingTree::handleWheelEventAfterMainThread):
     41        * page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h:
     42        * page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm:
     43        (WebCore::ScrollingTreeFrameScrollingNodeMac::handleWheelEvent):
     44        * page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.h:
     45        * page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.mm:
     46        (WebCore::ScrollingTreeOverflowScrollingNodeMac::handleWheelEvent):
     47        * platform/cocoa/ScrollController.mm:
     48        (WebCore::ScrollController::handleWheelEvent):
     49        * rendering/RenderLayer.cpp:
     50        (WebCore::RenderLayer::handleWheelEventForScrolling):
     51        * rendering/RenderLayer.h:
     52
    1532020-11-20  Zalan Bujtas  <zalan@apple.com>
    254

  • trunk/Source/WebCore/page/EventHandler.cpp

    r270125 r270130  
    29422942            if (scrollableArea && scrollableArea->scrollShouldClearLatchedState()) {
    29432943                // Web developer is controlling scrolling, so don't attempt to latch.
    2944                 clearLatchedState();
     2944                if (handling.containsAll({ EventHandling::DispatchedToDOM, EventHandling::DefaultPrevented }))
     2945                    clearLatchedState();
    29452946                scrollableArea->setScrollShouldClearLatchedState(false);
    29462947            }

  • trunk/Source/WebCore/page/scrolling/ScrollLatchingController.cpp

    r266333 r270130  
    121121            state.isOverWidget = isOverWidget;
    122122
     123            LOG_WITH_STREAM(ScrollLatching, stream << "ScrollLatchingController::updateAndFetchLatchingStateForFrame() - pushing state for Frame " << &frame << " element " << state.wheelEventElement.get() << " scrollableArea " << state.scrollableArea);
    123124            m_frameStateStack.append(WTFMove(state));
    124125            return;
    … …  
    144145            scrollableArea = state.scrollableArea;
    145146            isOverWidget = state.isOverWidget;
     147
     148            LOG_WITH_STREAM(ScrollLatching, stream << "ScrollLatchingController::updateAndFetchLatchingStateForFrame() - using state for Frame " << &frame << " element " << latchedElement.get() << " scrollableArea " << scrollableArea);
    146149        }
    147150    }

  • trunk/Source/WebCore/page/scrolling/ScrollingTree.cpp

    r269973 r270130  
    169169}
    170170
    171 WheelEventHandlingResult ScrollingTree::handleWheelEventWithNode(const PlatformWheelEvent& wheelEvent, OptionSet<WheelEventProcessingSteps> processingSteps, ScrollingTreeNode* node)
     171WheelEventHandlingResult ScrollingTree::handleWheelEventWithNode(const PlatformWheelEvent& wheelEvent, OptionSet<WheelEventProcessingSteps> processingSteps, ScrollingTreeNode* node, EventTargeting eventTargeting)
    172172{
    173173    while (node) {
    174174        if (is<ScrollingTreeScrollingNode>(*node)) {
    175175            auto& scrollingNode = downcast<ScrollingTreeScrollingNode>(*node);
    176             auto result = scrollingNode.handleWheelEvent(wheelEvent);
     176            auto result = scrollingNode.handleWheelEvent(wheelEvent, eventTargeting);
    177177
    178178            if (result.wasHandled) {
    … …  
    182182            }
    183183
    184             if (result.needsMainThreadProcessing())
     184            if (result.needsMainThreadProcessing() || eventTargeting != EventTargeting::Propagate)
    185185                return result;
    186186        }

  • trunk/Source/WebCore/page/scrolling/ScrollingTree.h

    r269973 r270130  
    7676};
    7777
     78enum class EventTargeting : uint8_t { NodeOnly, Propagate };
     79
    7880class ScrollingTree : public ThreadSafeRefCounted<ScrollingTree> {
    7981friend class ScrollingTreeLatchingController;
    … …  
    234236
    235237protected:
    236     WheelEventHandlingResult handleWheelEventWithNode(const PlatformWheelEvent&, OptionSet<WheelEventProcessingSteps>, ScrollingTreeNode*);
     238    WheelEventHandlingResult handleWheelEventWithNode(const PlatformWheelEvent&, OptionSet<WheelEventProcessingSteps>, ScrollingTreeNode*, EventTargeting = EventTargeting::Propagate);
    237239
    238240    FloatPoint mainFrameScrollPosition() const;

  • trunk/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.cpp

    r270125 r270130  
    135135}
    136136
    137 bool ScrollingTreeScrollingNode::canHandleWheelEvent(const PlatformWheelEvent& wheelEvent) const
     137bool ScrollingTreeScrollingNode::canHandleWheelEvent(const PlatformWheelEvent& wheelEvent, EventTargeting eventTargeting) const
    138138{
    139139    if (!canHaveScrollbars())
    … …  
    146146    // We always rubber-band the latched node, or the root node.
    147147    // The stateless wheel event doesn't trigger rubber-band.
    148     if (isLatchedNode() || (isRootNode() && !wheelEvent.isNonGestureEvent()))
     148    if (isLatchedNode() || eventTargeting == EventTargeting::NodeOnly || (isRootNode() && !wheelEvent.isNonGestureEvent()))
    149149        return true;
    150150
    … …  
    152152}
    153153
    154 WheelEventHandlingResult ScrollingTreeScrollingNode::handleWheelEvent(const PlatformWheelEvent&)
     154WheelEventHandlingResult ScrollingTreeScrollingNode::handleWheelEvent(const PlatformWheelEvent&, EventTargeting)
    155155{
    156156    return WheelEventHandlingResult::unhandled();

  • trunk/Source/WebCore/page/scrolling/ScrollingTreeScrollingNode.h

    r269559 r270130  
    2929
    3030#include "IntRect.h"
    31 #include "RectEdges.h"
    3231#include "ScrollSnapOffsetsInfo.h"
    33 #include "ScrollTypes.h"
    3432#include "ScrollableArea.h"
    35 #include "ScrollingCoordinator.h"
     33#include "ScrollingTree.h"
    3634#include "ScrollingTreeNode.h"
    3735
    … …  
    5654    void didCompleteCommitForNode() final;
    5755
    58     virtual bool canHandleWheelEvent(const PlatformWheelEvent&) const;
    59     virtual WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&);
     56    virtual bool canHandleWheelEvent(const PlatformWheelEvent&, EventTargeting) const;
     57    virtual WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&, EventTargeting = EventTargeting::Propagate);
    6058
    6159    FloatPoint currentScrollPosition() const { return m_currentScrollPosition; }

  • trunk/Source/WebCore/page/scrolling/ThreadedScrollingTree.cpp

    r269973 r270130  
    6767bool ThreadedScrollingTree::handleWheelEventAfterMainThread(const PlatformWheelEvent& wheelEvent, ScrollingNodeID targetNodeID)
    6868{
    69     LOG_WITH_STREAM(Scrolling, stream << "ThreadedScrollingTree::handleWheelEventAfterMainThread " << wheelEvent);
     69    LOG_WITH_STREAM(Scrolling, stream << "ThreadedScrollingTree::handleWheelEventAfterMainThread " << wheelEvent << " node " << targetNodeID);
    7070
    7171    LockHolder locker(m_treeMutex);
    … …  
    7373    SetForScope<bool> disallowLatchingScope(m_allowLatching, false);
    7474    RefPtr<ScrollingTreeNode> targetNode = nodeForID(targetNodeID);
    75     auto result = handleWheelEventWithNode(wheelEvent, { }, targetNode.get());
     75    auto result = handleWheelEventWithNode(wheelEvent, { }, targetNode.get(), EventTargeting::NodeOnly);
    7676    return result.wasHandled;
    7777}

  • trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h

    r269559 r270130  
    5252    void commitStateAfterChildren(const ScrollingStateNode&) override;
    5353
    54     WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&) override;
     54    WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&, EventTargeting) override;
    5555
    5656    WEBCORE_EXPORT void repositionRelatedLayers() override;

  • trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm

    r269559 r270130  
    118118}
    119119
    120 WheelEventHandlingResult ScrollingTreeFrameScrollingNodeMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
    121 {
    122     if (!canHandleWheelEvent(wheelEvent))
     120WheelEventHandlingResult ScrollingTreeFrameScrollingNodeMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent, EventTargeting eventTargeting)
     121{
     122    if (!canHandleWheelEvent(wheelEvent, eventTargeting))
    123123        return WheelEventHandlingResult::unhandled();
    124124

  • trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.h

    r269559 r270130  
    5454    void repositionRelatedLayers() override;
    5555
    56     WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&) override;
     56    WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&, EventTargeting) override;
    5757
    5858private:

  • trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.mm

    r269973 r270130  
    7474}
    7575
    76 WheelEventHandlingResult ScrollingTreeOverflowScrollingNodeMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
     76WheelEventHandlingResult ScrollingTreeOverflowScrollingNodeMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent, EventTargeting eventTargeting)
    7777{
    7878#if ENABLE(SCROLLING_THREAD)
    79     if (hasSynchronousScrollingReasons())
     79    if (hasSynchronousScrollingReasons() && eventTargeting != EventTargeting::NodeOnly)
    8080        return { { WheelEventProcessingSteps::MainThreadForScrolling, WheelEventProcessingSteps::MainThreadForNonBlockingDOMEventDispatch }, false };
    8181#endif
    8282
    83     if (!canHandleWheelEvent(wheelEvent))
     83    if (!canHandleWheelEvent(wheelEvent, eventTargeting))
    8484        return WheelEventHandlingResult::unhandled();
    8585

  • trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeFrameScrollingNodeNicosia.cpp

    r269909 r270130  
    159159#endif
    160160
    161 WheelEventHandlingResult ScrollingTreeFrameScrollingNodeNicosia::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
    162 {
    163     if (!canHandleWheelEvent(wheelEvent))
     161WheelEventHandlingResult ScrollingTreeFrameScrollingNodeNicosia::handleWheelEvent(const PlatformWheelEvent& wheelEvent, EventTargeting eventTargeting)
     162{
     163    if (!canHandleWheelEvent(wheelEvent, eventTargeting))
    164164        return WheelEventHandlingResult::unhandled();
    165165

  • trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeFrameScrollingNodeNicosia.h

    r269579 r270130  
    6363#endif
    6464
    65     WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&) override;
     65    WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&, EventTargeting) override;
    6666
    6767    void stopScrollAnimations() override;

  • trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeOverflowScrollingNodeNicosia.cpp

    r269909 r270130  
    149149#endif
    150150
    151 WheelEventHandlingResult ScrollingTreeOverflowScrollingNodeNicosia::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
    152 {
    153     if (!canHandleWheelEvent(wheelEvent))
     151WheelEventHandlingResult ScrollingTreeOverflowScrollingNodeNicosia::handleWheelEvent(const PlatformWheelEvent& wheelEvent, EventTargeting eventTargeting)
     152{
     153    if (!canHandleWheelEvent(wheelEvent, eventTargeting))
    154154        return WheelEventHandlingResult::unhandled();
    155155

  • trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeOverflowScrollingNodeNicosia.h

    r269909 r270130  
    5858#endif
    5959
    60     WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&) override;
     60    WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&, EventTargeting) override;
    6161
    6262    void stopScrollAnimations() override;

  • trunk/Source/WebCore/platform/cocoa/ScrollController.mm

    r269659 r270130  
    257257            }
    258258        }
     259
     260        LOG_WITH_STREAM(Scrolling, stream << "ScrollController::handleWheelEvent() - deltaX " << deltaX << " deltaY " << deltaY << " pinned " << m_client.pinnedInDirection(FloatSize(deltaX, deltaY)) << " shouldStretch " << shouldStretch);
    259261    }
    260262

  • trunk/Source/WebCore/rendering/RenderLayer.cpp

    r270023 r270130  
    31663166}
    31673167
     3168bool RenderLayer::handleWheelEventForScrolling(const PlatformWheelEvent& wheelEvent)
     3169{
     3170    if (!isScrollableOrRubberbandable())
     3171        return false;
     3172
     3173#if ENABLE(ASYNC_SCROLLING)
     3174    if (usesAsyncScrolling() && scrollingNodeID()) {
     3175        if (auto* scrollingCoordinator = page().scrollingCoordinator())
     3176            return scrollingCoordinator->handleWheelEventForScrolling(wheelEvent, scrollingNodeID());
     3177    }
     3178#endif
     3179
     3180    return ScrollableArea::handleWheelEventForScrolling(wheelEvent);
     3181}
     3182
    31683183IntRect RenderLayer::visibleContentRectInternal(VisibleContentRectIncludesScrollbars scrollbarInclusion, VisibleContentRectBehavior) const
    31693184{

  • trunk/Source/WebCore/rendering/RenderLayer.h

    r268263 r270130  
    494494    ScrollableArea* enclosingScrollableArea() const final;
    495495
     496    bool handleWheelEventForScrolling(const PlatformWheelEvent&) final;
    496497    bool isScrollableOrRubberbandable() final;
    497498    bool hasScrollableOrRubberbandableAncestor() final;

  • trunk/Source/WebKit/ChangeLog

    r270125 r270130  
     12020-11-20  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Dispatch main-thread overflow scrolls to the scrolling thread as we do for page scrolls
     4        https://bugs.webkit.org/show_bug.cgi?id=219213
     5
     6        Reviewed by Tim Horton.
     7       
     8        Unify the behavior of overflow scrolling and page scrolling for synchronous scrolls.
     9       
     10        Somewhat surprisingly, synchronous page scrolls move layers via a dispatch to the scrolling thread in
     11        FrameView::handleWheelEventForScrolling(), but overflow scrolls just did main thread compositing updates
     12        to set the new layer positions.
     13
     14        A future patch will require that the "began" event for a synchronous scroll gets back to the scrolling thread,
     15        so unify these code paths to have overflow scrolls also leverage handleWheelEventAfterMainThread(), via
     16        RenderLayer::handleWheelEventForScrolling().
     17
     18        There's some fallout from this. ThreadedScrollingTree::handleWheelEventAfterMainThread() calls into handleWheelEventWithNode(),
     19        but in this special case that codepath needs to know that we're in a special "post main thread" mode that should
     20            1. Behave as if the node is latched, i.e. don't propagate to parent nodes,
     21               and target the node if if it's scrolled to a the min or max to allow rubberbanding
     22            2. Scroll even if the node has synchronous scrolling reasons
     23        This mode is represented by the EventTargeting value.
     24
     25        Finally, EventHandler::handleWheelEventInternal() should only clear latching state if the content has called preventDefault()
     26        on the event.
     27
     28        * UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.cpp:
     29        (WebKit::ScrollingTreeFrameScrollingNodeRemoteMac::handleWheelEvent):
     30        * UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.h:
     31        * UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.cpp:
     32        (WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::handleWheelEvent):
     33        * UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.h:
     34
    1352020-11-20  Simon Fraser  <simon.fraser@apple.com>
    236

  • trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.cpp

    r269184 r270130  
    7373}
    7474
    75 WheelEventHandlingResult ScrollingTreeFrameScrollingNodeRemoteMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
     75WheelEventHandlingResult ScrollingTreeFrameScrollingNodeRemoteMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent, EventTargeting eventTargeting)
    7676{
    77     ScrollingTreeFrameScrollingNodeMac::handleWheelEvent(wheelEvent);
     77    ScrollingTreeFrameScrollingNodeMac::handleWheelEvent(wheelEvent, eventTargeting);
    7878
    7979    return WheelEventHandlingResult::result(m_scrollerPair->handleWheelEvent(wheelEvent));

  • trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.h

    r262294 r270130  
    4545
    4646    void commitStateBeforeChildren(const WebCore::ScrollingStateNode&) override;
    47     WebCore::WheelEventHandlingResult handleWheelEvent(const WebCore::PlatformWheelEvent&) override;
     47    WebCore::WheelEventHandlingResult handleWheelEvent(const WebCore::PlatformWheelEvent&, EventTargeting) override;
    4848    void repositionRelatedLayers() override;
    4949

  • trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.cpp

    r269184 r270130  
    7373}
    7474
    75 WheelEventHandlingResult ScrollingTreeOverflowScrollingNodeRemoteMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
     75WheelEventHandlingResult ScrollingTreeOverflowScrollingNodeRemoteMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent, EventTargeting eventTargeting)
    7676{
    77     ScrollingTreeOverflowScrollingNodeMac::handleWheelEvent(wheelEvent);
     77    ScrollingTreeOverflowScrollingNodeMac::handleWheelEvent(wheelEvent, eventTargeting);
    7878
    7979    return WheelEventHandlingResult::result(m_scrollerPair->handleWheelEvent(wheelEvent));

  • trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.h

    r262294 r270130  
    4545
    4646    void commitStateBeforeChildren(const WebCore::ScrollingStateNode&) override;
    47     WebCore::WheelEventHandlingResult handleWheelEvent(const WebCore::PlatformWheelEvent&) override;
     47    WebCore::WheelEventHandlingResult handleWheelEvent(const WebCore::PlatformWheelEvent&, EventTargeting) override;
    4848    void repositionRelatedLayers() override;
    4949
Note: See TracChangeset for help on using the changeset viewer.