Changeset 240787 in webkit


Ignore:
Timestamp:
Jan 31, 2019, 8:28:27 AM (6 years ago)
Author:
Simon Fraser
Message:

[Mac] Implement basic hit testing in the scrolling tree
​https://bugs.webkit.org/show_bug.cgi?id=172917
<rdar://problem/34215516>

Reviewed by Antti Koivisto.

Source/WebCore:

First steps to getting hit testing of scrolling nodes in the scrolling tree. Based on patch
by Frédéric Wang.

First we pipe the "async scrolling enabled" setting through to the ScrollingTree via
the root node (like the other settings; weird, but that's how it's done). For now,
we hit test in the scrolling tree if either async overflow or frame scrolling are enabled
(it's hard to deal with one without the other).

Nodes in the scrolling tree implement scrollingNodeForPoint() to implement hit testing.
Two helper functions exist to simplify coordinate conversion: parentToLocalPoint()
and localToContentsPoint(). Child nodes are hit-testing in reverse order to find nodes
hightest in Z first. Only scrolling nodes are returned (not sure if we'll ever need
to hit-test non-scrolling nodes). Nodes use parentRelativeScrollableRect and scroll positions
to do these point mappings.

handleWheelEvent() is changed to return a ScrollingEventResult.

Latching is not correct with this change when async frame scrolling is enabled. That needs
to be fixed separately.

No tests yet; for ease of testing, I'd like to add an Internals API to hit-test the
scrolling tree, rather than doing eventSender stuff everywhere.

  • page/scrolling/AsyncScrollingCoordinator.cpp:

(WebCore::AsyncScrollingCoordinator::frameViewLayoutUpdated):
(WebCore::AsyncScrollingCoordinator::asyncFrameOrOverflowScrollingEnabled const):

  • page/scrolling/AsyncScrollingCoordinator.h:
  • page/scrolling/ScrollingStateFrameScrollingNode.cpp:

(WebCore::ScrollingStateFrameScrollingNode::ScrollingStateFrameScrollingNode):
(WebCore::ScrollingStateFrameScrollingNode::setAllPropertiesChanged):
(WebCore::ScrollingStateFrameScrollingNode::setAsyncFrameOrOverflowScrollingEnabled):

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

(WebCore::ScrollingTree::shouldHandleWheelEventSynchronously):
(WebCore::ScrollingTree::handleWheelEvent):
(WebCore::ScrollingTree::commitTreeState):
(WebCore::ScrollingTree::setAsyncFrameOrOverflowScrollingEnabled):

  • page/scrolling/ScrollingTree.h:

(WebCore::ScrollingTree::asyncFrameOrOverflowScrollingEnabled const):

  • page/scrolling/ScrollingTreeFrameHostingNode.cpp:

(WebCore::ScrollingTreeFrameHostingNode::parentToLocalPoint const):

  • page/scrolling/ScrollingTreeFrameHostingNode.h:
  • page/scrolling/ScrollingTreeFrameScrollingNode.cpp:

(WebCore::ScrollingTreeFrameScrollingNode::parentToLocalPoint const):
(WebCore::ScrollingTreeFrameScrollingNode::localToContentsPoint const):

  • page/scrolling/ScrollingTreeFrameScrollingNode.h:
  • page/scrolling/ScrollingTreeNode.cpp:

(WebCore::ScrollingTreeNode::scrollingNodeForPoint const):

  • page/scrolling/ScrollingTreeNode.h:

(WebCore::ScrollingTreeNode::children const):
(WebCore::ScrollingTreeNode::parentToLocalPoint const):
(WebCore::ScrollingTreeNode::localToContentsPoint const):

  • page/scrolling/ScrollingTreeScrollingNode.cpp:

(WebCore::ScrollingTreeScrollingNode::scrollLimitReached const):
(WebCore::ScrollingTreeScrollingNode::parentToLocalPoint const):
(WebCore::ScrollingTreeScrollingNode::localToContentsPoint const):
(WebCore::ScrollingTreeScrollingNode::scrollingNodeForPoint const):

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

(WebCore::ThreadedScrollingTree::handleWheelEvent):

  • page/scrolling/ThreadedScrollingTree.h:
  • page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.h:
  • page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.mm:

(WebCore::ScrollingTreeFrameScrollingNodeIOS::handleWheelEvent):

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

(WebCore::ScrollingTreeFrameScrollingNodeMac::handleWheelEvent):

  • page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.h:

Source/WebKit:

Changed return types, "using namespace WebCore" in ScrollingTreeFrameScrollingNodeRemoteMac.cpp.

  • Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp:

(ArgumentCoder<ScrollingStateFrameScrollingNode>::encode):

  • UIProcess/RemoteLayerTree/ios/ScrollingTreeOverflowScrollingNodeIOS.h:
  • UIProcess/RemoteLayerTree/mac/ScrollerPairMac.h:
  • UIProcess/RemoteLayerTree/mac/ScrollerPairMac.mm:

(WebKit::ScrollerPairMac::handleWheelEvent):
(WebKit::ScrollerPairMac::handleMouseEvent):

  • UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.cpp:

(WebKit::ScrollingTreeFrameScrollingNodeRemoteMac::handleWheelEvent):
(WebKit::ScrollingTreeFrameScrollingNodeRemoteMac::handleMouseEvent):

  • UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.h:
Location:
trunk/Source
Files:
45 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r240784 r240787  
     12019-01-30  Simon Fraser  <simon.fraser@apple.com>
     2
     3        [Mac] Implement basic hit testing in the scrolling tree
     4        https://bugs.webkit.org/show_bug.cgi?id=172917
     5        <rdar://problem/34215516>
     6
     7        Reviewed by Antti Koivisto.
     8
     9        First steps to getting hit testing of scrolling nodes in the scrolling tree. Based on patch
     10        by Frédéric Wang.
     11
     12        First we pipe the "async scrolling enabled" setting through to the ScrollingTree via
     13        the root node (like the other settings; weird, but that's how it's done). For now,
     14        we hit test in the scrolling tree if either async overflow or frame scrolling are enabled
     15        (it's hard to deal with one without the other).
     16
     17        Nodes in the scrolling tree implement scrollingNodeForPoint() to implement hit testing.
     18        Two helper functions exist to simplify coordinate conversion: parentToLocalPoint()
     19        and localToContentsPoint(). Child nodes are hit-testing in reverse order to find nodes
     20        hightest in Z first. Only scrolling nodes are returned (not sure if we'll ever need
     21        to hit-test non-scrolling nodes). Nodes use parentRelativeScrollableRect and scroll positions
     22        to do these point mappings.
     23
     24        handleWheelEvent() is changed to return a ScrollingEventResult.
     25
     26        Latching is not correct with this change when async frame scrolling is enabled. That needs
     27        to be fixed separately.
     28
     29        No tests yet; for ease of testing, I'd like to add an Internals API to hit-test the
     30        scrolling tree, rather than doing eventSender stuff everywhere.
     31
     32        * page/scrolling/AsyncScrollingCoordinator.cpp:
     33        (WebCore::AsyncScrollingCoordinator::frameViewLayoutUpdated):
     34        (WebCore::AsyncScrollingCoordinator::asyncFrameOrOverflowScrollingEnabled const):
     35        * page/scrolling/AsyncScrollingCoordinator.h:
     36        * page/scrolling/ScrollingStateFrameScrollingNode.cpp:
     37        (WebCore::ScrollingStateFrameScrollingNode::ScrollingStateFrameScrollingNode):
     38        (WebCore::ScrollingStateFrameScrollingNode::setAllPropertiesChanged):
     39        (WebCore::ScrollingStateFrameScrollingNode::setAsyncFrameOrOverflowScrollingEnabled):
     40        * page/scrolling/ScrollingStateFrameScrollingNode.h:
     41        * page/scrolling/ScrollingTree.cpp:
     42        (WebCore::ScrollingTree::shouldHandleWheelEventSynchronously):
     43        (WebCore::ScrollingTree::handleWheelEvent):
     44        (WebCore::ScrollingTree::commitTreeState):
     45        (WebCore::ScrollingTree::setAsyncFrameOrOverflowScrollingEnabled):
     46        * page/scrolling/ScrollingTree.h:
     47        (WebCore::ScrollingTree::asyncFrameOrOverflowScrollingEnabled const):
     48        * page/scrolling/ScrollingTreeFrameHostingNode.cpp:
     49        (WebCore::ScrollingTreeFrameHostingNode::parentToLocalPoint const):
     50        * page/scrolling/ScrollingTreeFrameHostingNode.h:
     51        * page/scrolling/ScrollingTreeFrameScrollingNode.cpp:
     52        (WebCore::ScrollingTreeFrameScrollingNode::parentToLocalPoint const):
     53        (WebCore::ScrollingTreeFrameScrollingNode::localToContentsPoint const):
     54        * page/scrolling/ScrollingTreeFrameScrollingNode.h:
     55        * page/scrolling/ScrollingTreeNode.cpp:
     56        (WebCore::ScrollingTreeNode::scrollingNodeForPoint const):
     57        * page/scrolling/ScrollingTreeNode.h:
     58        (WebCore::ScrollingTreeNode::children const):
     59        (WebCore::ScrollingTreeNode::parentToLocalPoint const):
     60        (WebCore::ScrollingTreeNode::localToContentsPoint const):
     61        * page/scrolling/ScrollingTreeScrollingNode.cpp:
     62        (WebCore::ScrollingTreeScrollingNode::scrollLimitReached const):
     63        (WebCore::ScrollingTreeScrollingNode::parentToLocalPoint const):
     64        (WebCore::ScrollingTreeScrollingNode::localToContentsPoint const):
     65        (WebCore::ScrollingTreeScrollingNode::scrollingNodeForPoint const):
     66        * page/scrolling/ScrollingTreeScrollingNode.h:
     67        * page/scrolling/ThreadedScrollingTree.cpp:
     68        (WebCore::ThreadedScrollingTree::handleWheelEvent):
     69        * page/scrolling/ThreadedScrollingTree.h:
     70        * page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.h:
     71        * page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.mm:
     72        (WebCore::ScrollingTreeFrameScrollingNodeIOS::handleWheelEvent):
     73        * page/scrolling/ios/ScrollingTreeIOS.h:
     74        * page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h:
     75        * page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm:
     76        (WebCore::ScrollingTreeFrameScrollingNodeMac::handleWheelEvent):
     77        * page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.h:
     78
    1792019-01-31  Alicia Boya García  <aboya@igalia.com>
    280

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

    r240628 r240787  
    50125012        if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator()) {
    50135013            if (scrollingCoordinator->coordinatesScrollingForFrameView(*this))
    5014                 return scrollingCoordinator->handleWheelEvent(*this, wheelEvent);
     5014                return scrollingCoordinator->handleWheelEvent(*this, wheelEvent) != ScrollingEventResult::DidNotHandleEvent;
    50155015        }
    50165016    }

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

    r240713 r240787  
    131131        return;
    132132
    133     auto* node = downcast<ScrollingStateFrameScrollingNode>(m_scrollingStateTree->stateNodeForID(frameView.scrollLayerID()));
    134     if (!node)
    135         return;
     133    auto* node = m_scrollingStateTree->stateNodeForID(frameView.scrollLayerID());
     134    if (!node || !is<ScrollingStateFrameScrollingNode>(*node))
     135        return;
     136
     137    auto& frameScrollingNode = downcast<ScrollingStateFrameScrollingNode>(*node);
    136138
    137139    auto* verticalScrollbar = frameView.verticalScrollbar();
    138140    auto* horizontalScrollbar = frameView.horizontalScrollbar();
    139     node->setScrollerImpsFromScrollbars(verticalScrollbar, horizontalScrollbar);
    140 
    141     node->setFrameScaleFactor(frameView.frame().frameScaleFactor());
    142     node->setHeaderHeight(frameView.headerHeight());
    143     node->setFooterHeight(frameView.footerHeight());
    144     node->setTopContentInset(frameView.topContentInset());
    145 
    146     node->setVisualViewportEnabled(visualViewportEnabled());
    147     node->setLayoutViewport(frameView.layoutViewportRect());
    148     node->setMinLayoutViewportOrigin(frameView.minStableLayoutViewportOrigin());
    149     node->setMaxLayoutViewportOrigin(frameView.maxStableLayoutViewportOrigin());
    150 
    151     node->setScrollOrigin(frameView.scrollOrigin());
    152     node->setScrollableAreaSize(frameView.visibleContentRect().size());
    153     node->setTotalContentsSize(frameView.totalContentsSize());
    154     node->setReachableContentsSize(frameView.totalContentsSize());
    155     node->setFixedElementsLayoutRelativeToFrame(frameView.fixedElementsLayoutRelativeToFrame());
    156     node->setScrollBehaviorForFixedElements(frameView.scrollBehaviorForFixedElements());
     141    frameScrollingNode.setScrollerImpsFromScrollbars(verticalScrollbar, horizontalScrollbar);
     142
     143    frameScrollingNode.setFrameScaleFactor(frameView.frame().frameScaleFactor());
     144    frameScrollingNode.setHeaderHeight(frameView.headerHeight());
     145    frameScrollingNode.setFooterHeight(frameView.footerHeight());
     146    frameScrollingNode.setTopContentInset(frameView.topContentInset());
     147
     148    frameScrollingNode.setVisualViewportEnabled(visualViewportEnabled());
     149    frameScrollingNode.setLayoutViewport(frameView.layoutViewportRect());
     150    frameScrollingNode.setAsyncFrameOrOverflowScrollingEnabled(asyncFrameOrOverflowScrollingEnabled());
     151
     152    frameScrollingNode.setMinLayoutViewportOrigin(frameView.minStableLayoutViewportOrigin());
     153    frameScrollingNode.setMaxLayoutViewportOrigin(frameView.maxStableLayoutViewportOrigin());
     154
     155    frameScrollingNode.setScrollOrigin(frameView.scrollOrigin());
     156    frameScrollingNode.setScrollableAreaSize(frameView.visibleContentRect().size());
     157    frameScrollingNode.setTotalContentsSize(frameView.totalContentsSize());
     158    frameScrollingNode.setReachableContentsSize(frameView.totalContentsSize());
     159    frameScrollingNode.setFixedElementsLayoutRelativeToFrame(frameView.fixedElementsLayoutRelativeToFrame());
     160    frameScrollingNode.setScrollBehaviorForFixedElements(frameView.scrollBehaviorForFixedElements());
    157161
    158162#if ENABLE(CSS_SCROLL_SNAP)
    … …  
    165169    if (page && page->expectsWheelEventTriggers()) {
    166170        LOG(WheelEventTestTriggers, "    AsyncScrollingCoordinator::frameViewLayoutUpdated: Expects wheel event test trigger=%d", page->expectsWheelEventTriggers());
    167         node->setExpectsWheelEventTestTrigger(page->expectsWheelEventTriggers());
     171        frameScrollingNode.setExpectsWheelEventTestTrigger(page->expectsWheelEventTriggers());
    168172    }
    169173#endif
    … …  
    178182    scrollParameters.useDarkAppearanceForScrollbars = frameView.useDarkAppearanceForScrollbars();
    179183
    180     node->setScrollableAreaParameters(scrollParameters);
     184    frameScrollingNode.setScrollableAreaParameters(scrollParameters);
    181185}
    182186
    … …  
    680684}
    681685
     686bool AsyncScrollingCoordinator::asyncFrameOrOverflowScrollingEnabled() const
     687{
     688    auto& settings = m_page->mainFrame().settings();
     689    return settings.asyncFrameScrollingEnabled() || settings.asyncOverflowScrollingEnabled();
     690}
     691
    682692String AsyncScrollingCoordinator::scrollingStateTreeAsText(ScrollingStateTreeAsTextBehavior behavior) const
    683693{

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

    r240551 r240787  
    9191   
    9292    bool visualViewportEnabled() const;
     93    bool asyncFrameOrOverflowScrollingEnabled() const;
    9394
    9495    WEBCORE_EXPORT void frameViewLayoutUpdated(FrameView&) override;

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

    r240579 r240787  
    112112    virtual void commitTreeStateIfNeeded() { }
    113113    virtual bool requestScrollPositionUpdate(FrameView&, const IntPoint&) { return false; }
    114     virtual bool handleWheelEvent(FrameView&, const PlatformWheelEvent&) { return true; }
     114    virtual ScrollingEventResult handleWheelEvent(FrameView&, const PlatformWheelEvent&) { return ScrollingEventResult::DidNotHandleEvent; }
    115115
    116116    // Create an unparented node.

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

    r240579 r240787  
    8181};
    8282
     83enum class ScrollingEventResult {
     84    DidNotHandleEvent,
     85    DidHandleEvent,
     86    SendToMainThread
     87};
     88
    8389enum class ViewportRectStability {
    8490    Stable,

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

    r240677 r240787  
    6565    , m_fixedElementsLayoutRelativeToFrame(stateNode.fixedElementsLayoutRelativeToFrame())
    6666    , m_visualViewportEnabled(stateNode.visualViewportEnabled())
     67    , m_asyncFrameOrOverflowScrollingEnabled(stateNode.asyncFrameOrOverflowScrollingEnabled())
    6768{
    6869    if (hasChangedProperty(CounterScrollingLayer))
    … …  
    115116    setPropertyChangedBit(FixedElementsLayoutRelativeToFrame);
    116117    setPropertyChangedBit(VisualViewportEnabled);
     118    setPropertyChangedBit(AsyncFrameOrOverflowScrollingEnabled);
    117119    setPropertyChangedBit(LayoutViewport);
    118120    setPropertyChangedBit(MinLayoutViewportOrigin);
    … …  
    293295    m_visualViewportEnabled = visualViewportEnabled;
    294296    setPropertyChanged(VisualViewportEnabled);
     297}
     298
     299void ScrollingStateFrameScrollingNode::setAsyncFrameOrOverflowScrollingEnabled(bool enabled)
     300{
     301    if (enabled == m_asyncFrameOrOverflowScrollingEnabled)
     302        return;
     303   
     304    m_asyncFrameOrOverflowScrollingEnabled = enabled;
     305    setPropertyChanged(AsyncFrameOrOverflowScrollingEnabled);
    295306}
    296307

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

    r240677 r240787  
    6565        FixedElementsLayoutRelativeToFrame,
    6666        VisualViewportEnabled,
     67        AsyncFrameOrOverflowScrollingEnabled,
    6768        LayoutViewport,
    6869        MinLayoutViewportOrigin,
    … …  
    128129    WEBCORE_EXPORT void setHorizontalScrollbarLayer(const LayerRepresentation&);
    129130
     131    // These are more like Settings, and should probably move to the Scrolling{State}Tree itself.
    130132    bool fixedElementsLayoutRelativeToFrame() const { return m_fixedElementsLayoutRelativeToFrame; }
    131133    WEBCORE_EXPORT void setFixedElementsLayoutRelativeToFrame(bool);
    … …  
    133135    bool visualViewportEnabled() const { return m_visualViewportEnabled; };
    134136    WEBCORE_EXPORT void setVisualViewportEnabled(bool);
     137
     138    bool asyncFrameOrOverflowScrollingEnabled() const { return m_asyncFrameOrOverflowScrollingEnabled; }
     139    void setAsyncFrameOrOverflowScrollingEnabled(bool);
    135140
    136141#if PLATFORM(MAC)
    … …  
    177182    bool m_fixedElementsLayoutRelativeToFrame { false };
    178183    bool m_visualViewportEnabled { false };
     184    bool m_asyncFrameOrOverflowScrollingEnabled { false };
    179185};
    180186

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

    r240677 r240787  
    6666        const EventNames& names = eventNames();
    6767        IntPoint roundedPosition = roundedIntPoint(position);
     68
     69        // Event regions are affected by page scale, so no need to map through scale.
    6870        bool isSynchronousDispatchRegion = m_eventTrackingRegions.trackingTypeForPoint(names.wheelEvent, roundedPosition) == TrackingType::Synchronous
    6971            || m_eventTrackingRegions.trackingTypeForPoint(names.mousewheelEvent, roundedPosition) == TrackingType::Synchronous;
    … …  
    8486}
    8587
    86 void ScrollingTree::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
    87 {
    88     if (m_rootNode)
    89         downcast<ScrollingTreeScrollingNode>(*m_rootNode).handleWheelEvent(wheelEvent);
     88ScrollingEventResult ScrollingTree::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
     89{
     90    LOG_WITH_STREAM(Scrolling, stream << "ScrollingTree " << this << " handleWheelEvent (async scrolling enabled: " << asyncFrameOrOverflowScrollingEnabled() << ")");
     91
     92    if (!asyncFrameOrOverflowScrollingEnabled()) {
     93        if (m_rootNode)
     94            downcast<ScrollingTreeScrollingNode>(*m_rootNode).handleWheelEvent(wheelEvent);
     95        return ScrollingEventResult::DidNotHandleEvent;
     96    }
     97
     98    if (hasLatchedNode()) {
     99        auto* node = nodeForID(latchedNode());
     100        if (is<ScrollingTreeScrollingNode>(node))
     101            return downcast<ScrollingTreeScrollingNode>(*node).handleWheelEvent(wheelEvent);
     102    }
     103
     104    if (m_rootNode) {
     105        auto& frameScrollingNode = downcast<ScrollingTreeFrameScrollingNode>(*m_rootNode);
     106
     107        FloatPoint position = wheelEvent.position();
     108        ScrollingTreeNode* node = frameScrollingNode.scrollingNodeForPoint(LayoutPoint(position));
     109
     110        LOG_WITH_STREAM(Scrolling, stream << "ScrollingTree::handleWheelEvent found node " << (node ? node->scrollingNodeID() : 0) << " for point " << position << "\n");
     111
     112        while (node) {
     113            if (is<ScrollingTreeScrollingNode>(*node)) {
     114                auto& scrollingNode = downcast<ScrollingTreeScrollingNode>(*node);
     115                // FIXME: this needs to consult latching logic.
     116                if (scrollingNode.handleWheelEvent(wheelEvent) == ScrollingEventResult::DidHandleEvent)
     117                    return ScrollingEventResult::DidHandleEvent;
     118            }
     119            node = node->parent();
     120        }
     121    }
     122    return ScrollingEventResult::DidNotHandleEvent;
    90123}
    91124
    … …  
    116149    bool rootStateNodeChanged = scrollingStateTree->hasNewRootStateNode();
    117150   
    118     LOG(Scrolling, "\nScrollingTree::commitTreeState");
     151    LOG(Scrolling, "\nScrollingTree %p commitTreeState", this);
    119152   
    120153    auto* rootNode = scrollingStateTree->rootStateNode();
    … …  
    123156            || rootNode->hasChangedProperty(ScrollingStateFrameScrollingNode::EventTrackingRegion)
    124157            || rootNode->hasChangedProperty(ScrollingStateNode::ScrollLayer)
    125             || rootNode->hasChangedProperty(ScrollingStateFrameScrollingNode::VisualViewportEnabled))) {
     158            || rootNode->hasChangedProperty(ScrollingStateFrameScrollingNode::VisualViewportEnabled)
     159            || rootNode->hasChangedProperty(ScrollingStateFrameScrollingNode::AsyncFrameOrOverflowScrollingEnabled))) {
    126160        LockHolder lock(m_mutex);
    127161
    … …  
    134168        if (rootStateNodeChanged || rootNode->hasChangedProperty(ScrollingStateFrameScrollingNode::VisualViewportEnabled))
    135169            m_visualViewportEnabled = scrollingStateTree->rootStateNode()->visualViewportEnabled();
     170
     171        if (rootStateNodeChanged || rootNode->hasChangedProperty(ScrollingStateFrameScrollingNode::AsyncFrameOrOverflowScrollingEnabled))
     172            m_asyncFrameOrOverflowScrollingEnabled = scrollingStateTree->rootStateNode()->asyncFrameOrOverflowScrollingEnabled();
    136173    }
    137174   
    … …  
    224261}
    225262
     263void ScrollingTree::setAsyncFrameOrOverflowScrollingEnabled(bool enabled)
     264{
     265    LockHolder lock(m_mutex);
     266    m_asyncFrameOrOverflowScrollingEnabled = enabled;
     267}
     268
    226269void ScrollingTree::setMainFramePinState(bool pinnedToTheLeft, bool pinnedToTheRight, bool pinnedToTheTop, bool pinnedToTheBottom)
    227270{

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

    r240677 r240787  
    5151    WEBCORE_EXPORT virtual ~ScrollingTree();
    5252
    53     enum EventResult {
    54         DidNotHandleEvent,
    55         DidHandleEvent,
    56         SendToMainThread
    57     };
    58    
    5953    virtual bool isThreadedScrollingTree() const { return false; }
    6054    virtual bool isRemoteScrollingTree() const { return false; }
    … …  
    6357    bool visualViewportEnabled() const { return m_visualViewportEnabled; }
    6458
    65     virtual EventResult tryToHandleWheelEvent(const PlatformWheelEvent&) = 0;
     59    // This implies that we'll do hit-testing in the scrolling tree.
     60    bool asyncFrameOrOverflowScrollingEnabled() const { return m_asyncFrameOrOverflowScrollingEnabled; }
     61    void setAsyncFrameOrOverflowScrollingEnabled(bool);
     62
     63    virtual ScrollingEventResult tryToHandleWheelEvent(const PlatformWheelEvent&) = 0;
    6664    WEBCORE_EXPORT bool shouldHandleWheelEventSynchronously(const PlatformWheelEvent&);
    6765   
    … …  
    161159    void setVisualViewportEnabled(bool b) { m_visualViewportEnabled = b; }
    162160
    163     WEBCORE_EXPORT virtual void handleWheelEvent(const PlatformWheelEvent&);
     161    WEBCORE_EXPORT virtual ScrollingEventResult handleWheelEvent(const PlatformWheelEvent&);
    164162
    165163private:
    … …  
    197195    bool m_isHandlingProgrammaticScroll { false };
    198196    bool m_visualViewportEnabled { false };
     197    bool m_asyncFrameOrOverflowScrollingEnabled { false };
    199198};
    200199   

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

    r240713 r240787  
    6767}
    6868
     69LayoutPoint ScrollingTreeFrameHostingNode::parentToLocalPoint(LayoutPoint point) const
     70{
     71    return point - toLayoutSize(parentRelativeScrollableRect().location());
     72}
     73
    6974void ScrollingTreeFrameHostingNode::dumpProperties(TextStream& ts, ScrollingStateTreeAsTextBehavior behavior) const
    7075{

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

    r240713 r240787  
    4747    const LayoutRect& parentRelativeScrollableRect() const { return m_parentRelativeScrollableRect; }
    4848
     49    LayoutPoint parentToLocalPoint(LayoutPoint) const final;
     50
    4951    WEBCORE_EXPORT void dumpProperties(WTF::TextStream&, ScrollingStateTreeAsTextBehavior) const override;
    5052

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

    r240581 r240787  
    127127}
    128128
     129LayoutPoint ScrollingTreeFrameScrollingNode::parentToLocalPoint(LayoutPoint point) const
     130{
     131    return point - LayoutSize(0, headerHeight() + topContentInset());
     132}
     133
     134LayoutPoint ScrollingTreeFrameScrollingNode::localToContentsPoint(LayoutPoint point) const
     135{
     136    auto scrolledPoint = point + LayoutPoint(scrollPosition());
     137    return scrolledPoint.scaled(1 / frameScaleFactor());
     138}
     139
    129140void ScrollingTreeFrameScrollingNode::dumpProperties(TextStream& ts, ScrollingStateTreeAsTextBehavior behavior) const
    130141{

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

    r239689 r240787  
    4545    void updateLayersAfterAncestorChange(const ScrollingTreeNode& /*changedNode*/, const FloatRect& /*fixedPositionRect*/, const FloatSize& /*cumulativeDelta*/) override { }
    4646
    47     void handleWheelEvent(const PlatformWheelEvent&) override = 0;
     47    ScrollingEventResult handleWheelEvent(const PlatformWheelEvent&) override = 0;
    4848    void setScrollPosition(const FloatPoint&) override;
    4949    void setScrollPositionWithoutContentEdgeConstraints(const FloatPoint&) override = 0;
    … …  
    8181
    8282private:
     83    WEBCORE_EXPORT LayoutPoint parentToLocalPoint(LayoutPoint) const final;
     84    WEBCORE_EXPORT LayoutPoint localToContentsPoint(LayoutPoint) const final;
     85
    8386    WEBCORE_EXPORT void dumpProperties(WTF::TextStream&, ScrollingStateTreeAsTextBehavior) const override;
    8487

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

    r225480 r240787  
    9999}
    100100
     101ScrollingTreeScrollingNode* ScrollingTreeNode::scrollingNodeForPoint(LayoutPoint parentPoint) const
     102{
     103    LayoutPoint localPoint = parentToLocalPoint(parentPoint);
     104    LayoutPoint contentsPoint = localToContentsPoint(localPoint);
     105
     106    if (children()) {
     107        for (auto iterator = children()->rbegin(), end = children()->rend(); iterator != end; iterator++) {
     108            if (auto node = (**iterator).scrollingNodeForPoint(contentsPoint))
     109                return node;
     110        }
     111    }
     112
     113    return nullptr;
     114}
     115
    101116} // namespace WebCore
    102117

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

    r240579 r240787  
    4141class ScrollingStateScrollingNode;
    4242class ScrollingTreeFrameScrollingNode;
     43class ScrollingTreeScrollingNode;
    4344
    4445class ScrollingTreeNode : public RefCounted<ScrollingTreeNode> {
    … …  
    6566
    6667    Vector<RefPtr<ScrollingTreeNode>>* children() { return m_children.get(); }
     68    const Vector<RefPtr<ScrollingTreeNode>>* children() const { return m_children.get(); }
    6769
    6870    void appendChild(Ref<ScrollingTreeNode>&&);
    … …  
    7274
    7375    WEBCORE_EXPORT void dump(WTF::TextStream&, ScrollingStateTreeAsTextBehavior) const;
     76
     77    virtual LayoutPoint parentToLocalPoint(LayoutPoint point) const { return point; }
     78    virtual LayoutPoint localToContentsPoint(LayoutPoint point) const { return point; }
     79    virtual ScrollingTreeScrollingNode* scrollingNodeForPoint(LayoutPoint) const;
    7480
    7581protected:

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

    r240252 r240787  
    2929#if ENABLE(ASYNC_SCROLLING)
    3030
     31#include "Logging.h"
    3132#include "ScrollingStateScrollingNode.h"
    3233#include "ScrollingStateTree.h"
    … …  
    132133    FloatPoint contentSizePoint(totalContentsSize());
    133134    return FloatPoint(contentSizePoint - scrollableAreaSize()).expandedTo(FloatPoint());
     135}
     136
     137bool ScrollingTreeScrollingNode::scrollLimitReached(const PlatformWheelEvent& wheelEvent) const
     138{
     139    FloatPoint oldScrollPosition = scrollPosition();
     140    FloatPoint newScrollPosition = oldScrollPosition + FloatSize(wheelEvent.deltaX(), -wheelEvent.deltaY());
     141    newScrollPosition = newScrollPosition.constrainedBetween(minimumScrollPosition(), maximumScrollPosition());
     142    return newScrollPosition == oldScrollPosition;
     143}
     144
     145LayoutPoint ScrollingTreeScrollingNode::parentToLocalPoint(LayoutPoint point) const
     146{
     147    return point - toLayoutSize(parentRelativeScrollableRect().location());
     148}
     149
     150LayoutPoint ScrollingTreeScrollingNode::localToContentsPoint(LayoutPoint point) const
     151{
     152    return point + LayoutPoint(scrollPosition());
     153}
     154
     155ScrollingTreeScrollingNode* ScrollingTreeScrollingNode::scrollingNodeForPoint(LayoutPoint parentPoint) const
     156{
     157    if (auto* node = ScrollingTreeNode::scrollingNodeForPoint(parentPoint))
     158        return node;
     159
     160    if (parentRelativeScrollableRect().contains(parentPoint))
     161        return const_cast<ScrollingTreeScrollingNode*>(this);
     162
     163    return nullptr;
    134164}
    135165

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

    r239689 r240787  
    5656    WEBCORE_EXPORT void updateLayersAfterAncestorChange(const ScrollingTreeNode& changedNode, const FloatRect& fixedPositionRect, const FloatSize& cumulativeDelta) override;
    5757
    58     virtual void handleWheelEvent(const PlatformWheelEvent&) = 0;
     58    virtual ScrollingEventResult handleWheelEvent(const PlatformWheelEvent&) = 0;
    5959    WEBCORE_EXPORT virtual void setScrollPosition(const FloatPoint&);
    6060    WEBCORE_EXPORT virtual void setScrollPositionWithoutContentEdgeConstraints(const FloatPoint&);
    … …  
    7979
    8080    bool useDarkAppearanceForScrollbars() const { return m_scrollableAreaParameters.useDarkAppearanceForScrollbars; }
     81
     82    bool scrollLimitReached(const PlatformWheelEvent&) const;
     83    WEBCORE_EXPORT ScrollingTreeScrollingNode* scrollingNodeForPoint(LayoutPoint) const override;
    8184
    8285protected:
    … …  
    107110    bool canHaveScrollbars() const { return m_scrollableAreaParameters.horizontalScrollbarMode != ScrollbarAlwaysOff || m_scrollableAreaParameters.verticalScrollbarMode != ScrollbarAlwaysOff; }
    108111
     112    WEBCORE_EXPORT LayoutPoint parentToLocalPoint(LayoutPoint) const override;
     113    WEBCORE_EXPORT LayoutPoint localToContentsPoint(LayoutPoint) const override;
     114
    109115    WEBCORE_EXPORT void dumpProperties(WTF::TextStream&, ScrollingStateTreeAsTextBehavior) const override;
    110116

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

    r239427 r240787  
    4949}
    5050
    51 ScrollingTree::EventResult ThreadedScrollingTree::tryToHandleWheelEvent(const PlatformWheelEvent& wheelEvent)
     51ScrollingEventResult ThreadedScrollingTree::tryToHandleWheelEvent(const PlatformWheelEvent& wheelEvent)
    5252{
    5353    if (shouldHandleWheelEventSynchronously(wheelEvent))
    54         return SendToMainThread;
     54        return ScrollingEventResult::SendToMainThread;
    5555
    5656    if (willWheelEventStartSwipeGesture(wheelEvent))
    57         return DidNotHandleEvent;
     57        return ScrollingEventResult::DidNotHandleEvent;
    5858
    5959    RefPtr<ThreadedScrollingTree> protectedThis(this);
    … …  
    6262    });
    6363   
    64     return DidHandleEvent;
     64    return ScrollingEventResult::DidHandleEvent;
    6565}
    6666
    67 void ThreadedScrollingTree::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
     67ScrollingEventResult ThreadedScrollingTree::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
    6868{
    6969    ASSERT(ScrollingThread::isCurrentThread());
    70     ScrollingTree::handleWheelEvent(wheelEvent);
     70    return ScrollingTree::handleWheelEvent(wheelEvent);
    7171}
    7272

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

    r239427 r240787  
    4646    void commitTreeState(std::unique_ptr<ScrollingStateTree>) override;
    4747
    48     void handleWheelEvent(const PlatformWheelEvent&) override;
     48    ScrollingEventResult handleWheelEvent(const PlatformWheelEvent&) override;
    4949
    5050    // Can be called from any thread. Will try to handle the wheel event on the scrolling thread.
    5151    // Returns true if the wheel event can be handled on the scrolling thread and false if the
    5252    // event must be sent again to the WebCore event handler.
    53     EventResult tryToHandleWheelEvent(const PlatformWheelEvent&) override;
     53    ScrollingEventResult tryToHandleWheelEvent(const PlatformWheelEvent&) override;
    5454
    5555    void invalidate() override;

  • trunk/Source/WebCore/page/scrolling/ios/ScrollingCoordinatorIOS.h

    r237266 r240787  
    4848
    4949    // Handle the wheel event on the scrolling thread. Returns whether the event was handled or not.
    50     bool handleWheelEvent(FrameView&, const PlatformWheelEvent&) override { return false; }
     50    ScrollingEventResult handleWheelEvent(FrameView&, const PlatformWheelEvent&) override { return ScrollingEventResult::DidNotHandleEvent; }
    5151
    5252private:

  • trunk/Source/WebCore/page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.h

    r240162 r240787  
    4747    void commitStateAfterChildren(const ScrollingStateNode&) override;
    4848
    49     void handleWheelEvent(const PlatformWheelEvent&) override { }
     49    ScrollingEventResult handleWheelEvent(const PlatformWheelEvent&) override;
    5050
    5151    FloatPoint scrollPosition() const override;

  • trunk/Source/WebCore/page/scrolling/ios/ScrollingTreeFrameScrollingNodeIOS.mm

    r240162 r240787  
    9797}
    9898
     99ScrollingEventResult ScrollingTreeFrameScrollingNodeIOS::handleWheelEvent(const PlatformWheelEvent&)
     100{
     101    return ScrollingEventResult::DidNotHandleEvent;
     102}
     103
    99104FloatPoint ScrollingTreeFrameScrollingNodeIOS::scrollPosition() const
    100105{

  • trunk/Source/WebCore/page/scrolling/ios/ScrollingTreeIOS.h

    r239427 r240787  
    4646
    4747    // No wheel events on iOS
    48     void handleWheelEvent(const PlatformWheelEvent&) final { }
    49     EventResult tryToHandleWheelEvent(const PlatformWheelEvent&) final { return DidNotHandleEvent; }
     48    ScrollingEventResult handleWheelEvent(const PlatformWheelEvent&) final { return ScrollingEventResult::DidNotHandleEvent; }
     49    ScrollingEventResult tryToHandleWheelEvent(const PlatformWheelEvent&) final { return ScrollingEventResult::DidNotHandleEvent; }
    5050
    5151    void invalidate() final;

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

    r208179 r240787  
    4848
    4949    // Handle the wheel event on the scrolling thread. Returns whether the event was handled or not.
    50     bool handleWheelEvent(FrameView&, const PlatformWheelEvent&) override;
     50    ScrollingEventResult handleWheelEvent(FrameView&, const PlatformWheelEvent&) override;
    5151
    5252private:

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

    r230211 r240787  
    8383}
    8484
    85 bool ScrollingCoordinatorMac::handleWheelEvent(FrameView&, const PlatformWheelEvent& wheelEvent)
     85ScrollingEventResult ScrollingCoordinatorMac::handleWheelEvent(FrameView&, const PlatformWheelEvent& wheelEvent)
    8686{
    8787    ASSERT(isMainThread());
    … …  
    8989
    9090    if (scrollingTree()->willWheelEventStartSwipeGesture(wheelEvent))
    91         return false;
     91        return ScrollingEventResult::DidNotHandleEvent;
    9292
    9393    RefPtr<ThreadedScrollingTree> threadedScrollingTree = downcast<ThreadedScrollingTree>(scrollingTree());
    … …  
    9595        threadedScrollingTree->handleWheelEvent(wheelEvent);
    9696    });
    97     return true;
     97    return ScrollingEventResult::DidHandleEvent;
    9898}
    9999

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

    r239689 r240787  
    5252    void commitStateAfterChildren(const ScrollingStateNode&) override;
    5353
    54     void handleWheelEvent(const PlatformWheelEvent&) override;
     54    ScrollingEventResult handleWheelEvent(const PlatformWheelEvent&) override;
    5555
    5656    // ScrollController member functions.

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

    r240698 r240787  
    185185}
    186186
    187 void ScrollingTreeFrameScrollingNodeMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
     187ScrollingEventResult ScrollingTreeFrameScrollingNodeMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
    188188{
    189189    if (!canHaveScrollbars())
    190         return;
     190        return ScrollingEventResult::DidNotHandleEvent;
    191191
    192192    if (wheelEvent.momentumPhase() == PlatformWheelEventPhaseBegan) {
    … …  
    216216    scrollingTree().setOrClearLatchedNode(wheelEvent, scrollingNodeID());
    217217    scrollingTree().handleWheelEventPhase(wheelEvent.phase());
     218   
     219    // FIXME: This needs to return whether the event was handled.
     220    return ScrollingEventResult::DidHandleEvent;
    218221}
    219222

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

    r240105 r240787  
    5252    void updateLayersAfterAncestorChange(const WebCore::ScrollingTreeNode& changedNode, const WebCore::FloatRect& fixedPositionRect, const WebCore::FloatSize& cumulativeDelta) override;
    5353
    54     void handleWheelEvent(const WebCore::PlatformWheelEvent&) override { }
     54    ScrollingEventResult handleWheelEvent(const WebCore::PlatformWheelEvent&) override { return ScrollingEventResult::DidNotHandleEvent; }
    5555};
    5656

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

    r239667 r240787  
    6868}
    6969
    70 bool ScrollingCoordinatorNicosia::handleWheelEvent(FrameView&, const PlatformWheelEvent&)
     70ScrollingEventResult ScrollingCoordinatorNicosia::handleWheelEvent(FrameView&, const PlatformWheelEvent&)
    7171{
    72     return false;
     72    return ScrollingEventResult::DidNotHandleEvent;
    7373}
    7474

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

    r239667 r240787  
    4545    void commitTreeStateIfNeeded() override;
    4646
    47     bool handleWheelEvent(FrameView&, const PlatformWheelEvent&) override;
     47    ScrollingEventResult handleWheelEvent(FrameView&, const PlatformWheelEvent&) override;
    4848
    4949private:

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

    r239667 r240787  
    4545ScrollingTreeFrameScrollingNodeNicosia::~ScrollingTreeFrameScrollingNodeNicosia() = default;
    4646
    47 void ScrollingTreeFrameScrollingNodeNicosia::handleWheelEvent(const PlatformWheelEvent&)
     47ScrollingEventResult ScrollingTreeFrameScrollingNodeNicosia::handleWheelEvent(const PlatformWheelEvent&)
    4848{
     49    return ScrollingEventResult::DidNotHandleEvent;
    4950}
    5051

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

    r239667 r240787  
    4242    ScrollingTreeFrameScrollingNodeNicosia(ScrollingTree&, ScrollingNodeType, ScrollingNodeID);
    4343
    44     void handleWheelEvent(const PlatformWheelEvent&) override;
     44    ScrollingEventResult handleWheelEvent(const PlatformWheelEvent&) override;
    4545
    4646    FloatPoint scrollPosition() const override;

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

    r239667 r240787  
    3232
    3333#include "ScrollingTreeFixedNode.h"
     34#include "ScrollingTreeFrameHostingNode.h"
    3435#include "ScrollingTreeFrameScrollingNodeNicosia.h"
    3536#include "ScrollingTreeStickyNode.h"
    … …  
    5354    case ScrollingNodeType::Subframe:
    5455        return ScrollingTreeFrameScrollingNodeNicosia::create(*this, nodeType, nodeID);
     56    case ScrollingNodeType::FrameHosting:
     57        return ScrollingTreeFrameHostingNode::create(*this, nodeID);
    5558    case ScrollingNodeType::Overflow:
    5659        // Should not be reached -- caught by ASSERT_NOT_REACHED() below.

  • trunk/Source/WebKit/ChangeLog

    r240785 r240787  
     12019-01-30  Simon Fraser  <simon.fraser@apple.com>
     2
     3        [Mac] Implement basic hit testing in the scrolling tree
     4        https://bugs.webkit.org/show_bug.cgi?id=172917
     5        <rdar://problem/34215516>
     6
     7        Reviewed by Antti Koivisto.
     8
     9        Changed return types, "using namespace WebCore" in ScrollingTreeFrameScrollingNodeRemoteMac.cpp.
     10
     11        * Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp:
     12        (ArgumentCoder<ScrollingStateFrameScrollingNode>::encode):
     13        * UIProcess/RemoteLayerTree/ios/ScrollingTreeOverflowScrollingNodeIOS.h:
     14        * UIProcess/RemoteLayerTree/mac/ScrollerPairMac.h:
     15        * UIProcess/RemoteLayerTree/mac/ScrollerPairMac.mm:
     16        (WebKit::ScrollerPairMac::handleWheelEvent):
     17        (WebKit::ScrollerPairMac::handleMouseEvent):
     18        * UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.cpp:
     19        (WebKit::ScrollingTreeFrameScrollingNodeRemoteMac::handleWheelEvent):
     20        (WebKit::ScrollingTreeFrameScrollingNodeRemoteMac::handleMouseEvent):
     21        * UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.h:
     22
    1232019-01-31  Michael Catanzaro  <mcatanzaro@igalia.com>
    224

  • trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp

    r240713 r240787  
    159159    SCROLLING_NODE_ENCODE(ScrollingStateFrameScrollingNode::FixedElementsLayoutRelativeToFrame, fixedElementsLayoutRelativeToFrame)
    160160    SCROLLING_NODE_ENCODE(ScrollingStateFrameScrollingNode::VisualViewportEnabled, visualViewportEnabled)
     161    // AsyncFrameOrOverflowScrollingEnabled is not relevant for UI-side compositing.
    161162    SCROLLING_NODE_ENCODE(ScrollingStateFrameScrollingNode::LayoutViewport, layoutViewport)
    162163    SCROLLING_NODE_ENCODE(ScrollingStateFrameScrollingNode::MinLayoutViewportOrigin, minLayoutViewportOrigin)

  • trunk/Source/WebKit/UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.cpp

    r240579 r240787  
    152152bool RemoteScrollingCoordinatorProxy::handleWheelEvent(const PlatformWheelEvent& event)
    153153{
    154     ScrollingTree::EventResult result = m_scrollingTree->tryToHandleWheelEvent(event);
    155     return result == ScrollingTree::DidHandleEvent; // FIXME: handle other values.
     154    ScrollingEventResult result = m_scrollingTree->tryToHandleWheelEvent(event);
     155    return result == ScrollingEventResult::DidHandleEvent; // FIXME: handle other values.
    156156}
    157157

  • trunk/Source/WebKit/UIProcess/RemoteLayerTree/RemoteScrollingTree.cpp

    r240435 r240787  
    6060}
    6161
    62 ScrollingTree::EventResult RemoteScrollingTree::tryToHandleWheelEvent(const PlatformWheelEvent& wheelEvent)
     62ScrollingEventResult RemoteScrollingTree::tryToHandleWheelEvent(const PlatformWheelEvent& wheelEvent)
    6363{
    6464    if (shouldHandleWheelEventSynchronously(wheelEvent))
    65         return SendToMainThread;
     65        return ScrollingEventResult::SendToMainThread;
    6666
    6767    if (willWheelEventStartSwipeGesture(wheelEvent))
    68         return DidNotHandleEvent;
     68        return ScrollingEventResult::DidNotHandleEvent;
    6969
    7070    handleWheelEvent(wheelEvent);
    71     return DidHandleEvent;
     71    return ScrollingEventResult::DidHandleEvent;
    7272}
    7373

  • trunk/Source/WebKit/UIProcess/RemoteLayerTree/RemoteScrollingTree.h

    r239689 r240787  
    4646
    4747    bool isRemoteScrollingTree() const override { return true; }
    48     EventResult tryToHandleWheelEvent(const WebCore::PlatformWheelEvent&) override;
     48    WebCore::ScrollingEventResult tryToHandleWheelEvent(const WebCore::PlatformWheelEvent&) override;
    4949
    5050    void handleMouseEvent(const WebCore::PlatformMouseEvent&);

  • trunk/Source/WebKit/UIProcess/RemoteLayerTree/ios/ScrollingTreeOverflowScrollingNodeIOS.h

    r237266 r240787  
    5454    void updateLayersAfterAncestorChange(const WebCore::ScrollingTreeNode& changedNode, const WebCore::FloatRect& fixedPositionRect, const WebCore::FloatSize& cumulativeDelta) override;
    5555
    56     void handleWheelEvent(const WebCore::PlatformWheelEvent&) override { }
     56    WebCore::ScrollingEventResult handleWheelEvent(const WebCore::PlatformWheelEvent&) override { return ScrollingEventResult::DidNotHandleEvent; }
    5757
    5858    std::unique_ptr<ScrollingTreeScrollingNodeDelegateIOS> m_scrollingNodeDelegate;

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

    r239689 r240787  
    5353    ScrollerMac& horizontalScroller() { return m_horizontalScroller; }
    5454
    55     void handleWheelEvent(const WebCore::PlatformWheelEvent&);
    56     void handleMouseEvent(const WebCore::PlatformMouseEvent&);
     55    bool handleWheelEvent(const WebCore::PlatformWheelEvent&);
     56    bool handleMouseEvent(const WebCore::PlatformMouseEvent&);
    5757
    5858    void updateValues();

  • trunk/Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollerPairMac.mm

    r239689 r240787  
    142142}
    143143
    144 void ScrollerPairMac::handleWheelEvent(const WebCore::PlatformWheelEvent& event)
     144bool ScrollerPairMac::handleWheelEvent(const WebCore::PlatformWheelEvent& event)
    145145{
    146146    switch (event.phase()) {
    … …  
    159159        break;
    160160    }
    161 }
    162 
    163 void ScrollerPairMac::handleMouseEvent(const WebCore::PlatformMouseEvent& event)
     161    // FIXME: this needs to return whether the event was handled.
     162    return true;
     163}
     164
     165bool ScrollerPairMac::handleMouseEvent(const WebCore::PlatformMouseEvent& event)
    164166{
    165167    if (event.type() != WebCore::PlatformEvent::MouseMoved)
    166         return;
     168        return false;
    167169
    168170    m_lastKnownMousePosition = event.position();
    169171    [m_scrollerImpPair mouseMovedInContentArea];
     172    // FIXME: this needs to return whether the event was handled.
     173    return true;
    170174}
    171175

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

    r239689 r240787  
    3333
    3434namespace WebKit {
     35using namespace WebCore;
    3536
    36 ScrollingTreeFrameScrollingNodeRemoteMac::ScrollingTreeFrameScrollingNodeRemoteMac(WebCore::ScrollingTree& tree, WebCore::ScrollingNodeType nodeType, WebCore::ScrollingNodeID nodeID)
    37     : WebCore::ScrollingTreeFrameScrollingNodeMac(tree, nodeType, nodeID)
     37ScrollingTreeFrameScrollingNodeRemoteMac::ScrollingTreeFrameScrollingNodeRemoteMac(ScrollingTree& tree, ScrollingNodeType nodeType, ScrollingNodeID nodeID)
     38    : ScrollingTreeFrameScrollingNodeMac(tree, nodeType, nodeID)
    3839    , m_scrollerPair(std::make_unique<ScrollerPairMac>(*this))
    3940{
    … …  
    4445}
    4546
    46 Ref<ScrollingTreeFrameScrollingNodeRemoteMac> ScrollingTreeFrameScrollingNodeRemoteMac::create(WebCore::ScrollingTree& tree, WebCore::ScrollingNodeType nodeType, WebCore::ScrollingNodeID nodeID)
     47Ref<ScrollingTreeFrameScrollingNodeRemoteMac> ScrollingTreeFrameScrollingNodeRemoteMac::create(ScrollingTree& tree, ScrollingNodeType nodeType, ScrollingNodeID nodeID)
    4748{
    4849    return adoptRef(*new ScrollingTreeFrameScrollingNodeRemoteMac(tree, nodeType, nodeID));
    4950}
    5051
    51 void ScrollingTreeFrameScrollingNodeRemoteMac::commitStateBeforeChildren(const WebCore::ScrollingStateNode& stateNode)
     52void ScrollingTreeFrameScrollingNodeRemoteMac::commitStateBeforeChildren(const ScrollingStateNode& stateNode)
    5253{
    53     WebCore::ScrollingTreeFrameScrollingNodeMac::commitStateBeforeChildren(stateNode);
    54     const auto& scrollingStateNode = downcast<WebCore::ScrollingStateFrameScrollingNode>(stateNode);
     54    ScrollingTreeFrameScrollingNodeMac::commitStateBeforeChildren(stateNode);
     55    const auto& scrollingStateNode = downcast<ScrollingStateFrameScrollingNode>(stateNode);
    5556
    56     if (scrollingStateNode.hasChangedProperty(WebCore::ScrollingStateFrameScrollingNode::VerticalScrollbarLayer))
     57    if (scrollingStateNode.hasChangedProperty(ScrollingStateFrameScrollingNode::VerticalScrollbarLayer))
    5758        m_scrollerPair->verticalScroller().setHostLayer(scrollingStateNode.verticalScrollbarLayer());
    5859
    59     if (scrollingStateNode.hasChangedProperty(WebCore::ScrollingStateFrameScrollingNode::HorizontalScrollbarLayer))
     60    if (scrollingStateNode.hasChangedProperty(ScrollingStateFrameScrollingNode::HorizontalScrollbarLayer))
    6061        m_scrollerPair->horizontalScroller().setHostLayer(scrollingStateNode.horizontalScrollbarLayer());
    6162
    … …  
    6364}
    6465
    65 void ScrollingTreeFrameScrollingNodeRemoteMac::setScrollLayerPosition(const WebCore::FloatPoint& position, const WebCore::FloatRect& layoutViewport)
     66void ScrollingTreeFrameScrollingNodeRemoteMac::setScrollLayerPosition(const FloatPoint& position, const FloatRect& layoutViewport)
    6667{
    6768    ScrollingTreeFrameScrollingNodeMac::setScrollLayerPosition(position, layoutViewport);
    … …  
    7071}
    7172
    72 void ScrollingTreeFrameScrollingNodeRemoteMac::handleWheelEvent(const WebCore::PlatformWheelEvent& wheelEvent)
     73ScrollingEventResult ScrollingTreeFrameScrollingNodeRemoteMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
    7374{
    7475    ScrollingTreeFrameScrollingNodeMac::handleWheelEvent(wheelEvent);
    7576
    76     m_scrollerPair->handleWheelEvent(wheelEvent);
     77    return m_scrollerPair->handleWheelEvent(wheelEvent) ? ScrollingEventResult::DidHandleEvent : ScrollingEventResult::DidNotHandleEvent;
    7778}
    7879
    79 void ScrollingTreeFrameScrollingNodeRemoteMac::handleMouseEvent(const WebCore::PlatformMouseEvent& mouseEvent)
     80bool ScrollingTreeFrameScrollingNodeRemoteMac::handleMouseEvent(const PlatformMouseEvent& mouseEvent)
    8081{
    81     m_scrollerPair->handleMouseEvent(mouseEvent);
     82    return m_scrollerPair->handleMouseEvent(mouseEvent);
    8283}
    8384

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

    r239689 r240787  
    3939    virtual ~ScrollingTreeFrameScrollingNodeRemoteMac();
    4040
    41     void handleMouseEvent(const WebCore::PlatformMouseEvent&);
     41    bool handleMouseEvent(const WebCore::PlatformMouseEvent&);
    4242
    4343private:
    … …  
    4545
    4646    void commitStateBeforeChildren(const WebCore::ScrollingStateNode&) override;
    47     void handleWheelEvent(const WebCore::PlatformWheelEvent&) override;
     47    WebCore::ScrollingEventResult handleWheelEvent(const WebCore::PlatformWheelEvent&) override;
    4848    void setScrollLayerPosition(const WebCore::FloatPoint& position, const WebCore::FloatRect& layoutViewport) override;
    4949

  • trunk/Source/WebKit/WebProcess/WebPage/EventDispatcher.cpp

    r235236 r240787  
    123123            scrollingTree->setCanRubberBandState(canRubberBandAtLeft, canRubberBandAtRight, canRubberBandAtTop, canRubberBandAtBottom);
    124124
    125         ScrollingTree::EventResult result = scrollingTree->tryToHandleWheelEvent(platformWheelEvent);
    126 
    127         if (result == ScrollingTree::DidHandleEvent || result == ScrollingTree::DidNotHandleEvent) {
    128             sendDidReceiveEvent(pageID, wheelEvent, result == ScrollingTree::DidHandleEvent);
     125        ScrollingEventResult result = scrollingTree->tryToHandleWheelEvent(platformWheelEvent);
     126
     127        if (result == ScrollingEventResult::DidHandleEvent || result == ScrollingEventResult::DidNotHandleEvent) {
     128            sendDidReceiveEvent(pageID, wheelEvent, result == ScrollingEventResult::DidHandleEvent);
    129129            return;
    130130        }
Note: See TracChangeset for help on using the changeset viewer.