⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 242359 in webkit


Ignore:
Timestamp:
Mar 4, 2019, 8:57:38 AM (7 years ago)
Author:
Simon Fraser
Message:

Share more code between overflow and frame scrolling nodes, fixing overflow scrollbar display
​https://bugs.webkit.org/show_bug.cgi?id=195258

Reviewed by Antti Koivisto.

This patch moves management of scrollbar layers and scrollbar painters ("NSScrollerImp") down to
ScrollingStateScrollingNode to be shared between frame and overflow nodes, allowing for
scrolling thread updates of overflow scrollbars. It also moves some scrolling tree-side code
to ScrollingTreeScrollingNodeDelegateMac to be shared between the "tree" nodes for overflow and frames.

Layers for scrollbars are given to scrolling state nodes via setNodeLayers() now, and
RenderLayerCompositor::updateScrollingNodeLayers() is added to provide a bottleneck to call that.
At some point AsyncScrollingCoordinator::scrollableAreaScrollbarLayerDidChange() should be relieved
of the responsibility of pushing scrollbar layers (but the scrolling state tree needs to hold
references to GraphicsLayers before that becomes safe).

The actual fix that allows overflow scrollbars to show is the change in
AsyncScrollingCoordinator::scrollableAreaScrollbarLayerDidChange() that calls scrollableArea.*ScrollbarLayerDidChange()
for all ScrollableAreas. This ensures that the CALayer is pushed onto the NSScrollerImp.

Source/WebCore:

  • SourcesCocoa.txt:
  • WebCore.xcodeproj/project.pbxproj:
  • page/scrolling/AsyncScrollingCoordinator.cpp:

(WebCore::AsyncScrollingCoordinator::scrollableAreaScrollbarLayerDidChange):
(WebCore::AsyncScrollingCoordinator::setNodeLayers):
(WebCore::AsyncScrollingCoordinator::setFrameScrollingNodeState):
(WebCore::AsyncScrollingCoordinator::setScrollingNodeScrollableAreaGeometry):

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

(WebCore::ScrollingStateFrameScrollingNode::ScrollingStateFrameScrollingNode):
(WebCore::ScrollingStateFrameScrollingNode::setAllPropertiesChanged):
(WebCore::ScrollingStateFrameScrollingNode::setVerticalScrollbarLayer): Deleted.
(WebCore::ScrollingStateFrameScrollingNode::setHorizontalScrollbarLayer): Deleted.
(WebCore::ScrollingStateFrameScrollingNode::setScrollerImpsFromScrollbars): Deleted.

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

(WebCore::ScrollingStateScrollingNode::ScrollingStateScrollingNode):
(WebCore::ScrollingStateScrollingNode::setAllPropertiesChanged):
(WebCore::ScrollingStateScrollingNode::setHorizontalScrollbarLayer):
(WebCore::ScrollingStateScrollingNode::setVerticalScrollbarLayer):
(WebCore::ScrollingStateScrollingNode::setScrollerImpsFromScrollbars):

  • page/scrolling/ScrollingStateScrollingNode.h:

(WebCore::ScrollingStateScrollingNode::horizontalScrollbarLayer const):
(WebCore::ScrollingStateScrollingNode::verticalScrollbarLayer const):
(WebCore::ScrollingStateScrollingNode::verticalScrollerImp const):
(WebCore::ScrollingStateScrollingNode::horizontalScrollerImp const):

  • page/scrolling/ScrollingTree.cpp:

(WebCore::ScrollingTree::setOrClearLatchedNode):
(WebCore::ScrollingTree::handleWheelEvent):

  • page/scrolling/mac/ScrollingStateScrollingNodeMac.mm: Renamed from Source/WebCore/page/scrolling/mac/ScrollingStateFrameScrollingNodeMac.mm.

(WebCore::ScrollingStateScrollingNode::setScrollerImpsFromScrollbars):

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

(WebCore::ScrollingTreeFrameScrollingNodeMac::commitStateBeforeChildren):
(WebCore::ScrollingTreeFrameScrollingNodeMac::handleWheelEvent):
(WebCore::ScrollingTreeFrameScrollingNodeMac::repositionRelatedLayers):
(WebCore::ScrollingTreeFrameScrollingNodeMac::~ScrollingTreeFrameScrollingNodeMac): Deleted.
(WebCore::ScrollingTreeFrameScrollingNodeMac::releaseReferencesToScrollerImpsOnTheMainThread): Deleted.

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

(WebCore::ScrollingTreeOverflowScrollingNodeMac::commitStateBeforeChildren):
(WebCore::ScrollingTreeOverflowScrollingNodeMac::handleWheelEvent):
(WebCore::ScrollingTreeOverflowScrollingNodeMac::repositionRelatedLayers):

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

(WebCore::ScrollingTreeScrollingNodeDelegateMac::~ScrollingTreeScrollingNodeDelegateMac):
(WebCore::ScrollingTreeScrollingNodeDelegateMac::updateFromStateNode):
(WebCore::ScrollingTreeScrollingNodeDelegateMac::handleWheelEvent):
(WebCore::ScrollingTreeScrollingNodeDelegateMac::updateScrollbarPainters):
(WebCore::ScrollingTreeScrollingNodeDelegateMac::releaseReferencesToScrollerImpsOnTheMainThread):

  • platform/ScrollbarThemeComposite.h:
  • rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::didChangePlatformLayerForLayer):
(WebCore::RenderLayerCompositor::updateScrollingNodeLayers):
(WebCore::RenderLayerCompositor::updateScrollingNodeForScrollingRole):

  • rendering/RenderLayerCompositor.h:

Source/WebKit:

  • Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp:

(ArgumentCoder<ScrollingStateScrollingNode>::encode):
(ArgumentCoder<ScrollingStateFrameScrollingNode>::encode):
(ArgumentCoder<ScrollingStateScrollingNode>::decode):
(ArgumentCoder<ScrollingStateFrameScrollingNode>::decode):

  • SourcesCocoa.txt:
  • UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.cpp:

(WebKit::RemoteScrollingCoordinatorProxy::connectStateNodeLayers):

  • UIProcess/RemoteLayerTree/RemoteScrollingTree.cpp:

(WebKit::RemoteScrollingTree::createScrollingTreeNode):

  • UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.cpp:

(WebKit::ScrollingTreeFrameScrollingNodeRemoteMac::commitStateBeforeChildren):
(WebKit::ScrollingTreeFrameScrollingNodeRemoteMac::repositionRelatedLayers):
(WebKit::ScrollingTreeFrameScrollingNodeRemoteMac::handleMouseEvent):

  • UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.cpp: Copied from Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.cpp.

(WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::create):
(WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::ScrollingTreeOverflowScrollingNodeRemoteMac):
(WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::~ScrollingTreeOverflowScrollingNodeRemoteMac):
(WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::commitStateBeforeChildren):
(WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::repositionRelatedLayers):
(WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::handleWheelEvent):
(WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::handleMouseEvent):

  • WebKit.xcodeproj/project.pbxproj:
Location:
trunk/Source
Files:
26 edited
2 copied
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r242357 r242359  
     12019-03-04  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Share more code between overflow and frame scrolling nodes, fixing overflow scrollbar display
     4        https://bugs.webkit.org/show_bug.cgi?id=195258
     5
     6        Reviewed by Antti Koivisto.
     7
     8        This patch moves management of scrollbar layers and scrollbar painters ("NSScrollerImp") down to
     9        ScrollingStateScrollingNode to be shared between frame and overflow nodes, allowing for
     10        scrolling thread updates of overflow scrollbars. It also moves some scrolling tree-side code
     11        to ScrollingTreeScrollingNodeDelegateMac to be shared between the "tree" nodes for overflow and frames.
     12
     13        Layers for scrollbars are given to scrolling state nodes via setNodeLayers() now, and
     14        RenderLayerCompositor::updateScrollingNodeLayers() is added to provide a bottleneck to call that.
     15        At some point AsyncScrollingCoordinator::scrollableAreaScrollbarLayerDidChange() should be relieved
     16        of the responsibility of pushing scrollbar layers (but the scrolling state tree needs to hold
     17        references to GraphicsLayers before that becomes safe).
     18       
     19        The actual fix that allows overflow scrollbars to show is the change in
     20        AsyncScrollingCoordinator::scrollableAreaScrollbarLayerDidChange() that calls scrollableArea.*ScrollbarLayerDidChange()
     21        for all ScrollableAreas. This ensures that the CALayer is pushed onto the NSScrollerImp.
     22
     23        * SourcesCocoa.txt:
     24        * WebCore.xcodeproj/project.pbxproj:
     25        * page/scrolling/AsyncScrollingCoordinator.cpp:
     26        (WebCore::AsyncScrollingCoordinator::scrollableAreaScrollbarLayerDidChange):
     27        (WebCore::AsyncScrollingCoordinator::setNodeLayers):
     28        (WebCore::AsyncScrollingCoordinator::setFrameScrollingNodeState):
     29        (WebCore::AsyncScrollingCoordinator::setScrollingNodeScrollableAreaGeometry):
     30        * page/scrolling/ScrollingCoordinator.h:
     31        * page/scrolling/ScrollingStateFrameScrollingNode.cpp:
     32        (WebCore::ScrollingStateFrameScrollingNode::ScrollingStateFrameScrollingNode):
     33        (WebCore::ScrollingStateFrameScrollingNode::setAllPropertiesChanged):
     34        (WebCore::ScrollingStateFrameScrollingNode::setVerticalScrollbarLayer): Deleted.
     35        (WebCore::ScrollingStateFrameScrollingNode::setHorizontalScrollbarLayer): Deleted.
     36        (WebCore::ScrollingStateFrameScrollingNode::setScrollerImpsFromScrollbars): Deleted.
     37        * page/scrolling/ScrollingStateFrameScrollingNode.h:
     38        * page/scrolling/ScrollingStateScrollingNode.cpp:
     39        (WebCore::ScrollingStateScrollingNode::ScrollingStateScrollingNode):
     40        (WebCore::ScrollingStateScrollingNode::setAllPropertiesChanged):
     41        (WebCore::ScrollingStateScrollingNode::setHorizontalScrollbarLayer):
     42        (WebCore::ScrollingStateScrollingNode::setVerticalScrollbarLayer):
     43        (WebCore::ScrollingStateScrollingNode::setScrollerImpsFromScrollbars):
     44        * page/scrolling/ScrollingStateScrollingNode.h:
     45        (WebCore::ScrollingStateScrollingNode::horizontalScrollbarLayer const):
     46        (WebCore::ScrollingStateScrollingNode::verticalScrollbarLayer const):
     47        (WebCore::ScrollingStateScrollingNode::verticalScrollerImp const):
     48        (WebCore::ScrollingStateScrollingNode::horizontalScrollerImp const):
     49        * page/scrolling/ScrollingTree.cpp:
     50        (WebCore::ScrollingTree::setOrClearLatchedNode):
     51        (WebCore::ScrollingTree::handleWheelEvent):
     52        * page/scrolling/mac/ScrollingStateScrollingNodeMac.mm: Renamed from Source/WebCore/page/scrolling/mac/ScrollingStateFrameScrollingNodeMac.mm.
     53        (WebCore::ScrollingStateScrollingNode::setScrollerImpsFromScrollbars):
     54        * page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.h:
     55        * page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm:
     56        (WebCore::ScrollingTreeFrameScrollingNodeMac::commitStateBeforeChildren):
     57        (WebCore::ScrollingTreeFrameScrollingNodeMac::handleWheelEvent):
     58        (WebCore::ScrollingTreeFrameScrollingNodeMac::repositionRelatedLayers):
     59        (WebCore::ScrollingTreeFrameScrollingNodeMac::~ScrollingTreeFrameScrollingNodeMac): Deleted.
     60        (WebCore::ScrollingTreeFrameScrollingNodeMac::releaseReferencesToScrollerImpsOnTheMainThread): Deleted.
     61        * page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.h:
     62        * page/scrolling/mac/ScrollingTreeOverflowScrollingNodeMac.mm:
     63        (WebCore::ScrollingTreeOverflowScrollingNodeMac::commitStateBeforeChildren):
     64        (WebCore::ScrollingTreeOverflowScrollingNodeMac::handleWheelEvent):
     65        (WebCore::ScrollingTreeOverflowScrollingNodeMac::repositionRelatedLayers):
     66        * page/scrolling/mac/ScrollingTreeScrollingNodeDelegateMac.h:
     67        * page/scrolling/mac/ScrollingTreeScrollingNodeDelegateMac.mm:
     68        (WebCore::ScrollingTreeScrollingNodeDelegateMac::~ScrollingTreeScrollingNodeDelegateMac):
     69        (WebCore::ScrollingTreeScrollingNodeDelegateMac::updateFromStateNode):
     70        (WebCore::ScrollingTreeScrollingNodeDelegateMac::handleWheelEvent):
     71        (WebCore::ScrollingTreeScrollingNodeDelegateMac::updateScrollbarPainters):
     72        (WebCore::ScrollingTreeScrollingNodeDelegateMac::releaseReferencesToScrollerImpsOnTheMainThread):
     73        * platform/ScrollbarThemeComposite.h:
     74        * rendering/RenderLayerCompositor.cpp:
     75        (WebCore::RenderLayerCompositor::didChangePlatformLayerForLayer):
     76        (WebCore::RenderLayerCompositor::updateScrollingNodeLayers):
     77        (WebCore::RenderLayerCompositor::updateScrollingNodeForScrollingRole):
     78        * rendering/RenderLayerCompositor.h:
     79
    1802019-03-04  Jer Noble  <jer.noble@apple.com>
    281

  • trunk/Source/WebCore/SourcesCocoa.txt

    r242190 r242359  
    153153page/scrolling/mac/ScrollingCoordinatorMac.mm
    154154page/scrolling/mac/ScrollingMomentumCalculatorMac.mm
    155 page/scrolling/mac/ScrollingStateFrameScrollingNodeMac.mm
     155page/scrolling/mac/ScrollingStateScrollingNodeMac.mm
    156156page/scrolling/mac/ScrollingThreadMac.mm
    157157page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r242317 r242359  
    355355                0F6383DE18615B29003E5DB5 /* ThreadedScrollingTree.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F6383DC18615B29003E5DB5 /* ThreadedScrollingTree.h */; settings = {ATTRIBUTES = (Private, ); }; };
    356356                0F6A12BE1A00923700C6DE72 /* DebugPageOverlays.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F6A12BC1A00923700C6DE72 /* DebugPageOverlays.h */; settings = {ATTRIBUTES = (Private, ); }; };
     357                0F73B769222B3A0C00805316 /* ScrollingTreeOverflowScrollingNodeMac.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FC0516A219B5EBE0031C39E /* ScrollingTreeOverflowScrollingNodeMac.h */; settings = {ATTRIBUTES = (Private, ); }; };
    357358                0F7D07331884C56C00B4AF86 /* PlatformTextTrack.h in Headers */ = {isa = PBXBuildFile; fileRef = 072847E216EBC5B00043CFA4 /* PlatformTextTrack.h */; settings = {ATTRIBUTES = (Private, ); }; };
    358359                0F850FE31ED7C18300FB77A7 /* PerformanceLoggingClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F850FE21ED7C18300FB77A7 /* PerformanceLoggingClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    57865787                0F6A12BC1A00923700C6DE72 /* DebugPageOverlays.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DebugPageOverlays.h; sourceTree = "<group>"; };
    57875788                0F70495D211B524200369968 /* ActivityState.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = ActivityState.cpp; sourceTree = "<group>"; };
     5789                0F73B765222B327F00805316 /* ScrollingStateScrollingNodeMac.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = ScrollingStateScrollingNodeMac.mm; sourceTree = "<group>"; };
    57885790                0F7DF1471E2BF1A60095951B /* WebCoreJSClientData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebCoreJSClientData.cpp; sourceTree = "<group>"; };
    57895791                0F850FE21ED7C18300FB77A7 /* PerformanceLoggingClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PerformanceLoggingClient.h; sourceTree = "<group>"; };
    … …  
    58055807                0FA24D77162DF91900A3F4C0 /* GraphicsLayerUpdater.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = GraphicsLayerUpdater.cpp; sourceTree = "<group>"; };
    58065808                0FA24D78162DF91900A3F4C0 /* GraphicsLayerUpdater.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GraphicsLayerUpdater.h; sourceTree = "<group>"; };
    5807                 0FA88EBC16A8D1BD00F99984 /* ScrollingStateFrameScrollingNodeMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ScrollingStateFrameScrollingNodeMac.mm; sourceTree = "<group>"; };
    58085809                0FB6252C18DE1B1500A07C05 /* GeometryUtilities.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = GeometryUtilities.cpp; sourceTree = "<group>"; };
    58095810                0FB6252D18DE1B1500A07C05 /* GeometryUtilities.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GeometryUtilities.h; sourceTree = "<group>"; };
    … …  
    1698616987                                517DEEE71DE94B0800B91644 /* ScrollingMomentumCalculatorMac.h */,
    1698716988                                517DEEE31DE94ADC00B91644 /* ScrollingMomentumCalculatorMac.mm */,
    16988                                 0FA88EBC16A8D1BD00F99984 /* ScrollingStateFrameScrollingNodeMac.mm */,
     16989                                0F73B765222B327F00805316 /* ScrollingStateScrollingNodeMac.mm */,
    1698916990                                1AF62F2314DAFE910041556C /* ScrollingThreadMac.mm */,
    1699016991                                93C4A4131629DF5A00C3EB6E /* ScrollingTreeFrameScrollingNodeMac.h */,
    … …  
    3150431505                                1AAADDE414DC8C8F00AF64B3 /* ScrollingTreeNode.h in Headers */,
    3150531506                                0FEA3E80191B3169000F1B55 /* ScrollingTreeOverflowScrollingNode.h in Headers */,
     31507                                0F73B769222B3A0C00805316 /* ScrollingTreeOverflowScrollingNodeMac.h in Headers */,
    3150631508                                9391A99D1629D70000297330 /* ScrollingTreeScrollingNode.h in Headers */,
    3150731509                                A6D5A99D1629D70000297330 /* ScrollingTreeScrollingNodeDelegate.h in Headers */,

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

    r242333 r242359  
    457457
    458458    auto* node = m_scrollingStateTree->stateNodeForID(scrollableArea.scrollingNodeID());
    459     if (is<ScrollingStateFrameScrollingNode>(node)) {
    460         auto& scrollingNode = downcast<ScrollingStateFrameScrollingNode>(*node);
     459    if (is<ScrollingStateScrollingNode>(node)) {
     460        auto& scrollingNode = downcast<ScrollingStateScrollingNode>(*node);
    461461        if (orientation == VerticalScrollbar)
    462462            scrollingNode.setVerticalScrollbarLayer(scrollableArea.layerForVerticalScrollbar());
    … …  
    465465    }
    466466
    467     if (&scrollableArea == m_page->mainFrame().view()) {
    468         if (orientation == VerticalScrollbar)
    469             scrollableArea.verticalScrollbarLayerDidChange();
    470         else
    471             scrollableArea.horizontalScrollbarLayerDidChange();
    472     }
     467    if (orientation == VerticalScrollbar)
     468        scrollableArea.verticalScrollbarLayerDidChange();
     469    else
     470        scrollableArea.horizontalScrollbarLayerDidChange();
    473471}
    474472
    … …  
    568566        scrollingNode.setScrollContainerLayer(nodeLayers.scrollContainerLayer);
    569567        scrollingNode.setScrolledContentsLayer(nodeLayers.scrolledContentsLayer);
     568        scrollingNode.setHorizontalScrollbarLayer(nodeLayers.horizontalScrollbarLayer);
     569        scrollingNode.setVerticalScrollbarLayer(nodeLayers.verticalScrollbarLayer);
    570570
    571571        if (is<ScrollingStateFrameScrollingNode>(node)) {
    … …  
    606606    auto& frameScrollingNode = downcast<ScrollingStateFrameScrollingNode>(*stateNode);
    607607
    608     auto* verticalScrollbar = frameView.verticalScrollbar();
    609     auto* horizontalScrollbar = frameView.horizontalScrollbar();
    610     frameScrollingNode.setScrollerImpsFromScrollbars(verticalScrollbar, horizontalScrollbar);
    611 
    612608    frameScrollingNode.setFrameScaleFactor(frameView.frame().frameScaleFactor());
    613609    frameScrollingNode.setHeaderHeight(frameView.headerHeight());
    … …  
    632628
    633629    auto& scrollingNode = downcast<ScrollingStateScrollingNode>(*stateNode);
     630
     631    auto* verticalScrollbar = scrollableArea.verticalScrollbar();
     632    auto* horizontalScrollbar = scrollableArea.horizontalScrollbar();
     633    scrollingNode.setScrollerImpsFromScrollbars(verticalScrollbar, horizontalScrollbar);
     634
    634635    scrollingNode.setScrollOrigin(scrollableArea.scrollOrigin());
    635636    scrollingNode.setScrollPosition(scrollableArea.scrollPosition());
    … …  
    637638    scrollingNode.setReachableContentsSize(scrollableArea.reachableTotalContentsSize());
    638639    scrollingNode.setScrollableAreaSize(scrollableArea.visibleSize());
    639 
    640     auto* verticalScrollbar = scrollableArea.verticalScrollbar();
    641     auto* horizontalScrollbar = scrollableArea.horizontalScrollbar();
    642640
    643641    ScrollableAreaParameters scrollParameters;

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

    r242333 r242359  
    137137        GraphicsLayer* insetClipLayer { nullptr };
    138138        GraphicsLayer* rootContentsLayer { nullptr };
     139        GraphicsLayer* horizontalScrollbarLayer { nullptr };
     140        GraphicsLayer* verticalScrollbarLayer { nullptr };
    139141    };
    140142    virtual void setNodeLayers(ScrollingNodeID, const NodeLayers&) { }

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

    r241934 r242359  
    4747ScrollingStateFrameScrollingNode::ScrollingStateFrameScrollingNode(const ScrollingStateFrameScrollingNode& stateNode, ScrollingStateTree& adoptiveTree)
    4848    : ScrollingStateScrollingNode(stateNode, adoptiveTree)
    49 #if PLATFORM(MAC)
    50     , m_verticalScrollerImp(stateNode.verticalScrollerImp())
    51     , m_horizontalScrollerImp(stateNode.horizontalScrollerImp())
    52 #endif
    5349    , m_eventTrackingRegions(stateNode.eventTrackingRegions())
    5450    , m_requestedScrollPosition(stateNode.requestedScrollPosition())
    … …  
    8379    if (hasChangedProperty(FooterLayer))
    8480        setFooterLayer(stateNode.footerLayer().toRepresentation(adoptiveTree.preferredLayerRepresentation()));
    85 
    86     if (hasChangedProperty(VerticalScrollbarLayer))
    87         setVerticalScrollbarLayer(stateNode.verticalScrollbarLayer().toRepresentation(adoptiveTree.preferredLayerRepresentation()));
    88 
    89     if (hasChangedProperty(HorizontalScrollbarLayer))
    90         setHorizontalScrollbarLayer(stateNode.horizontalScrollbarLayer().toRepresentation(adoptiveTree.preferredLayerRepresentation()));
    9181}
    9282
    … …  
    112102    setPropertyChangedBit(HeaderLayer);
    113103    setPropertyChangedBit(FooterLayer);
    114     setPropertyChangedBit(VerticalScrollbarLayer);
    115     setPropertyChangedBit(HorizontalScrollbarLayer);
    116     setPropertyChangedBit(PainterForScrollbar);
    117104    setPropertyChangedBit(BehaviorForFixedElements);
    118105    setPropertyChangedBit(TopContentInset);
    … …  
    271258}
    272259
    273 void ScrollingStateFrameScrollingNode::setVerticalScrollbarLayer(const LayerRepresentation& layer)
    274 {
    275     if (layer == m_verticalScrollbarLayer)
    276         return;
    277 
    278     m_verticalScrollbarLayer = layer;
    279     setPropertyChanged(VerticalScrollbarLayer);
    280 }
    281 
    282 void ScrollingStateFrameScrollingNode::setHorizontalScrollbarLayer(const LayerRepresentation& layer)
    283 {
    284     if (layer == m_horizontalScrollbarLayer)
    285         return;
    286 
    287     m_horizontalScrollbarLayer = layer;
    288     setPropertyChanged(HorizontalScrollbarLayer);
    289 }
    290 
    291260void ScrollingStateFrameScrollingNode::setFixedElementsLayoutRelativeToFrame(bool fixedElementsLayoutRelativeToFrame)
    292261{
    … …  
    306275    setPropertyChanged(AsyncFrameOrOverflowScrollingEnabled);
    307276}
    308 
    309 #if !PLATFORM(MAC)
    310 void ScrollingStateFrameScrollingNode::setScrollerImpsFromScrollbars(Scrollbar*, Scrollbar*)
    311 {
    312 }
    313 #endif
    314277
    315278void ScrollingStateFrameScrollingNode::dumpProperties(TextStream& ts, ScrollingStateTreeAsTextBehavior behavior) const

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

    r241934 r242359  
    5959        HeaderLayer,
    6060        FooterLayer,
    61         VerticalScrollbarLayer,
    62         HorizontalScrollbarLayer,
    63         PainterForScrollbar,
    6461        BehaviorForFixedElements,
    6562        TopContentInset,
    … …  
    126123    WEBCORE_EXPORT void setFooterLayer(const LayerRepresentation&);
    127124
    128     const LayerRepresentation& verticalScrollbarLayer() const { return m_verticalScrollbarLayer; }
    129     WEBCORE_EXPORT void setVerticalScrollbarLayer(const LayerRepresentation&);
    130 
    131     const LayerRepresentation& horizontalScrollbarLayer() const { return m_horizontalScrollbarLayer; }
    132     WEBCORE_EXPORT void setHorizontalScrollbarLayer(const LayerRepresentation&);
    133 
    134125    // These are more like Settings, and should probably move to the Scrolling{State}Tree itself.
    135126    bool fixedElementsLayoutRelativeToFrame() const { return m_fixedElementsLayoutRelativeToFrame; }
    … …  
    138129    bool asyncFrameOrOverflowScrollingEnabled() const { return m_asyncFrameOrOverflowScrollingEnabled; }
    139130    void setAsyncFrameOrOverflowScrollingEnabled(bool);
    140 
    141 #if PLATFORM(MAC)
    142     NSScrollerImp *verticalScrollerImp() const { return m_verticalScrollerImp.get(); }
    143     NSScrollerImp *horizontalScrollerImp() const { return m_horizontalScrollerImp.get(); }
    144 #endif
    145     void setScrollerImpsFromScrollbars(Scrollbar* verticalScrollbar, Scrollbar* horizontalScrollbar);
    146131
    147132    void dumpProperties(WTF::TextStream&, ScrollingStateTreeAsTextBehavior) const override;
    … …  
    159144    LayerRepresentation m_headerLayer;
    160145    LayerRepresentation m_footerLayer;
    161     LayerRepresentation m_verticalScrollbarLayer;
    162     LayerRepresentation m_horizontalScrollbarLayer;
    163 
    164 #if PLATFORM(MAC)
    165     RetainPtr<NSScrollerImp> m_verticalScrollerImp;
    166     RetainPtr<NSScrollerImp> m_horizontalScrollerImp;
    167 #endif
    168146
    169147    EventTrackingRegions m_eventTrackingRegions;

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

    r240861 r242359  
    5151    , m_snapOffsetsInfo(stateNode.m_snapOffsetsInfo)
    5252#endif
     53#if PLATFORM(MAC)
     54    , m_verticalScrollerImp(stateNode.verticalScrollerImp())
     55    , m_horizontalScrollerImp(stateNode.horizontalScrollerImp())
     56#endif
    5357    , m_scrollableAreaParameters(stateNode.scrollableAreaParameters())
    5458    , m_requestedScrollPositionRepresentsProgrammaticScroll(stateNode.requestedScrollPositionRepresentsProgrammaticScroll())
    … …  
    5761    if (hasChangedProperty(ScrollContainerLayer))
    5862        setScrollContainerLayer(stateNode.scrollContainerLayer().toRepresentation(adoptiveTree.preferredLayerRepresentation()));
     63
    5964    if (hasChangedProperty(ScrolledContentsLayer))
    6065        setScrolledContentsLayer(stateNode.scrolledContentsLayer().toRepresentation(adoptiveTree.preferredLayerRepresentation()));
     66
     67    if (hasChangedProperty(VerticalScrollbarLayer))
     68        setVerticalScrollbarLayer(stateNode.verticalScrollbarLayer().toRepresentation(adoptiveTree.preferredLayerRepresentation()));
     69
     70    if (hasChangedProperty(HorizontalScrollbarLayer))
     71        setHorizontalScrollbarLayer(stateNode.horizontalScrollbarLayer().toRepresentation(adoptiveTree.preferredLayerRepresentation()));
    6172}
    6273
    … …  
    8495    setPropertyChangedBit(ScrollContainerLayer);
    8596    setPropertyChangedBit(ScrolledContentsLayer);
     97    setPropertyChangedBit(HorizontalScrollbarLayer);
     98    setPropertyChangedBit(VerticalScrollbarLayer);
     99    setPropertyChangedBit(PainterForScrollbar);
    86100
    87101    ScrollingStateNode::setAllPropertiesChanged();
    … …  
    240254    setPropertyChanged(ScrolledContentsLayer);
    241255}
     256
     257void ScrollingStateScrollingNode::setHorizontalScrollbarLayer(const LayerRepresentation& layer)
     258{
     259    if (layer == m_horizontalScrollbarLayer)
     260        return;
     261
     262    m_horizontalScrollbarLayer = layer;
     263    setPropertyChanged(HorizontalScrollbarLayer);
     264}
     265
     266void ScrollingStateScrollingNode::setVerticalScrollbarLayer(const LayerRepresentation& layer)
     267{
     268    if (layer == m_verticalScrollbarLayer)
     269        return;
     270
     271    m_verticalScrollbarLayer = layer;
     272    setPropertyChanged(VerticalScrollbarLayer);
     273}
     274
     275#if !PLATFORM(MAC)
     276void ScrollingStateScrollingNode::setScrollerImpsFromScrollbars(Scrollbar*, Scrollbar*)
     277{
     278}
     279#endif
    242280
    243281void ScrollingStateScrollingNode::dumpProperties(TextStream& ts, ScrollingStateTreeAsTextBehavior behavior) const

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

    r240861 r242359  
    3333#include "ScrollingStateNode.h"
    3434
     35#if PLATFORM(COCOA)
     36OBJC_CLASS NSScrollerImp;
     37#endif
     38
    3539namespace WebCore {
    3640
    … …  
    5963        ScrollContainerLayer,
    6064        ScrolledContentsLayer,
     65        HorizontalScrollbarLayer,
     66        VerticalScrollbarLayer,
     67        PainterForScrollbar,
    6168        NumScrollingStateNodeBits // This must remain at the last position.
    6269    };
    … …  
    117124    WEBCORE_EXPORT void setScrolledContentsLayer(const LayerRepresentation&);
    118125
     126    const LayerRepresentation& horizontalScrollbarLayer() const { return m_horizontalScrollbarLayer; }
     127    WEBCORE_EXPORT void setHorizontalScrollbarLayer(const LayerRepresentation&);
     128
     129    const LayerRepresentation& verticalScrollbarLayer() const { return m_verticalScrollbarLayer; }
     130    WEBCORE_EXPORT void setVerticalScrollbarLayer(const LayerRepresentation&);
     131
     132#if PLATFORM(MAC)
     133    NSScrollerImp *verticalScrollerImp() const { return m_verticalScrollerImp.get(); }
     134    NSScrollerImp *horizontalScrollerImp() const { return m_horizontalScrollerImp.get(); }
     135#endif
     136    void setScrollerImpsFromScrollbars(Scrollbar* verticalScrollbar, Scrollbar* horizontalScrollbar);
     137
    119138protected:
    120139    ScrollingStateScrollingNode(ScrollingStateTree&, ScrollingNodeType, ScrollingNodeID);
    … …  
    133152    FloatPoint m_requestedScrollPosition;
    134153    IntPoint m_scrollOrigin;
     154
    135155#if ENABLE(CSS_SCROLL_SNAP)
    136156    ScrollSnapOffsetsInfo<float> m_snapOffsetsInfo;
    … …  
    138158    unsigned m_currentVerticalSnapPointIndex { 0 };
    139159#endif
    140     ScrollableAreaParameters m_scrollableAreaParameters;
     160
    141161    LayerRepresentation m_scrollContainerLayer;
    142162    LayerRepresentation m_scrolledContentsLayer;
     163    LayerRepresentation m_horizontalScrollbarLayer;
     164    LayerRepresentation m_verticalScrollbarLayer;
     165
     166#if PLATFORM(MAC)
     167    RetainPtr<NSScrollerImp> m_verticalScrollerImp;
     168    RetainPtr<NSScrollerImp> m_horizontalScrollerImp;
     169#endif
     170
     171    ScrollableAreaParameters m_scrollableAreaParameters;
     172
    143173    bool m_requestedScrollPositionRepresentsProgrammaticScroll { false };
    144174    bool m_expectsWheelEventTestTrigger { false };

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

    r242313 r242359  
    8181void ScrollingTree::setOrClearLatchedNode(const PlatformWheelEvent& wheelEvent, ScrollingNodeID nodeID)
    8282{
    83     if (wheelEvent.shouldConsiderLatching())
     83    if (wheelEvent.shouldConsiderLatching()) {
     84        LOG_WITH_STREAM(Scrolling, stream << "ScrollingTree " << this << " setOrClearLatchedNode: setting latched node " << nodeID);
    8485        setLatchedNode(nodeID);
    85     else if (wheelEvent.shouldResetLatching())
     86    } else if (wheelEvent.shouldResetLatching()) {
     87        LOG_WITH_STREAM(Scrolling, stream << "ScrollingTree " << this << " setOrClearLatchedNode: clearing latched node (was " << latchedNode() << ")");
    8688        clearLatchedNode();
     89    }
    8790}
    8891
    … …  
    98101
    99102    if (hasLatchedNode()) {
     103        LOG_WITH_STREAM(Scrolling, stream << " has latched node " << latchedNode());
    100104        auto* node = nodeForID(latchedNode());
    101105        if (is<ScrollingTreeScrollingNode>(node))

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

    r242358 r242359  
    11/*
    2  * Copyright (C) 2013 Apple Inc. All rights reserved.
     2 * Copyright (C) 2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2525
    2626#include "config.h"
    27 #include "ScrollingStateFrameScrollingNode.h"
     27#include "ScrollingStateScrollingNode.h"
    2828
    2929#if ENABLE(ASYNC_SCROLLING) && PLATFORM(MAC)
    … …  
    3636namespace WebCore {
    3737
    38 void ScrollingStateFrameScrollingNode::setScrollerImpsFromScrollbars(Scrollbar* verticalScrollbar, Scrollbar* horizontalScrollbar)
     38void ScrollingStateScrollingNode::setScrollerImpsFromScrollbars(Scrollbar* verticalScrollbar, Scrollbar* horizontalScrollbar)
    3939{
    4040    ScrollbarTheme& scrollbarTheme = ScrollbarTheme::theme();

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

    r242132 r242359  
    4646    ScrollingTreeFrameScrollingNodeMac(ScrollingTree&, ScrollingNodeType, ScrollingNodeID);
    4747
    48     void releaseReferencesToScrollerImpsOnTheMainThread();
    49 
    5048    // ScrollingTreeNode member functions.
    5149    void commitStateBeforeChildren(const ScrollingStateNode&) override;
    … …  
    6967    void repositionScrollingLayers() override;
    7068
     69    ScrollingTreeScrollingNodeDelegateMac m_delegate;
     70
    7171    RetainPtr<CALayer> m_rootContentsLayer;
    7272    RetainPtr<CALayer> m_counterScrollingLayer;
    … …  
    7575    RetainPtr<CALayer> m_headerLayer;
    7676    RetainPtr<CALayer> m_footerLayer;
    77     RetainPtr<NSScrollerImp> m_verticalScrollerImp;
    78     RetainPtr<NSScrollerImp> m_horizontalScrollerImp;
    79 
    80     ScrollingTreeScrollingNodeDelegateMac m_delegate;
    8177   
    8278    bool m_lastScrollHadUnfilledPixels { false };

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

    r242132 r242359  
    3939#import "TileController.h"
    4040#import "WebLayer.h"
    41 #import <pal/spi/mac/NSScrollerImpSPI.h>
    42 #import <wtf/text/TextStream.h>
    43 
    4441#import <QuartzCore/QuartzCore.h>
    4542#import <wtf/Deque.h>
    4643#import <wtf/text/CString.h>
     44#import <wtf/text/TextStream.h>
    4745
    4846namespace WebCore {
    … …  
    5957}
    6058
    61 ScrollingTreeFrameScrollingNodeMac::~ScrollingTreeFrameScrollingNodeMac()
    62 {
    63     releaseReferencesToScrollerImpsOnTheMainThread();
    64 }
    65 
    66 void ScrollingTreeFrameScrollingNodeMac::releaseReferencesToScrollerImpsOnTheMainThread()
    67 {
    68     if (m_verticalScrollerImp || m_horizontalScrollerImp) {
    69         // FIXME: This is a workaround in place for the time being since NSScrollerImps cannot be deallocated
    70         // on a non-main thread. rdar://problem/24535055
    71         WTF::callOnMainThread([verticalScrollerImp = WTFMove(m_verticalScrollerImp), horizontalScrollerImp = WTFMove(m_horizontalScrollerImp)] {
    72         });
    73     }
    74 }
     59ScrollingTreeFrameScrollingNodeMac::~ScrollingTreeFrameScrollingNodeMac() = default;
    7560
    7661#if ENABLE(CSS_SCROLL_SNAP)
    … …  
    119104        m_footerLayer = scrollingStateNode.footerLayer();
    120105
    121     if (scrollingStateNode.hasChangedProperty(ScrollingStateFrameScrollingNode::PainterForScrollbar)) {
    122         releaseReferencesToScrollerImpsOnTheMainThread();
    123         m_verticalScrollerImp = scrollingStateNode.verticalScrollerImp();
    124         m_horizontalScrollerImp = scrollingStateNode.horizontalScrollerImp();
    125     }
    126 
    127106    bool logScrollingMode = !m_hadFirstUpdate;
    128107    if (scrollingStateNode.hasChangedProperty(ScrollingStateFrameScrollingNode::ReasonsForSynchronousScrolling))
    … …  
    132111        scrollingTree().reportSynchronousScrollingReasonsChanged(MonotonicTime::now(), synchronousScrollingReasons());
    133112
     113    m_delegate.updateFromStateNode(scrollingStateNode);
     114
    134115#if ENABLE(CSS_SCROLL_SNAP)
     116    // FIXME: this should move to the delegate and be shared with overflow.
    135117    if (scrollingStateNode.hasChangedProperty(ScrollingStateFrameScrollingNode::HorizontalSnapOffsets) || scrollingStateNode.hasChangedProperty(ScrollingStateFrameScrollingNode::HorizontalSnapOffsetRanges))
    136118        m_delegate.updateScrollSnapPoints(ScrollEventAxis::Horizontal, convertToLayoutUnits(scrollingStateNode.horizontalSnapOffsets()), convertToLayoutUnits(scrollingStateNode.horizontalSnapOffsetRanges()));
    … …  
    170152    if (!canHaveScrollbars())
    171153        return ScrollingEventResult::DidNotHandleEvent;
    172 
    173     if (wheelEvent.momentumPhase() == PlatformWheelEventPhaseBegan) {
    174         [m_verticalScrollerImp setUsePresentationValue:YES];
    175         [m_horizontalScrollerImp setUsePresentationValue:YES];
    176     }
    177     if (wheelEvent.momentumPhase() == PlatformWheelEventPhaseEnded || wheelEvent.momentumPhase() == PlatformWheelEventPhaseCancelled) {
    178         [m_verticalScrollerImp setUsePresentationValue:NO];
    179         [m_horizontalScrollerImp setUsePresentationValue:NO];
    180     }
    181 
    182 #if ENABLE(CSS_SCROLL_SNAP) || ENABLE(RUBBER_BANDING)
    183     if (expectsWheelEventTestTrigger()) {
    184         if (scrollingTree().shouldHandleWheelEventSynchronously(wheelEvent))
    185             m_delegate.removeTestDeferralForReason(reinterpret_cast<WheelEventTestTrigger::ScrollableAreaIdentifier>(scrollingNodeID()), WheelEventTestTrigger::ScrollingThreadSyncNeeded);
    186         else
    187             m_delegate.deferTestsForReason(reinterpret_cast<WheelEventTestTrigger::ScrollableAreaIdentifier>(scrollingNodeID()), WheelEventTestTrigger::ScrollingThreadSyncNeeded);
    188     }
    189 #endif
    190154
    191155    m_delegate.handleWheelEvent(wheelEvent);
    … …  
    267231    }
    268232
    269     if (m_verticalScrollerImp || m_horizontalScrollerImp) {
    270         [CATransaction begin];
    271         [CATransaction lock];
    272 
    273         if ([m_verticalScrollerImp shouldUsePresentationValue]) {
    274             float presentationValue;
    275             float overhangAmount;
    276             ScrollableArea::computeScrollbarValueAndOverhang(scrollPosition.y(), totalContentsSize().height(), visibleContentRect.height(), presentationValue, overhangAmount);
    277             [m_verticalScrollerImp setPresentationValue:presentationValue];
    278         }
    279 
    280         if ([m_horizontalScrollerImp shouldUsePresentationValue]) {
    281             float presentationValue;
    282             float overhangAmount;
    283             ScrollableArea::computeScrollbarValueAndOverhang(scrollPosition.x(), totalContentsSize().width(), visibleContentRect.width(), presentationValue, overhangAmount);
    284             [m_horizontalScrollerImp setPresentationValue:presentationValue];
    285         }
    286 
    287         [CATransaction unlock];
    288         [CATransaction commit];
    289     }
     233    m_delegate.updateScrollbarPainters();
    290234}
    291235

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

    r242132 r242359  
    3535namespace WebCore {
    3636
    37 class ScrollingTreeOverflowScrollingNodeMac : public ScrollingTreeOverflowScrollingNode {
     37class WEBCORE_EXPORT ScrollingTreeOverflowScrollingNodeMac : public ScrollingTreeOverflowScrollingNode {
    3838public:
    3939    static Ref<ScrollingTreeOverflowScrollingNodeMac> create(ScrollingTree&, ScrollingNodeID);
    4040    virtual ~ScrollingTreeOverflowScrollingNodeMac();
    4141
    42 private:
     42protected:
    4343    ScrollingTreeOverflowScrollingNodeMac(ScrollingTree&, ScrollingNodeID);
    4444
    … …  
    4949
    5050    void repositionScrollingLayers() override;
     51    void repositionRelatedLayers() override;
    5152
    5253    ScrollingEventResult handleWheelEvent(const PlatformWheelEvent&) override;
    5354
     55private:
    5456    ScrollingTreeScrollingNodeDelegateMac m_delegate;
    5557};

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

    r242132 r242359  
    5252{
    5353    ScrollingTreeOverflowScrollingNode::commitStateBeforeChildren(stateNode);
    54     const auto& scrollingStateNode = downcast<ScrollingStateOverflowScrollingNode>(stateNode);
    55     UNUSED_PARAM(scrollingStateNode);
    56     // FIXME: Scroll snap data.
     54    m_delegate.updateFromStateNode(downcast<ScrollingStateOverflowScrollingNode>(stateNode));
    5755}
    5856
    … …  
    6866    if (!canHaveScrollbars())
    6967        return ScrollingEventResult::DidNotHandleEvent;
    70 
    71 
    72 #if ENABLE(CSS_SCROLL_SNAP) || ENABLE(RUBBER_BANDING)
    73     if (expectsWheelEventTestTrigger()) {
    74         if (scrollingTree().shouldHandleWheelEventSynchronously(wheelEvent))
    75             m_delegate.removeTestDeferralForReason(reinterpret_cast<WheelEventTestTrigger::ScrollableAreaIdentifier>(scrollingNodeID()), WheelEventTestTrigger::ScrollingThreadSyncNeeded);
    76         else
    77             m_delegate.deferTestsForReason(reinterpret_cast<WheelEventTestTrigger::ScrollableAreaIdentifier>(scrollingNodeID()), WheelEventTestTrigger::ScrollingThreadSyncNeeded);
    78     }
    79 #endif
    8068
    8169    m_delegate.handleWheelEvent(wheelEvent);
    … …  
    10290}
    10391
     92void ScrollingTreeOverflowScrollingNodeMac::repositionRelatedLayers()
     93{
     94    m_delegate.updateScrollbarPainters();
     95}
     96
    10497} // namespace WebCore
    10598

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

    r240963 r242359  
    3232#include "ScrollController.h"
    3333
     34OBJC_CLASS NSScrollerImp;
     35
    3436namespace WebCore {
    3537
    … …  
    3739class FloatSize;
    3840class IntPoint;
     41class ScrollingStateScrollingNode;
    3942class ScrollingTreeScrollingNode;
    4043class ScrollingTree;
    … …  
    5457    bool isScrollSnapInProgress() const;
    5558#endif
     59
     60    void updateFromStateNode(const ScrollingStateScrollingNode&);
     61    void updateScrollbarPainters();
    5662
    5763    void deferTestsForReason(WheelEventTestTrigger::ScrollableAreaIdentifier, WheelEventTestTrigger::DeferTestTriggerReason) const override;
    … …  
    8490#endif
    8591
     92    void releaseReferencesToScrollerImpsOnTheMainThread();
     93
    8694    ScrollController m_scrollController;
     95
     96    RetainPtr<NSScrollerImp> m_verticalScrollerImp;
     97    RetainPtr<NSScrollerImp> m_horizontalScrollerImp;
    8798};
    8899

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

    r242132 r242359  
    3030
    3131#import "Logging.h"
     32#import "ScrollingStateScrollingNode.h"
    3233#import "ScrollingTree.h"
    3334#import "ScrollingTreeFrameScrollingNode.h"
    3435#import "ScrollingTreeScrollingNode.h"
     36#import <QuartzCore/QuartzCore.h>
     37#import <pal/spi/mac/NSScrollerImpSPI.h>
    3538
    3639namespace WebCore {
    … …  
    4245}
    4346
    44 ScrollingTreeScrollingNodeDelegateMac::~ScrollingTreeScrollingNodeDelegateMac() = default;
     47ScrollingTreeScrollingNodeDelegateMac::~ScrollingTreeScrollingNodeDelegateMac()
     48{
     49    releaseReferencesToScrollerImpsOnTheMainThread();
     50}
     51
     52void ScrollingTreeScrollingNodeDelegateMac::updateFromStateNode(const ScrollingStateScrollingNode& scrollingStateNode)
     53{
     54    if (scrollingStateNode.hasChangedProperty(ScrollingStateScrollingNode::PainterForScrollbar)) {
     55        releaseReferencesToScrollerImpsOnTheMainThread();
     56        m_verticalScrollerImp = scrollingStateNode.verticalScrollerImp();
     57        m_horizontalScrollerImp = scrollingStateNode.horizontalScrollerImp();
     58    }
     59}
    4560
    4661void ScrollingTreeScrollingNodeDelegateMac::updateScrollSnapPoints(ScrollEventAxis axis, const Vector<LayoutUnit>& snapOffsets, const Vector<ScrollOffsetRange<LayoutUnit>>& snapRanges)
    … …  
    6681bool ScrollingTreeScrollingNodeDelegateMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
    6782{
     83    if (wheelEvent.momentumPhase() == PlatformWheelEventPhaseBegan) {
     84        [m_verticalScrollerImp setUsePresentationValue:YES];
     85        [m_horizontalScrollerImp setUsePresentationValue:YES];
     86    }
     87    if (wheelEvent.momentumPhase() == PlatformWheelEventPhaseEnded || wheelEvent.momentumPhase() == PlatformWheelEventPhaseCancelled) {
     88        [m_verticalScrollerImp setUsePresentationValue:NO];
     89        [m_horizontalScrollerImp setUsePresentationValue:NO];
     90    }
     91
     92#if ENABLE(CSS_SCROLL_SNAP) || ENABLE(RUBBER_BANDING)
     93    if (scrollingNode().expectsWheelEventTestTrigger()) {
     94        if (scrollingTree().shouldHandleWheelEventSynchronously(wheelEvent))
     95            removeTestDeferralForReason(reinterpret_cast<WheelEventTestTrigger::ScrollableAreaIdentifier>(scrollingNode().scrollingNodeID()), WheelEventTestTrigger::ScrollingThreadSyncNeeded);
     96        else
     97            deferTestsForReason(reinterpret_cast<WheelEventTestTrigger::ScrollableAreaIdentifier>(scrollingNode().scrollingNodeID()), WheelEventTestTrigger::ScrollingThreadSyncNeeded);
     98    }
     99#endif
     100
    68101    return m_scrollController.handleWheelEvent(wheelEvent);
    69102}
    … …  
    292325}
    293326
     327void ScrollingTreeScrollingNodeDelegateMac::updateScrollbarPainters()
     328{
     329    if (m_verticalScrollerImp || m_horizontalScrollerImp) {
     330        auto scrollPosition = currentScrollPosition();
     331
     332        [CATransaction begin];
     333        [CATransaction lock];
     334
     335        if ([m_verticalScrollerImp shouldUsePresentationValue]) {
     336            float presentationValue;
     337            float overhangAmount;
     338            ScrollableArea::computeScrollbarValueAndOverhang(scrollPosition.y(), totalContentsSize().height(), scrollableAreaSize().height(), presentationValue, overhangAmount);
     339            [m_verticalScrollerImp setPresentationValue:presentationValue];
     340        }
     341
     342        if ([m_horizontalScrollerImp shouldUsePresentationValue]) {
     343            float presentationValue;
     344            float overhangAmount;
     345            ScrollableArea::computeScrollbarValueAndOverhang(scrollPosition.x(), totalContentsSize().width(), scrollableAreaSize().width(), presentationValue, overhangAmount);
     346            [m_horizontalScrollerImp setPresentationValue:presentationValue];
     347        }
     348
     349        [CATransaction unlock];
     350        [CATransaction commit];
     351    }
     352}
     353
     354void ScrollingTreeScrollingNodeDelegateMac::releaseReferencesToScrollerImpsOnTheMainThread()
     355{
     356    if (m_verticalScrollerImp || m_horizontalScrollerImp) {
     357        // FIXME: This is a workaround in place for the time being since NSScrollerImps cannot be deallocated
     358        // on a non-main thread. rdar://problem/24535055
     359        WTF::callOnMainThread([verticalScrollerImp = WTFMove(m_verticalScrollerImp), horizontalScrollerImp = WTFMove(m_horizontalScrollerImp)] {
     360        });
     361    }
     362}
     363
    294364} // namespace WebCore
    295365

  • trunk/Source/WebCore/platform/ScrollbarThemeComposite.h

    r233116 r242359  
    2424 */
    2525
    26 #ifndef ScrollbarThemeComposite_h
    27 #define ScrollbarThemeComposite_h
     26#pragma once
    2827
    2928#include "ScrollbarTheme.h"
    … …  
    7271
    7372}
    74 #endif

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

    r242333 r242359  
    545545
    546546    auto* backing = layer.backing();
     547    if (auto nodeID = backing->scrollingNodeIDForRole(ScrollCoordinationRole::Scrolling))
     548        updateScrollingNodeLayers(nodeID, layer, *scrollingCoordinator);
     549
    547550    if (auto nodeID = backing->scrollingNodeIDForRole(ScrollCoordinationRole::ViewportConstrained))
    548551        scrollingCoordinator->setNodeLayers(nodeID, { backing->graphicsLayer() });
    549 
    550     if (auto nodeID = backing->scrollingNodeIDForRole(ScrollCoordinationRole::Scrolling)) {
    551         // FIXME: would be nice to not have to special-case the root.
    552         ScrollingCoordinator::NodeLayers nodeLayers;
    553         if (layer.isRenderViewLayer())
    554             nodeLayers = { nullptr, scrollContainerLayer(), scrolledContentsLayer(), fixedRootBackgroundLayer(), clipLayer(), rootContentsLayer() };
    555         else
    556             nodeLayers = { layer.backing()->graphicsLayer(), backing->scrollContainerLayer(), backing->scrolledContentsLayer() };
    557 
    558         scrollingCoordinator->setNodeLayers(nodeID, nodeLayers);
    559     }
    560552
    561553    if (auto nodeID = backing->scrollingNodeIDForRole(ScrollCoordinationRole::FrameHosting))
    … …  
    39703962}
    39713963
     3964void RenderLayerCompositor::updateScrollingNodeLayers(ScrollingNodeID nodeID, RenderLayer& layer, ScrollingCoordinator& scrollingCoordinator)
     3965{
     3966    if (layer.isRenderViewLayer()) {
     3967        FrameView& frameView = m_renderView.frameView();
     3968        scrollingCoordinator.setNodeLayers(nodeID, { nullptr,
     3969            scrollContainerLayer(), scrolledContentsLayer(),
     3970            fixedRootBackgroundLayer(), clipLayer(), rootContentsLayer(),
     3971            frameView.layerForHorizontalScrollbar(), frameView.layerForVerticalScrollbar() });
     3972    } else {
     3973        scrollingCoordinator.setNodeLayers(nodeID, { layer.backing()->graphicsLayer(),
     3974            layer.backing()->scrollContainerLayer(), layer.backing()->scrolledContentsLayer(),
     3975            nullptr, nullptr, nullptr,
     3976            layer.layerForHorizontalScrollbar(), layer.layerForVerticalScrollbar() });
     3977    }
     3978}
     3979
    39723980ScrollingNodeID RenderLayerCompositor::updateScrollingNodeForScrollingRole(RenderLayer& layer, ScrollingTreeState& treeState, OptionSet<ScrollingNodeChangeFlags> changes)
    39733981{
    … …  
    39883996
    39893997        if (changes & ScrollingNodeChangeFlags::Layer)
    3990             scrollingCoordinator->setNodeLayers(newNodeID, { nullptr, scrollContainerLayer(), scrolledContentsLayer(), fixedRootBackgroundLayer(), clipLayer(), rootContentsLayer() });
     3998            updateScrollingNodeLayers(newNodeID, layer, *scrollingCoordinator);
    39913999
    39924000        if (changes & ScrollingNodeChangeFlags::LayerGeometry) {
    … …  
    40034011       
    40044012        if (changes & ScrollingNodeChangeFlags::Layer)
    4005             scrollingCoordinator->setNodeLayers(newNodeID, { layer.backing()->graphicsLayer(), layer.backing()->scrollContainerLayer(), layer.backing()->scrolledContentsLayer() });
     4013            updateScrollingNodeLayers(newNodeID, layer, *scrollingCoordinator);
    40064014
    40074015        if (changes & ScrollingNodeChangeFlags::LayerGeometry && treeState.parentNodeID) {

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

    r242333 r242359  
    493493    ScrollingNodeID updateScrollingNodeForFrameHostingRole(RenderLayer&, struct ScrollingTreeState&, OptionSet<ScrollingNodeChangeFlags>);
    494494
     495    void updateScrollingNodeLayers(ScrollingNodeID, RenderLayer&, ScrollingCoordinator&);
     496
    495497    void detachScrollCoordinatedLayer(RenderLayer&, OptionSet<ScrollCoordinationRole>);
    496498    void detachScrollCoordinatedLayerWithRole(RenderLayer&, ScrollingCoordinator&, ScrollCoordinationRole);

  • trunk/Source/WebKit/ChangeLog

    r242356 r242359  
     12019-03-04  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Share more code between overflow and frame scrolling nodes, fixing overflow scrollbar display
     4        https://bugs.webkit.org/show_bug.cgi?id=195258
     5
     6        Reviewed by Antti Koivisto.
     7
     8        This patch moves management of scrollbar layers and scrollbar painters ("NSScrollerImp") down to
     9        ScrollingStateScrollingNode to be shared between frame and overflow nodes, allowing for
     10        scrolling thread updates of overflow scrollbars. It also moves some scrolling tree-side code
     11        to ScrollingTreeScrollingNodeDelegateMac to be shared between the "tree" nodes for overflow and frames.
     12
     13        Layers for scrollbars are given to scrolling state nodes via setNodeLayers() now, and
     14        RenderLayerCompositor::updateScrollingNodeLayers() is added to provide a bottleneck to call that.
     15        At some point AsyncScrollingCoordinator::scrollableAreaScrollbarLayerDidChange() should be relieved
     16        of the responsibility of pushing scrollbar layers (but the scrolling state tree needs to hold
     17        references to GraphicsLayers before that becomes safe).
     18       
     19        The actual fix that allows overflow scrollbars to show is the change in
     20        AsyncScrollingCoordinator::scrollableAreaScrollbarLayerDidChange() that calls scrollableArea.*ScrollbarLayerDidChange()
     21        for all ScrollableAreas. This ensures that the CALayer is pushed onto the NSScrollerImp.
     22
     23        * Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp:
     24        (ArgumentCoder<ScrollingStateScrollingNode>::encode):
     25        (ArgumentCoder<ScrollingStateFrameScrollingNode>::encode):
     26        (ArgumentCoder<ScrollingStateScrollingNode>::decode):
     27        (ArgumentCoder<ScrollingStateFrameScrollingNode>::decode):
     28        * SourcesCocoa.txt:
     29        * UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.cpp:
     30        (WebKit::RemoteScrollingCoordinatorProxy::connectStateNodeLayers):
     31        * UIProcess/RemoteLayerTree/RemoteScrollingTree.cpp:
     32        (WebKit::RemoteScrollingTree::createScrollingTreeNode):
     33        * UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.cpp:
     34        (WebKit::ScrollingTreeFrameScrollingNodeRemoteMac::commitStateBeforeChildren):
     35        (WebKit::ScrollingTreeFrameScrollingNodeRemoteMac::repositionRelatedLayers):
     36        (WebKit::ScrollingTreeFrameScrollingNodeRemoteMac::handleMouseEvent):
     37        * UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.cpp: Copied from Source/WebKit/UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.cpp.
     38        (WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::create):
     39        (WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::ScrollingTreeOverflowScrollingNodeRemoteMac):
     40        (WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::~ScrollingTreeOverflowScrollingNodeRemoteMac):
     41        (WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::commitStateBeforeChildren):
     42        (WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::repositionRelatedLayers):
     43        (WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::handleWheelEvent):
     44        (WebKit::ScrollingTreeOverflowScrollingNodeRemoteMac::handleMouseEvent):
     45        * WebKit.xcodeproj/project.pbxproj:
     46
    1472019-03-04  Andy Estes  <aestes@apple.com>
    248

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

    r241934 r242359  
    144144    if (node.hasChangedProperty(ScrollingStateScrollingNode::ScrollContainerLayer))
    145145        encoder << static_cast<GraphicsLayer::PlatformLayerID>(node.scrollContainerLayer());
     146
    146147    if (node.hasChangedProperty(ScrollingStateScrollingNode::ScrolledContentsLayer))
    147148        encoder << static_cast<GraphicsLayer::PlatformLayerID>(node.scrolledContentsLayer());
     149
     150    if (node.hasChangedProperty(ScrollingStateFrameScrollingNode::HorizontalScrollbarLayer))
     151        encoder << static_cast<GraphicsLayer::PlatformLayerID>(node.horizontalScrollbarLayer());
     152
     153    if (node.hasChangedProperty(ScrollingStateFrameScrollingNode::VerticalScrollbarLayer))
     154        encoder << static_cast<GraphicsLayer::PlatformLayerID>(node.verticalScrollbarLayer());
    148155}
    149156
    … …  
    173180    if (node.hasChangedProperty(ScrollingStateFrameScrollingNode::ContentShadowLayer))
    174181        encoder << static_cast<GraphicsLayer::PlatformLayerID>(node.contentShadowLayer());
    175 
    176     if (node.hasChangedProperty(ScrollingStateFrameScrollingNode::VerticalScrollbarLayer))
    177         encoder << static_cast<GraphicsLayer::PlatformLayerID>(node.verticalScrollbarLayer());
    178 
    179     if (node.hasChangedProperty(ScrollingStateFrameScrollingNode::HorizontalScrollbarLayer))
    180         encoder << static_cast<GraphicsLayer::PlatformLayerID>(node.horizontalScrollbarLayer());
    181182
    182183    if (node.hasChangedProperty(ScrollingStateFrameScrollingNode::RootContentsLayer))
    … …  
    257258    }
    258259
     260    if (node.hasChangedProperty(ScrollingStateFrameScrollingNode::HorizontalScrollbarLayer)) {
     261        GraphicsLayer::PlatformLayerID layerID;
     262        if (!decoder.decode(layerID))
     263            return false;
     264        node.setHorizontalScrollbarLayer(layerID);
     265    }
     266
     267    if (node.hasChangedProperty(ScrollingStateFrameScrollingNode::VerticalScrollbarLayer)) {
     268        GraphicsLayer::PlatformLayerID layerID;
     269        if (!decoder.decode(layerID))
     270            return false;
     271        node.setVerticalScrollbarLayer(layerID);
     272    }
     273
    259274    return true;
    260275}
    … …  
    297312            return false;
    298313        node.setContentShadowLayer(layerID);
    299     }
    300 
    301     if (node.hasChangedProperty(ScrollingStateFrameScrollingNode::VerticalScrollbarLayer)) {
    302         GraphicsLayer::PlatformLayerID layerID;
    303         if (!decoder.decode(layerID))
    304             return false;
    305         node.setVerticalScrollbarLayer(layerID);
    306     }
    307 
    308     if (node.hasChangedProperty(ScrollingStateFrameScrollingNode::HorizontalScrollbarLayer)) {
    309         GraphicsLayer::PlatformLayerID layerID;
    310         if (!decoder.decode(layerID))
    311             return false;
    312         node.setHorizontalScrollbarLayer(layerID);
    313314    }
    314315

  • trunk/Source/WebKit/SourcesCocoa.txt

    r242356 r242359  
    454454UIProcess/RemoteLayerTree/mac/ScrollerPairMac.mm
    455455UIProcess/RemoteLayerTree/mac/ScrollingTreeFrameScrollingNodeRemoteMac.cpp
     456UIProcess/RemoteLayerTree/mac/ScrollingTreeOverflowScrollingNodeRemoteMac.cpp
    456457
    457458UIProcess/RemoteLayerTree/ios/RemoteLayerTreeHostIOS.mm

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

    r242132 r242359  
    147147            if (scrollingStateNode.hasChangedProperty(ScrollingStateScrollingNode::ScrolledContentsLayer))
    148148                scrollingStateNode.setScrolledContentsLayer(layerTreeHost.layerForID(scrollingStateNode.scrolledContentsLayer()));
     149
     150            if (scrollingStateNode.hasChangedProperty(ScrollingStateFrameScrollingNode::VerticalScrollbarLayer))
     151                scrollingStateNode.setVerticalScrollbarLayer(layerTreeHost.layerForID(scrollingStateNode.verticalScrollbarLayer()));
     152
     153            if (scrollingStateNode.hasChangedProperty(ScrollingStateFrameScrollingNode::HorizontalScrollbarLayer))
     154                scrollingStateNode.setHorizontalScrollbarLayer(layerTreeHost.layerForID(scrollingStateNode.horizontalScrollbarLayer()));
    149155            break;
    150156        }

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

    r242132 r242359  
    4040#else
    4141#include "ScrollingTreeFrameScrollingNodeRemoteMac.h"
     42#include "ScrollingTreeOverflowScrollingNodeRemoteMac.h"
    4243#endif
    4344
    … …  
    126127        return ScrollingTreeOverflowScrollingNodeIOS::create(*this, nodeID);
    127128#else
    128         ASSERT_NOT_REACHED();
    129         break;
     129        return ScrollingTreeOverflowScrollingNodeRemoteMac::create(*this, nodeID);
    130130#endif
    131131    case ScrollingNodeType::Fixed:

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

    r242132 r242359  
    5555    const auto& scrollingStateNode = downcast<ScrollingStateFrameScrollingNode>(stateNode);
    5656
     57    // FIXME: Push to ScrollingTreeScrollingNodeDelegateMac?
    5758    if (scrollingStateNode.hasChangedProperty(ScrollingStateFrameScrollingNode::VerticalScrollbarLayer))
    5859        m_scrollerPair->verticalScroller().setHostLayer(scrollingStateNode.verticalScrollbarLayer());
    … …  
    6869    ScrollingTreeFrameScrollingNodeMac::repositionRelatedLayers();
    6970
    70     m_scrollerPair->updateValues();
     71    if (m_scrollerPair)
     72        m_scrollerPair->updateValues();
    7173}
    7274
    … …  
    8082bool ScrollingTreeFrameScrollingNodeRemoteMac::handleMouseEvent(const PlatformMouseEvent& mouseEvent)
    8183{
     84    if (!m_scrollerPair)
     85        return false;
    8286    return m_scrollerPair->handleMouseEvent(mouseEvent);
    8387}

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

    r242358 r242359  
    2525
    2626#include "config.h"
    27 #include "ScrollingTreeFrameScrollingNodeRemoteMac.h"
     27#include "ScrollingTreeOverflowScrollingNodeRemoteMac.h"
    2828
    2929#if ENABLE(ASYNC_SCROLLING) && PLATFORM(MAC)
    … …  
    3535using namespace WebCore;
    3636
    37 ScrollingTreeFrameScrollingNodeRemoteMac::ScrollingTreeFrameScrollingNodeRemoteMac(ScrollingTree& tree, ScrollingNodeType nodeType, ScrollingNodeID nodeID)
    38     : ScrollingTreeFrameScrollingNodeMac(tree, nodeType, nodeID)
     37Ref<ScrollingTreeOverflowScrollingNodeRemoteMac> ScrollingTreeOverflowScrollingNodeRemoteMac::create(ScrollingTree& tree, ScrollingNodeID nodeID)
     38{
     39    return adoptRef(*new ScrollingTreeOverflowScrollingNodeRemoteMac(tree, nodeID));
     40}
     41
     42ScrollingTreeOverflowScrollingNodeRemoteMac::ScrollingTreeOverflowScrollingNodeRemoteMac(ScrollingTree& tree, ScrollingNodeID nodeID)
     43    : ScrollingTreeOverflowScrollingNodeMac(tree, nodeID)
    3944    , m_scrollerPair(std::make_unique<ScrollerPairMac>(*this))
    4045{
    4146}
    4247
    43 ScrollingTreeFrameScrollingNodeRemoteMac::~ScrollingTreeFrameScrollingNodeRemoteMac()
     48ScrollingTreeOverflowScrollingNodeRemoteMac::~ScrollingTreeOverflowScrollingNodeRemoteMac()
    4449{
    4550}
    4651
    47 Ref<ScrollingTreeFrameScrollingNodeRemoteMac> ScrollingTreeFrameScrollingNodeRemoteMac::create(ScrollingTree& tree, ScrollingNodeType nodeType, ScrollingNodeID nodeID)
     52void ScrollingTreeOverflowScrollingNodeRemoteMac::commitStateBeforeChildren(const ScrollingStateNode& stateNode)
    4853{
    49     return adoptRef(*new ScrollingTreeFrameScrollingNodeRemoteMac(tree, nodeType, nodeID));
    50 }
     54    ScrollingTreeOverflowScrollingNodeMac::commitStateBeforeChildren(stateNode);
     55    const auto& scrollingStateNode = downcast<ScrollingStateOverflowScrollingNode>(stateNode);
    5156
    52 void ScrollingTreeFrameScrollingNodeRemoteMac::commitStateBeforeChildren(const ScrollingStateNode& stateNode)
    53 {
    54     ScrollingTreeFrameScrollingNodeMac::commitStateBeforeChildren(stateNode);
    55     const auto& scrollingStateNode = downcast<ScrollingStateFrameScrollingNode>(stateNode);
    56 
    57     if (scrollingStateNode.hasChangedProperty(ScrollingStateFrameScrollingNode::VerticalScrollbarLayer))
     57    // FIXME: Push to ScrollingTreeScrollingNodeDelegateMac?
     58    if (scrollingStateNode.hasChangedProperty(ScrollingStateOverflowScrollingNode::VerticalScrollbarLayer))
    5859        m_scrollerPair->verticalScroller().setHostLayer(scrollingStateNode.verticalScrollbarLayer());
    5960
    60     if (scrollingStateNode.hasChangedProperty(ScrollingStateFrameScrollingNode::HorizontalScrollbarLayer))
     61    if (scrollingStateNode.hasChangedProperty(ScrollingStateOverflowScrollingNode::HorizontalScrollbarLayer))
    6162        m_scrollerPair->horizontalScroller().setHostLayer(scrollingStateNode.horizontalScrollbarLayer());
    6263
    … …  
    6465}
    6566
    66 void ScrollingTreeFrameScrollingNodeRemoteMac::repositionRelatedLayers()
     67void ScrollingTreeOverflowScrollingNodeRemoteMac::repositionRelatedLayers()
    6768{
    68     ScrollingTreeFrameScrollingNodeMac::repositionRelatedLayers();
     69    ScrollingTreeOverflowScrollingNodeMac::repositionRelatedLayers();
    6970
    7071    m_scrollerPair->updateValues();
    7172}
    7273
    73 ScrollingEventResult ScrollingTreeFrameScrollingNodeRemoteMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
     74ScrollingEventResult ScrollingTreeOverflowScrollingNodeRemoteMac::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
    7475{
    75     ScrollingTreeFrameScrollingNodeMac::handleWheelEvent(wheelEvent);
     76    ScrollingTreeOverflowScrollingNodeMac::handleWheelEvent(wheelEvent);
    7677
    7778    return m_scrollerPair->handleWheelEvent(wheelEvent) ? ScrollingEventResult::DidHandleEvent : ScrollingEventResult::DidNotHandleEvent;
    7879}
    7980
    80 bool ScrollingTreeFrameScrollingNodeRemoteMac::handleMouseEvent(const PlatformMouseEvent& mouseEvent)
     81bool ScrollingTreeOverflowScrollingNodeRemoteMac::handleMouseEvent(const PlatformMouseEvent& mouseEvent)
    8182{
    8283    return m_scrollerPair->handleMouseEvent(mouseEvent);

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

    r242358 r242359  
    2828#if ENABLE(ASYNC_SCROLLING) && PLATFORM(MAC)
    2929
    30 #include "ScrollingTreeOverflowScrollingNode.h"
    31 #include "ScrollingTreeScrollingNodeDelegateMac.h"
     30#include <WebCore/ScrollingTreeOverflowScrollingNodeMac.h>
    3231
    33 OBJC_CLASS CALayer;
     32namespace WebKit {
    3433
    35 namespace WebCore {
     34class ScrollerPairMac;
    3635
    37 class ScrollingTreeOverflowScrollingNodeMac : public ScrollingTreeOverflowScrollingNode {
     36class ScrollingTreeOverflowScrollingNodeRemoteMac : public WebCore::ScrollingTreeOverflowScrollingNodeMac {
    3837public:
    39     static Ref<ScrollingTreeOverflowScrollingNodeMac> create(ScrollingTree&, ScrollingNodeID);
    40     virtual ~ScrollingTreeOverflowScrollingNodeMac();
     38    WEBCORE_EXPORT static Ref<ScrollingTreeOverflowScrollingNodeRemoteMac> create(WebCore::ScrollingTree&, WebCore::ScrollingNodeID);
     39    virtual ~ScrollingTreeOverflowScrollingNodeRemoteMac();
     40
     41    bool handleMouseEvent(const WebCore::PlatformMouseEvent&);
    4142
    4243private:
    43     ScrollingTreeOverflowScrollingNodeMac(ScrollingTree&, ScrollingNodeID);
     44    ScrollingTreeOverflowScrollingNodeRemoteMac(WebCore::ScrollingTree&, WebCore::ScrollingNodeID);
    4445
    45     void commitStateBeforeChildren(const ScrollingStateNode&) override;
    46     void commitStateAfterChildren(const ScrollingStateNode&) override;
    47    
    48     FloatPoint adjustedScrollPosition(const FloatPoint&, ScrollPositionClamp) const override;
     46    void commitStateBeforeChildren(const WebCore::ScrollingStateNode&) override;
     47    WebCore::ScrollingEventResult handleWheelEvent(const WebCore::PlatformWheelEvent&) override;
     48    void repositionRelatedLayers() override;
    4949
    50     void repositionScrollingLayers() override;
    51 
    52     ScrollingEventResult handleWheelEvent(const PlatformWheelEvent&) override;
    53 
    54     ScrollingTreeScrollingNodeDelegateMac m_delegate;
     50    std::unique_ptr<ScrollerPairMac> m_scrollerPair;
    5551};
    5652
    57 } // namespace WebKit
     53}
    5854
    5955#endif // ENABLE(ASYNC_SCROLLING) && PLATFORM(MAC)

  • trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj

    r242356 r242359  
    18901890                0F707C771A1FEE8300DA7A45 /* RemoteLayerTreeScrollingPerformanceData.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = RemoteLayerTreeScrollingPerformanceData.mm; sourceTree = "<group>"; };
    18911891                0F707C791A1FEEA300DA7A45 /* RemoteLayerTreeScrollingPerformanceData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RemoteLayerTreeScrollingPerformanceData.h; sourceTree = "<group>"; };
     1892                0F73B767222B38C600805316 /* ScrollingTreeOverflowScrollingNodeRemoteMac.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = ScrollingTreeOverflowScrollingNodeRemoteMac.cpp; sourceTree = "<group>"; };
     1893                0F73B768222B38C600805316 /* ScrollingTreeOverflowScrollingNodeRemoteMac.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ScrollingTreeOverflowScrollingNodeRemoteMac.h; sourceTree = "<group>"; };
    18921894                0F850FE41ED7C39F00FB77A7 /* WebPerformanceLoggingClient.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebPerformanceLoggingClient.cpp; sourceTree = "<group>"; };
    18931895                0F850FE51ED7C39F00FB77A7 /* WebPerformanceLoggingClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebPerformanceLoggingClient.h; sourceTree = "<group>"; };
    … …  
    87678769                                E404907121DE65F70037F0DB /* ScrollingTreeFrameScrollingNodeRemoteMac.cpp */,
    87688770                                E404907321DE65F70037F0DB /* ScrollingTreeFrameScrollingNodeRemoteMac.h */,
     8771                                0F73B767222B38C600805316 /* ScrollingTreeOverflowScrollingNodeRemoteMac.cpp */,
     8772                                0F73B768222B38C600805316 /* ScrollingTreeOverflowScrollingNodeRemoteMac.h */,
    87698773                        );
    87708774                        path = mac;
Note: See TracChangeset for help on using the changeset viewer.