Attachment 359347 Details for Bug 193527 – Patch

[patch] Patch

bug-193527-20190116210302.patch (text/plain), 22.26 KB, created by Simon Fraser (smfr) on 2019-01-16 21:03:03 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Simon Fraser (smfr)

Created: 2019-01-16 21:03:03 PST

Size: 22.26 KB

patch

obsolete

>Subversion Revision: 240047
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 33b90d656238f39cc6f48d837922a81c501534c0..3d16ee3ba375e3b8c54e38593d2c89cbd2f23e69 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,42 @@
>+2019-01-16  Simon Fraser  <simon.fraser@apple.com>
>+
>+        ScrollingCoordinator: separate updating node geometry from node layers
>+        https://bugs.webkit.org/show_bug.cgi?id=193527
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Updating scrolling tree node layers happens in a different code path from updating geometry;
>+        the former has to be post-flush, when GraphicsLayer has made tiled or structural layers.
>+        Geometry only needs to be updated after layout, and soon we'll do this via compositing updates.
>+        
>+        We can also clean up the ScrollingCoordinator API and have a single function that updates
>+        node layers (handling different node types), and separate functions for pushing viewport-constrained
>+        and scrolling node geometry.
>+
>+		No observable behavior change.
>+
>+        * page/scrolling/AsyncScrollingCoordinator.cpp:
>+        (WebCore::AsyncScrollingCoordinator::setNodeLayers):
>+        (WebCore::AsyncScrollingCoordinator::setScrollingNodeGeometry):
>+        (WebCore::AsyncScrollingCoordinator::setViewportConstraintedNodeGeometry):
>+        (WebCore::AsyncScrollingCoordinator::updateFrameScrollingNode): Deleted.
>+        (WebCore::AsyncScrollingCoordinator::updateOverflowScrollingNode): Deleted.
>+        (WebCore::AsyncScrollingCoordinator::updateNodeLayer): Deleted.
>+        (WebCore::AsyncScrollingCoordinator::updateNodeViewportConstraints): Deleted.
>+        * page/scrolling/AsyncScrollingCoordinator.h:
>+        * page/scrolling/ScrollingCoordinator.h:
>+        (WebCore::ScrollingCoordinator::setNodeLayers):
>+        (WebCore::ScrollingCoordinator::setScrollingNodeGeometry):
>+        (WebCore::ScrollingCoordinator::setViewportConstraintedNodeGeometry):
>+        (WebCore::ScrollingCoordinator::updateNodeLayer): Deleted.
>+        (WebCore::ScrollingCoordinator::updateNodeViewportConstraints): Deleted.
>+        (WebCore::ScrollingCoordinator::updateFrameScrollingNode): Deleted.
>+        (WebCore::ScrollingCoordinator::updateOverflowScrollingNode): Deleted.
>+        * rendering/RenderLayerCompositor.cpp:
>+        (WebCore::RenderLayerCompositor::updateScrollCoordinationForThisFrame):
>+        (WebCore::RenderLayerCompositor::updateScrollCoordinatedLayer):
>+        * rendering/RenderLayerCompositor.h:
>+
> 2019-01-15  Simon Fraser  <simon.fraser@apple.com>
> 
>         Make didCommitChangesForLayer() explicitly about the platform layer changing because of tile/non-tile swapping
>diff --git a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp b/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp
>index 9d802d37865b52058f714276375cb1e5a074f85b..fb4e9e131b1234cc79651bddc5ce7a6d62efd79a 100644
>--- a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp
>+++ b/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp
>@@ -525,58 +525,53 @@ void AsyncScrollingCoordinator::ensureRootStateNodeForFrameView(FrameView& frame
>     attachToStateTree(ScrollingNodeType::MainFrame, frameView.scrollLayerID(), 0, 0);
> }
> 
>-void AsyncScrollingCoordinator::updateFrameScrollingNode(ScrollingNodeID nodeID, GraphicsLayer* layer, GraphicsLayer* scrolledContentsLayer, GraphicsLayer* counterScrollingLayer, GraphicsLayer* insetClipLayer, const ScrollingGeometry& scrollingGeometry)
>+void AsyncScrollingCoordinator::setNodeLayers(ScrollingNodeID nodeID, GraphicsLayer* layer, GraphicsLayer* scrolledContentsLayer, GraphicsLayer* counterScrollingLayer, GraphicsLayer* insetClipLayer)
> {
>-    auto* node = downcast<ScrollingStateFrameScrollingNode>(m_scrollingStateTree->stateNodeForID(nodeID));
>+    auto* node = m_scrollingStateTree->stateNodeForID(nodeID);
>     ASSERT(node);
>     if (!node)
>         return;
> 
>     node->setLayer(layer);
>-    node->setInsetClipLayer(insetClipLayer);
>-    node->setScrolledContentsLayer(scrolledContentsLayer);
>-    node->setCounterScrollingLayer(counterScrollingLayer);
>-    node->setParentRelativeScrollableRect(scrollingGeometry.parentRelativeScrollableRect);
>-    node->setScrollOrigin(scrollingGeometry.scrollOrigin);
>-    node->setScrollPosition(scrollingGeometry.scrollPosition);
>-    node->setTotalContentsSize(scrollingGeometry.contentSize);
>-    node->setReachableContentsSize(scrollingGeometry.reachableContentSize);
>-    node->setScrollableAreaSize(scrollingGeometry.scrollableAreaSize);
>-}
>-    
>-void AsyncScrollingCoordinator::updateOverflowScrollingNode(ScrollingNodeID nodeID, GraphicsLayer* layer, GraphicsLayer* scrolledContentsLayer, const ScrollingGeometry& scrollingGeometry)
>-{
>-    auto* node = downcast<ScrollingStateOverflowScrollingNode>(m_scrollingStateTree->stateNodeForID(nodeID));
>-    ASSERT(node);
>-    if (!node)
>-        return;
> 
>-    node->setLayer(layer);
>-    node->setScrolledContentsLayer(scrolledContentsLayer);
>-    node->setParentRelativeScrollableRect(scrollingGeometry.parentRelativeScrollableRect);
>-    node->setScrollOrigin(scrollingGeometry.scrollOrigin);
>-    node->setScrollPosition(scrollingGeometry.scrollPosition);
>-    node->setTotalContentsSize(scrollingGeometry.contentSize);
>-    node->setReachableContentsSize(scrollingGeometry.reachableContentSize);
>-    node->setScrollableAreaSize(scrollingGeometry.scrollableAreaSize);
>-#if ENABLE(CSS_SCROLL_SNAP)
>-    setStateScrollingNodeSnapOffsetsAsFloat(*node, ScrollEventAxis::Horizontal, &scrollingGeometry.horizontalSnapOffsets, &scrollingGeometry.horizontalSnapOffsetRanges, m_page->deviceScaleFactor());
>-    setStateScrollingNodeSnapOffsetsAsFloat(*node, ScrollEventAxis::Vertical, &scrollingGeometry.verticalSnapOffsets, &scrollingGeometry.verticalSnapOffsetRanges, m_page->deviceScaleFactor());
>-    node->setCurrentHorizontalSnapPointIndex(scrollingGeometry.currentHorizontalSnapPointIndex);
>-    node->setCurrentVerticalSnapPointIndex(scrollingGeometry.currentVerticalSnapPointIndex);
>-#endif
>+    if (is<ScrollingStateScrollingNode>(node)) {
>+        auto& scrollingNode = downcast<ScrollingStateScrollingNode>(*node);
>+        scrollingNode.setScrolledContentsLayer(scrolledContentsLayer);
>+    
>+        if (is<ScrollingStateFrameScrollingNode>(node)) {
>+            auto& frameScrollingNode = downcast<ScrollingStateFrameScrollingNode>(*node);
>+            frameScrollingNode.setInsetClipLayer(insetClipLayer);
>+            frameScrollingNode.setCounterScrollingLayer(counterScrollingLayer);
>+        }
>+    }
> }
> 
>-void AsyncScrollingCoordinator::updateNodeLayer(ScrollingNodeID nodeID, GraphicsLayer* graphicsLayer)
>+void AsyncScrollingCoordinator::setScrollingNodeGeometry(ScrollingNodeID nodeID, const ScrollingGeometry& scrollingGeometry)
> {
>-    auto* node = m_scrollingStateTree->stateNodeForID(nodeID);
>-    if (!node)
>+    auto* scrollingNode = downcast<ScrollingStateScrollingNode>(m_scrollingStateTree->stateNodeForID(nodeID));
>+    ASSERT(scrollingNode);
>+    if (!scrollingNode)
>         return;
> 
>-    node->setLayer(graphicsLayer);
>+    scrollingNode->setParentRelativeScrollableRect(scrollingGeometry.parentRelativeScrollableRect);
>+    scrollingNode->setScrollOrigin(scrollingGeometry.scrollOrigin);
>+    scrollingNode->setScrollPosition(scrollingGeometry.scrollPosition);
>+    scrollingNode->setTotalContentsSize(scrollingGeometry.contentSize);
>+    scrollingNode->setReachableContentsSize(scrollingGeometry.reachableContentSize);
>+    scrollingNode->setScrollableAreaSize(scrollingGeometry.scrollableAreaSize);
>+
>+#if ENABLE(CSS_SCROLL_SNAP)
>+    // updateScrollSnapPropertiesWithFrameView() sets these for frame scrolling nodes. FIXME: Why the difference?
>+    if (is<ScrollingStateOverflowScrollingNode>(scrollingNode)) {
>+        setStateScrollingNodeSnapOffsetsAsFloat(*scrollingNode, ScrollEventAxis::Horizontal, &scrollingGeometry.horizontalSnapOffsets, &scrollingGeometry.horizontalSnapOffsetRanges, m_page->deviceScaleFactor());
>+        setStateScrollingNodeSnapOffsetsAsFloat(*scrollingNode, ScrollEventAxis::Vertical, &scrollingGeometry.verticalSnapOffsets, &scrollingGeometry.verticalSnapOffsetRanges, m_page->deviceScaleFactor());
>+        scrollingNode->setCurrentHorizontalSnapPointIndex(scrollingGeometry.currentHorizontalSnapPointIndex);
>+        scrollingNode->setCurrentVerticalSnapPointIndex(scrollingGeometry.currentVerticalSnapPointIndex);
>+    }
>+#endif
> }
> 
>-void AsyncScrollingCoordinator::updateNodeViewportConstraints(ScrollingNodeID nodeID, const ViewportConstraints& constraints)
>+void AsyncScrollingCoordinator::setViewportConstraintedNodeGeometry(ScrollingNodeID nodeID, const ViewportConstraints& constraints)
> {
>     auto* node = m_scrollingStateTree->stateNodeForID(nodeID);
>     if (!node)
>diff --git a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h b/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h
>index 8eee100343e5955abbc9eeae84b2ea91d369938a..07968b8ab7dcd86efeb8acf8f4860d188ca15187 100644
>--- a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h
>+++ b/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h
>@@ -101,12 +101,10 @@ private:
>     WEBCORE_EXPORT void detachFromStateTree(ScrollingNodeID) override;
>     WEBCORE_EXPORT void clearStateTree() override;
>     
>-    WEBCORE_EXPORT void updateNodeLayer(ScrollingNodeID, GraphicsLayer*) override;
>-    WEBCORE_EXPORT void updateNodeViewportConstraints(ScrollingNodeID, const ViewportConstraints&) override;
>-    
>-    WEBCORE_EXPORT void updateFrameScrollingNode(ScrollingNodeID, GraphicsLayer* scrollLayer, GraphicsLayer* scrolledContentsLayer, GraphicsLayer* counterScrollingLayer, GraphicsLayer* insetClipLayer, const ScrollingGeometry&) override;
>-    WEBCORE_EXPORT void updateOverflowScrollingNode(ScrollingNodeID, GraphicsLayer* scrollLayer, GraphicsLayer* scrolledContentsLayer, const ScrollingGeometry&) override;
>-    
>+    WEBCORE_EXPORT void setNodeLayers(ScrollingNodeID, GraphicsLayer* /*layer*/, GraphicsLayer* /*scrolledContentsLayer*/ = nullptr, GraphicsLayer* /*counterScrollingLayer*/ = nullptr, GraphicsLayer* /*insetClipLayer*/ = nullptr) override;
>+    WEBCORE_EXPORT void setScrollingNodeGeometry(ScrollingNodeID, const ScrollingGeometry&) override;
>+    WEBCORE_EXPORT void setViewportConstraintedNodeGeometry(ScrollingNodeID, const ViewportConstraints&) override;
>+
>     WEBCORE_EXPORT void reconcileScrollingState(FrameView&, const FloatPoint&, const LayoutViewportOriginOrOverrideRect&, bool programmaticScroll, ViewportRectStability, ScrollingLayerPositionAction) override;
> 
>     bool isRubberBandInProgress() const override;
>diff --git a/Source/WebCore/page/scrolling/ScrollingCoordinator.h b/Source/WebCore/page/scrolling/ScrollingCoordinator.h
>index 614b67055748a1d0c58aa4105aa89960d6901e56..63ee6eafbe070d8e707f11ee68a0836d97506e2e 100644
>--- a/Source/WebCore/page/scrolling/ScrollingCoordinator.h
>+++ b/Source/WebCore/page/scrolling/ScrollingCoordinator.h
>@@ -168,8 +168,7 @@ public:
>     virtual void detachFromStateTree(ScrollingNodeID) { }
>     virtual void clearStateTree() { }
> 
>-    virtual void updateNodeLayer(ScrollingNodeID, GraphicsLayer*) { }
>-    virtual void updateNodeViewportConstraints(ScrollingNodeID, const ViewportConstraints&) { }
>+    virtual void setNodeLayers(ScrollingNodeID, GraphicsLayer* /*layer*/, GraphicsLayer* /*scrolledContentsLayer*/ = nullptr, GraphicsLayer* /*counterScrollingLayer*/ = nullptr, GraphicsLayer* /*insetClipLayer*/ = nullptr) { }
> 
>     struct ScrollingGeometry {
>         LayoutRect parentRelativeScrollableRect;
>@@ -188,8 +187,9 @@ public:
> #endif
>     };
> 
>-    virtual void updateFrameScrollingNode(ScrollingNodeID, GraphicsLayer* /*scrollLayer*/, GraphicsLayer* /*scrolledContentsLayer*/, GraphicsLayer* /*counterScrollingLayer*/, GraphicsLayer* /*insetClipLayer*/, const ScrollingGeometry&) { }
>-    virtual void updateOverflowScrollingNode(ScrollingNodeID, GraphicsLayer* /*scrollLayer*/, GraphicsLayer* /*scrolledContentsLayer*/, const ScrollingGeometry&) { }
>+    virtual void setScrollingNodeGeometry(ScrollingNodeID, const ScrollingGeometry&) { }
>+    virtual void setViewportConstraintedNodeGeometry(ScrollingNodeID, const ViewportConstraints&) { }
>+
>     virtual void reconcileViewportConstrainedLayerPositions(ScrollingNodeID, const LayoutRect&, ScrollingLayerPositionAction) { }
>     virtual String scrollingStateTreeAsText(ScrollingStateTreeAsTextBehavior = ScrollingStateTreeAsTextBehaviorNormal) const;
>     virtual bool isRubberBandInProgress() const { return false; }
>diff --git a/Source/WebCore/rendering/RenderLayerCompositor.cpp b/Source/WebCore/rendering/RenderLayerCompositor.cpp
>index 29f75fca2a90287fc3f4176224342ab310fc004b..548af6f8741efb5e6842c1e3b855341613f5ef7f 100644
>--- a/Source/WebCore/rendering/RenderLayerCompositor.cpp
>+++ b/Source/WebCore/rendering/RenderLayerCompositor.cpp
>@@ -3846,24 +3846,30 @@ void RenderLayerCompositor::detachScrollCoordinatedLayer(RenderLayer& layer, Opt
>     backing->detachFromScrollingCoordinator(roles);
> }
> 
>-void RenderLayerCompositor::updateScrollCoordinationForThisFrame(ScrollingNodeID parentNodeID)
>+void RenderLayerCompositor::updateScrollCoordinationForThisFrame(ScrollingNodeID parentNodeID, OptionSet<ScrollingNodeChangeFlags> changes)
> {
>     auto* scrollingCoordinator = this->scrollingCoordinator();
>     FrameView& frameView = m_renderView.frameView();
>     ASSERT(scrollingCoordinator->coordinatesScrollingForFrameView(frameView));
> 
>     ScrollingNodeID nodeID = attachScrollingNode(*m_renderView.layer(), m_renderView.frame().isMainFrame() ? ScrollingNodeType::MainFrame : ScrollingNodeType::Subframe, parentNodeID);
>-    ScrollingCoordinator::ScrollingGeometry scrollingGeometry;
>-    // FIXME(https://webkit.org/b/172917): Pass parentRelativeScrollableRect?
>-    scrollingGeometry.scrollOrigin = frameView.scrollOrigin();
>-    scrollingGeometry.scrollableAreaSize = frameView.visibleContentRect().size();
>-    scrollingGeometry.contentSize = frameView.totalContentsSize();
>-    scrollingGeometry.reachableContentSize = frameView.totalContentsSize();
>+
>+    if (changes & ScrollingNodeChangeFlags::Layer)
>+        scrollingCoordinator->setNodeLayers(nodeID, m_scrollLayer.get(), m_rootContentLayer.get(), fixedRootBackgroundLayer(), clipLayer());
>+
>+    if (changes & ScrollingNodeChangeFlags::LayerGeometry) {
>+        ScrollingCoordinator::ScrollingGeometry scrollingGeometry;
>+        // FIXME(https://webkit.org/b/172917): Pass parentRelativeScrollableRect?
>+        scrollingGeometry.scrollOrigin = frameView.scrollOrigin();
>+        scrollingGeometry.scrollableAreaSize = frameView.visibleContentRect().size();
>+        scrollingGeometry.contentSize = frameView.totalContentsSize();
>+        scrollingGeometry.reachableContentSize = frameView.totalContentsSize();
> #if ENABLE(CSS_SCROLL_SNAP)
>-    frameView.updateSnapOffsets();
>-    scrollingCoordinator->updateScrollSnapPropertiesWithFrameView(frameView);
>+        frameView.updateSnapOffsets();
>+        scrollingCoordinator->updateScrollSnapPropertiesWithFrameView(frameView);
> #endif
>-    scrollingCoordinator->updateFrameScrollingNode(nodeID, m_scrollLayer.get(), m_rootContentLayer.get(), fixedRootBackgroundLayer(), clipLayer(), scrollingGeometry);
>+        scrollingCoordinator->setScrollingNodeGeometry(nodeID, scrollingGeometry);
>+    }
> }
> 
> void RenderLayerCompositor::updateScrollCoordinatedLayer(RenderLayer& layer, OptionSet<ScrollCoordinationRole> roles, OptionSet<ScrollingNodeChangeFlags> changes)
>@@ -3882,7 +3888,7 @@ void RenderLayerCompositor::updateScrollCoordinatedLayer(RenderLayer& layer, Opt
>         if (!parentDocumentHostingNodeID)
>             return;
> 
>-        updateScrollCoordinationForThisFrame(parentDocumentHostingNodeID);
>+        updateScrollCoordinationForThisFrame(parentDocumentHostingNodeID, changes);
>         if (!(roles.contains(ScrollCoordinationRole::ViewportConstrained)) && isRenderViewLayer)
>             return;
>     }
>@@ -3911,15 +3917,15 @@ void RenderLayerCompositor::updateScrollCoordinatedLayer(RenderLayer& layer, Opt
>         LOG_WITH_STREAM(Compositing, stream << "Registering ViewportConstrained " << nodeType << " node " << nodeID << " (layer " << backing->graphicsLayer()->primaryLayerID() << ") as child of " << parentNodeID);
> 
>         if (changes & ScrollingNodeChangeFlags::Layer)
>-            scrollingCoordinator->updateNodeLayer(nodeID, backing->graphicsLayer());
>+            scrollingCoordinator->setNodeLayers(nodeID, backing->graphicsLayer());
> 
>         if (changes & ScrollingNodeChangeFlags::LayerGeometry) {
>             switch (nodeType) {
>             case ScrollingNodeType::Fixed:
>-                scrollingCoordinator->updateNodeViewportConstraints(nodeID, computeFixedViewportConstraints(layer));
>+                scrollingCoordinator->setViewportConstraintedNodeGeometry(nodeID, computeFixedViewportConstraints(layer));
>                 break;
>             case ScrollingNodeType::Sticky:
>-                scrollingCoordinator->updateNodeViewportConstraints(nodeID, computeStickyViewportConstraints(layer));
>+                scrollingCoordinator->setViewportConstraintedNodeGeometry(nodeID, computeStickyViewportConstraints(layer));
>                 break;
>             case ScrollingNodeType::MainFrame:
>             case ScrollingNodeType::Subframe:
>@@ -3934,36 +3940,41 @@ void RenderLayerCompositor::updateScrollCoordinatedLayer(RenderLayer& layer, Opt
>         
>     if (roles.contains(ScrollCoordinationRole::Scrolling)) {
>         if (isRenderViewLayer)
>-            updateScrollCoordinationForThisFrame(parentNodeID);
>+            updateScrollCoordinationForThisFrame(parentNodeID, changes);
>         else {
>             ScrollingNodeType nodeType = ScrollingNodeType::Overflow;
>             ScrollingNodeID nodeID = attachScrollingNode(layer, nodeType, parentNodeID);
>             if (!nodeID)
>                 return;
> 
>-            ScrollingCoordinator::ScrollingGeometry scrollingGeometry;
>-            // FIXME(https://webkit.org/b/172917): Pass parentRelativeScrollableRect?
>-            scrollingGeometry.scrollOrigin = layer.scrollOrigin();
>-            scrollingGeometry.scrollPosition = layer.scrollPosition();
>-            scrollingGeometry.scrollableAreaSize = layer.visibleSize();
>-            scrollingGeometry.contentSize = layer.contentsSize();
>-            scrollingGeometry.reachableContentSize = layer.scrollableContentsSize();
>+            if (changes & ScrollingNodeChangeFlags::Layer)
>+                scrollingCoordinator->setNodeLayers(nodeID, backing->scrollingLayer(), backing->scrollingContentsLayer());
>+
>+            if (changes & ScrollingNodeChangeFlags::LayerGeometry) {
>+                ScrollingCoordinator::ScrollingGeometry scrollingGeometry;
>+                // FIXME(https://webkit.org/b/172917): Pass parentRelativeScrollableRect?
>+                scrollingGeometry.scrollOrigin = layer.scrollOrigin();
>+                scrollingGeometry.scrollPosition = layer.scrollPosition();
>+                scrollingGeometry.scrollableAreaSize = layer.visibleSize();
>+                scrollingGeometry.contentSize = layer.contentsSize();
>+                scrollingGeometry.reachableContentSize = layer.scrollableContentsSize();
> #if ENABLE(CSS_SCROLL_SNAP)
>-            if (const Vector<LayoutUnit>* offsets = layer.horizontalSnapOffsets())
>-                scrollingGeometry.horizontalSnapOffsets = *offsets;
>-            if (const Vector<LayoutUnit>* offsets = layer.verticalSnapOffsets())
>-                scrollingGeometry.verticalSnapOffsets = *offsets;
>-            if (const Vector<ScrollOffsetRange<LayoutUnit>>* ranges = layer.horizontalSnapOffsetRanges())
>-                scrollingGeometry.horizontalSnapOffsetRanges = *ranges;
>-            if (const Vector<ScrollOffsetRange<LayoutUnit>>* ranges = layer.verticalSnapOffsetRanges())
>-                scrollingGeometry.verticalSnapOffsetRanges = *ranges;
>-            scrollingGeometry.currentHorizontalSnapPointIndex = layer.currentHorizontalSnapPointIndex();
>-            scrollingGeometry.currentVerticalSnapPointIndex = layer.currentVerticalSnapPointIndex();
>+                if (const Vector<LayoutUnit>* offsets = layer.horizontalSnapOffsets())
>+                    scrollingGeometry.horizontalSnapOffsets = *offsets;
>+                if (const Vector<LayoutUnit>* offsets = layer.verticalSnapOffsets())
>+                    scrollingGeometry.verticalSnapOffsets = *offsets;
>+                if (const Vector<ScrollOffsetRange<LayoutUnit>>* ranges = layer.horizontalSnapOffsetRanges())
>+                    scrollingGeometry.horizontalSnapOffsetRanges = *ranges;
>+                if (const Vector<ScrollOffsetRange<LayoutUnit>>* ranges = layer.verticalSnapOffsetRanges())
>+                    scrollingGeometry.verticalSnapOffsetRanges = *ranges;
>+                scrollingGeometry.currentHorizontalSnapPointIndex = layer.currentHorizontalSnapPointIndex();
>+                scrollingGeometry.currentVerticalSnapPointIndex = layer.currentVerticalSnapPointIndex();
> #endif
> 
>-            LOG(Compositing, "Registering Scrolling scrolling node %" PRIu64 " (layer %" PRIu64 ") as child of %" PRIu64, nodeID, backing->graphicsLayer()->primaryLayerID(), parentNodeID);
>+                LOG(Compositing, "Registering Scrolling scrolling node %" PRIu64 " (layer %" PRIu64 ") as child of %" PRIu64, nodeID, backing->graphicsLayer()->primaryLayerID(), parentNodeID);
> 
>-            scrollingCoordinator->updateOverflowScrollingNode(nodeID, backing->scrollingLayer(), backing->scrollingContentsLayer(), scrollingGeometry);
>+                scrollingCoordinator->setScrollingNodeGeometry(nodeID, scrollingGeometry);
>+            }
>         }
>     } else
>         detachScrollCoordinatedLayer(layer, ScrollCoordinationRole::Scrolling);
>diff --git a/Source/WebCore/rendering/RenderLayerCompositor.h b/Source/WebCore/rendering/RenderLayerCompositor.h
>index 9c9074dd2e6ea085ece350898469ff5c2f4a0acb..9b19f7ede49eb4732049c4d5bbd6bafdb244509c 100644
>--- a/Source/WebCore/rendering/RenderLayerCompositor.h
>+++ b/Source/WebCore/rendering/RenderLayerCompositor.h
>@@ -472,7 +472,7 @@ private:
> 
>     void updateCustomLayersAfterFlush();
> 
>-    void updateScrollCoordinationForThisFrame(ScrollingNodeID);
>+    void updateScrollCoordinationForThisFrame(ScrollingNodeID, OptionSet<ScrollingNodeChangeFlags>);
>     ScrollingNodeID attachScrollingNode(RenderLayer&, ScrollingNodeType, ScrollingNodeID parentNodeID);
>     void updateScrollCoordinatedLayer(RenderLayer&, OptionSet<ScrollCoordinationRole>, OptionSet<ScrollingNodeChangeFlags>);
>     void detachScrollCoordinatedLayer(RenderLayer&, OptionSet<ScrollCoordinationRole>);

Flags:

koivisto: review+

Actions: View | Formatted Diff | Diff

Attachments on bug 193527: 359347