Attachment 370483 Details for Bug 196885 – Patch

[patch] Patch

bug-196885-20190522211831.patch (text/plain), 46.83 KB, created by Simon Fraser (smfr) on 2019-05-22 21:18:32 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Simon Fraser (smfr)

Created: 2019-05-22 21:18:32 PDT

Size: 46.83 KB

patch

obsolete

>Subversion Revision: 245659
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index bcfc865013f732576f3f54674e56355a5777e82d..3da671b917642b6d7506f20740cc7e851c02a68e 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,46 @@
>+2019-05-22  Simon Fraser  <simon.fraser@apple.com>
>+
>+        [iOS WK2] Clipped, absolutely positioned elements inside overflow:scroll jiggle
>+        https://bugs.webkit.org/show_bug.cgi?id=196885
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Test: scrollingcoordinator/ios/nested-absolute-layer-with-clipping.html
>+
>+        * page/scrolling/AsyncScrollingCoordinator.cpp:
>+        (WebCore::AsyncScrollingCoordinator::setNodeLayers):
>+        (WebCore::AsyncScrollingCoordinator::setPositionedNodeGeometry):
>+        * page/scrolling/AsyncScrollingCoordinator.h:
>+        * page/scrolling/ScrollingCoordinator.h:
>+        (WebCore::ScrollingCoordinator::setPositionedNodeGeometry):
>+        * page/scrolling/ScrollingStatePositionedNode.cpp:
>+        (WebCore::ScrollingStatePositionedNode::ScrollingStatePositionedNode):
>+        (WebCore::ScrollingStatePositionedNode::setAllPropertiesChanged):
>+        (WebCore::ScrollingStatePositionedNode::setAncestorClippingLayer):
>+        (WebCore::ScrollingStatePositionedNode::setLayerConstraints):
>+        (WebCore::ScrollingStatePositionedNode::setClippingLayerConstraints):
>+        (WebCore::ScrollingStatePositionedNode::dumpProperties const):
>+        (WebCore::ScrollingStatePositionedNode::updateConstraints): Deleted.
>+        * page/scrolling/ScrollingStatePositionedNode.h:
>+        * page/scrolling/cocoa/ScrollingTreePositionedNode.h:
>+        (WebCore::ScrollingTreePositionedNode::scrollPositioningBehavior const):
>+        * page/scrolling/cocoa/ScrollingTreePositionedNode.mm:
>+        (WebCore::ScrollingTreePositionedNode::commitStateBeforeChildren):
>+        (WebCore::ScrollingTreePositionedNode::applyLayerPositions):
>+        (WebCore::ScrollingTreePositionedNode::dumpProperties const):
>+        * rendering/RenderLayer.cpp:
>+        (WebCore::RenderLayer::updateLayerPosition):
>+        * rendering/RenderLayerBacking.cpp:
>+        (WebCore::RenderLayerBacking::coordinatedScrollingRoles const):
>+        * rendering/RenderLayerBacking.h:
>+        * rendering/RenderLayerCompositor.cpp:
>+        (WebCore::RenderLayerCompositor::didChangePlatformLayerForLayer):
>+        (WebCore::enclosingClippingLayer):
>+        (WebCore::RenderLayerCompositor::updateScrollCoordinationForLayer):
>+        (WebCore::RenderLayerCompositor::updateScrollingNodeLayers):
>+        (WebCore::RenderLayerCompositor::updateScrollingNodeForPositioningRole):
>+        * rendering/RenderLayerCompositor.h:
>+
> 2019-05-22  Simon Fraser  <simon.fraser@apple.com>
> 
>         Fix scrolling tree state for more obscure combinations of positioning and paint order
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 0a16433f9caf47d752e9ddadd6995c5e20fca10c..32f60fd7a6d95c4c6277c0125639214fc4e5567a 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,19 @@
>+2019-05-22  Simon Fraser  <simon.fraser@apple.com>
>+
>+        [iOS WK2] Clipped, absolutely positioned elements inside overflow:scroll jiggle
>+        https://bugs.webkit.org/show_bug.cgi?id=196885
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp:
>+        (ArgumentCoder<ScrollingStatePositionedNode>::encode):
>+        (ArgumentCoder<ScrollingStatePositionedNode>::decode):
>+        (WebKit::dump):
>+        * UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.cpp:
>+        (WebKit::RemoteScrollingCoordinatorProxy::connectStateNodeLayers):
>+        * UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm:
>+        (WebKit::RemoteScrollingCoordinatorProxy::connectStateNodeLayers):
>+
> 2019-05-22  Ryosuke Niwa  <rniwa@webkit.org>
> 
>         Crash in WebFrame::jsContext() when m_coreFrame is null
>diff --git a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp b/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp
>index d5e447bf256de70f9d980ceaf0636dc4a9194e26..1d3d67bce8b570c68e786175ebe289f7e7999a8d 100644
>--- a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp
>+++ b/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp
>@@ -586,6 +586,9 @@ void AsyncScrollingCoordinator::setNodeLayers(ScrollingNodeID nodeID, const Node
>             frameScrollingNode.setCounterScrollingLayer(nodeLayers.counterScrollingLayer);
>             frameScrollingNode.setRootContentsLayer(nodeLayers.rootContentsLayer);
>         }
>+    } else if (is<ScrollingStatePositionedNode>(node)) {
>+        auto& scrollingNode = downcast<ScrollingStatePositionedNode>(*node);
>+        scrollingNode.setAncestorClippingLayer(nodeLayers.clippingLayer);
>     }
> }
> 
>@@ -692,15 +695,17 @@ void AsyncScrollingCoordinator::setViewportConstraintedNodeConstraints(Scrolling
>     }
> }
> 
>-void AsyncScrollingCoordinator::setPositionedNodeGeometry(ScrollingNodeID nodeID, const LayoutConstraints& constraints)
>+void AsyncScrollingCoordinator::setPositionedNodeGeometry(ScrollingNodeID nodeID, const LayoutConstraints& constraints, const LayoutConstraints& clippingLayerConstraints)
> {
>     auto* node = m_scrollingStateTree->stateNodeForID(nodeID);
>     if (!node)
>         return;
> 
>     ASSERT(is<ScrollingStatePositionedNode>(*node));
>-    if (auto* positionedNode = downcast<ScrollingStatePositionedNode>(node))
>-        positionedNode->updateConstraints(constraints);
>+    if (auto* positionedNode = downcast<ScrollingStatePositionedNode>(node)) {
>+        positionedNode->setLayerConstraints(constraints);
>+        positionedNode->setClippingLayerConstraints(clippingLayerConstraints);
>+    }
> }
> 
> void AsyncScrollingCoordinator::setRelatedOverflowScrollingNodes(ScrollingNodeID nodeID, Vector<ScrollingNodeID>&& relatedNodes)
>diff --git a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h b/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h
>index b153bac8c4df4ee0443706f4100a9a2e38dbf3d9..5375316944dc02ef2719b230f3bd1cc6eea21207 100644
>--- a/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h
>+++ b/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h
>@@ -115,7 +115,7 @@ private:
>     WEBCORE_EXPORT void setScrollingNodeScrollableAreaGeometry(ScrollingNodeID, ScrollableArea&) override;
>     WEBCORE_EXPORT void setFrameScrollingNodeState(ScrollingNodeID, const FrameView&) override;
>     WEBCORE_EXPORT void setViewportConstraintedNodeConstraints(ScrollingNodeID, const ViewportConstraints&) override;
>-    WEBCORE_EXPORT void setPositionedNodeGeometry(ScrollingNodeID, const LayoutConstraints&) override;
>+    WEBCORE_EXPORT void setPositionedNodeGeometry(ScrollingNodeID, const LayoutConstraints&, const LayoutConstraints& clippingLayerConstraints) override;
>     WEBCORE_EXPORT void setRelatedOverflowScrollingNodes(ScrollingNodeID, Vector<ScrollingNodeID>&&) override;
> 
>     WEBCORE_EXPORT void reconcileScrollingState(FrameView&, const FloatPoint&, const LayoutViewportOriginOrOverrideRect&, ScrollType, ViewportRectStability, ScrollingLayerPositionAction) override;
>diff --git a/Source/WebCore/page/scrolling/ScrollingCoordinator.h b/Source/WebCore/page/scrolling/ScrollingCoordinator.h
>index 65c625828538de5d4fd568b47049bc0bbc32d73b..fc6252a17511ad7d653761b86e9ac6e9b0eee0af 100644
>--- a/Source/WebCore/page/scrolling/ScrollingCoordinator.h
>+++ b/Source/WebCore/page/scrolling/ScrollingCoordinator.h
>@@ -135,6 +135,7 @@ public:
> 
>     struct NodeLayers {
>         GraphicsLayer* layer { nullptr };
>+        GraphicsLayer* clippingLayer { nullptr };
>         GraphicsLayer* scrollContainerLayer { nullptr };
>         GraphicsLayer* scrolledContentsLayer { nullptr };
>         GraphicsLayer* counterScrollingLayer { nullptr };
>@@ -149,7 +150,7 @@ public:
>     virtual void setScrollingNodeScrollableAreaGeometry(ScrollingNodeID, ScrollableArea&) { }
>     virtual void setFrameScrollingNodeState(ScrollingNodeID, const FrameView&) { }
>     virtual void setViewportConstraintedNodeConstraints(ScrollingNodeID, const ViewportConstraints&) { }
>-    virtual void setPositionedNodeGeometry(ScrollingNodeID, const LayoutConstraints&) { }
>+    virtual void setPositionedNodeGeometry(ScrollingNodeID, const LayoutConstraints&, const LayoutConstraints&) { }
>     virtual void setRelatedOverflowScrollingNodes(ScrollingNodeID, Vector<ScrollingNodeID>&&) { }
> 
>     virtual void reconcileViewportConstrainedLayerPositions(ScrollingNodeID, const LayoutRect&, ScrollingLayerPositionAction) { }
>diff --git a/Source/WebCore/page/scrolling/ScrollingStatePositionedNode.cpp b/Source/WebCore/page/scrolling/ScrollingStatePositionedNode.cpp
>index e71f8017434a7bf7f164ec5a627e8d41039ae1e3..26aecbeb4f3ac63b752748c77d4bb8ee72c99058 100644
>--- a/Source/WebCore/page/scrolling/ScrollingStatePositionedNode.cpp
>+++ b/Source/WebCore/page/scrolling/ScrollingStatePositionedNode.cpp
>@@ -48,8 +48,11 @@ ScrollingStatePositionedNode::ScrollingStatePositionedNode(ScrollingStateTree& t
> ScrollingStatePositionedNode::ScrollingStatePositionedNode(const ScrollingStatePositionedNode& node, ScrollingStateTree& adoptiveTree)
>     : ScrollingStateNode(node, adoptiveTree)
>     , m_relatedOverflowScrollingNodes(node.relatedOverflowScrollingNodes())
>-    , m_constraints(node.layoutConstraints())
>+    , m_layerConstraints(node.layerConstraints())
>+    , m_clippingLayerConstraints(node.clippingLayerConstraints())
> {
>+    if (hasChangedProperty(AncestorClippingLayer))
>+        setAncestorClippingLayer(node.ancestorClippingLayer().toRepresentation(adoptiveTree.preferredLayerRepresentation()));
> }
> 
> ScrollingStatePositionedNode::~ScrollingStatePositionedNode() = default;
>@@ -61,11 +64,22 @@ Ref<ScrollingStateNode> ScrollingStatePositionedNode::clone(ScrollingStateTree&
> 
> void ScrollingStatePositionedNode::setAllPropertiesChanged()
> {
>+    setPropertyChangedBit(AncestorClippingLayer);
>     setPropertyChangedBit(RelatedOverflowScrollingNodes);
>-    setPropertyChangedBit(LayoutConstraintData);
>+    setPropertyChangedBit(LayerConstraints);
>+    setPropertyChangedBit(ClippingLayerConstraints);
>     ScrollingStateNode::setAllPropertiesChanged();
> }
> 
>+void ScrollingStatePositionedNode::setAncestorClippingLayer(const LayerRepresentation& layerRepresentation)
>+{
>+    if (layerRepresentation == m_ancestorClippingLayer)
>+        return;
>+
>+    m_ancestorClippingLayer = layerRepresentation;
>+    setPropertyChanged(AncestorClippingLayer);
>+}
>+
> void ScrollingStatePositionedNode::setRelatedOverflowScrollingNodes(Vector<ScrollingNodeID>&& nodes)
> {
>     if (nodes == m_relatedOverflowScrollingNodes)
>@@ -75,15 +89,26 @@ void ScrollingStatePositionedNode::setRelatedOverflowScrollingNodes(Vector<Scrol
>     setPropertyChanged(RelatedOverflowScrollingNodes);
> }
> 
>-void ScrollingStatePositionedNode::updateConstraints(const LayoutConstraints& constraints)
>+void ScrollingStatePositionedNode::setLayerConstraints(const LayoutConstraints& constraints)
>+{
>+    if (m_layerConstraints == constraints)
>+        return;
>+
>+    LOG_WITH_STREAM(Scrolling, stream << "ScrollingStatePositionedNode " << scrollingNodeID() << " setLayerConstraints " << constraints);
>+
>+    m_layerConstraints = constraints;
>+    setPropertyChanged(LayerConstraints);
>+}
>+
>+void ScrollingStatePositionedNode::setClippingLayerConstraints(const LayoutConstraints& constraints)
> {
>-    if (m_constraints == constraints)
>+    if (m_clippingLayerConstraints == constraints)
>         return;
> 
>-    LOG_WITH_STREAM(Scrolling, stream << "ScrollingStatePositionedNode " << scrollingNodeID() << " updateConstraints " << constraints);
>+    LOG_WITH_STREAM(Scrolling, stream << "ScrollingStatePositionedNode " << scrollingNodeID() << " setClippingLayerConstraints " << constraints);
> 
>-    m_constraints = constraints;
>-    setPropertyChanged(LayoutConstraintData);
>+    m_clippingLayerConstraints = constraints;
>+    setPropertyChanged(ClippingLayerConstraints);
> }
> 
> void ScrollingStatePositionedNode::dumpProperties(TextStream& ts, ScrollingStateTreeAsTextBehavior behavior) const
>@@ -91,10 +116,14 @@ void ScrollingStatePositionedNode::dumpProperties(TextStream& ts, ScrollingState
>     ts << "Positioned node";
>     ScrollingStateNode::dumpProperties(ts, behavior);
> 
>-    ts.dumpProperty("layout constraints", m_constraints);
>+    ts.dumpProperty("layer constraints", m_layerConstraints);
>+    ts.dumpProperty("clipping layer constraints", m_clippingLayerConstraints);
>     ts.dumpProperty("related overflow nodes", m_relatedOverflowScrollingNodes.size());
> 
>     if (behavior & ScrollingStateTreeAsTextBehaviorIncludeNodeIDs) {
>+        if (m_ancestorClippingLayer.layerID())
>+            ts.dumpProperty("ancestor clipping layer", m_ancestorClippingLayer.layerID());
>+
>         if (!m_relatedOverflowScrollingNodes.isEmpty()) {
>             TextStream::GroupScope scope(ts);
>             ts << "overflow nodes";
>diff --git a/Source/WebCore/page/scrolling/ScrollingStatePositionedNode.h b/Source/WebCore/page/scrolling/ScrollingStatePositionedNode.h
>index 601a966c1ca9df41f55834b711989159009fcc32..ddc68b97eed6cae34c6fd57346e4a94bc11500a0 100644
>--- a/Source/WebCore/page/scrolling/ScrollingStatePositionedNode.h
>+++ b/Source/WebCore/page/scrolling/ScrollingStatePositionedNode.h
>@@ -46,16 +46,24 @@ public:
>     virtual ~ScrollingStatePositionedNode();
> 
>     enum {
>-        RelatedOverflowScrollingNodes = NumStateNodeBits,
>-        LayoutConstraintData,
>+        AncestorClippingLayer = NumStateNodeBits,
>+        RelatedOverflowScrollingNodes,
>+        LayerConstraints,
>+        ClippingLayerConstraints,
>     };
> 
>+    const LayerRepresentation& ancestorClippingLayer() const { return m_ancestorClippingLayer; }
>+    WEBCORE_EXPORT void setAncestorClippingLayer(const LayerRepresentation&);
>+
>     // These are the overflow scrolling nodes whose scroll position affects the layers in this node.
>     const Vector<ScrollingNodeID>& relatedOverflowScrollingNodes() const { return m_relatedOverflowScrollingNodes; }
>     WEBCORE_EXPORT void setRelatedOverflowScrollingNodes(Vector<ScrollingNodeID>&&);
> 
>-    WEBCORE_EXPORT void updateConstraints(const LayoutConstraints&);
>-    const LayoutConstraints& layoutConstraints() const { return m_constraints; }
>+    WEBCORE_EXPORT void setLayerConstraints(const LayoutConstraints&);
>+    const LayoutConstraints& layerConstraints() const { return m_layerConstraints; }
>+
>+    WEBCORE_EXPORT void setClippingLayerConstraints(const LayoutConstraints&);
>+    const LayoutConstraints& clippingLayerConstraints() const { return m_clippingLayerConstraints; }
> 
> private:
>     ScrollingStatePositionedNode(ScrollingStateTree&, ScrollingNodeID);
>@@ -65,8 +73,11 @@ private:
> 
>     void dumpProperties(WTF::TextStream&, ScrollingStateTreeAsTextBehavior) const override;
> 
>+    LayerRepresentation m_ancestorClippingLayer;
>+
>     Vector<ScrollingNodeID> m_relatedOverflowScrollingNodes;
>-    LayoutConstraints m_constraints;
>+    LayoutConstraints m_layerConstraints;
>+    LayoutConstraints m_clippingLayerConstraints;
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/page/scrolling/cocoa/ScrollingTreePositionedNode.h b/Source/WebCore/page/scrolling/cocoa/ScrollingTreePositionedNode.h
>index a1053ac5438caf461d69d49a403194644cd318dd..23079dc104734132e174c27275ea153a7a50d8ea 100644
>--- a/Source/WebCore/page/scrolling/cocoa/ScrollingTreePositionedNode.h
>+++ b/Source/WebCore/page/scrolling/cocoa/ScrollingTreePositionedNode.h
>@@ -43,7 +43,8 @@ public:
> 
>     CALayer *layer() const { return m_layer.get(); }
> 
>-    ScrollPositioningBehavior scrollPositioningBehavior() const { return m_constraints.scrollPositioningBehavior(); }
>+    ScrollPositioningBehavior scrollPositioningBehavior() const { return m_layerConstraints.scrollPositioningBehavior(); }
>+
>     const Vector<ScrollingNodeID>& relatedOverflowScrollingNodes() const { return m_relatedOverflowScrollingNodes; }
> 
> private:
>@@ -57,8 +58,10 @@ private:
>     WEBCORE_EXPORT void dumpProperties(WTF::TextStream&, ScrollingStateTreeAsTextBehavior) const override;
> 
>     Vector<ScrollingNodeID> m_relatedOverflowScrollingNodes;
>-    LayoutConstraints m_constraints;
>+    LayoutConstraints m_layerConstraints;
>+    LayoutConstraints m_clippingLayerConstraints;
>     RetainPtr<CALayer> m_layer;
>+    RetainPtr<CALayer> m_ancestorClippingLayer;
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/page/scrolling/cocoa/ScrollingTreePositionedNode.mm b/Source/WebCore/page/scrolling/cocoa/ScrollingTreePositionedNode.mm
>index 14abd503312b3be0725c567c7407f1c644258579..6b88f0076e55aa986aae5207d2ffe54879ce511f 100644
>--- a/Source/WebCore/page/scrolling/cocoa/ScrollingTreePositionedNode.mm
>+++ b/Source/WebCore/page/scrolling/cocoa/ScrollingTreePositionedNode.mm
>@@ -57,14 +57,20 @@ void ScrollingTreePositionedNode::commitStateBeforeChildren(const ScrollingState
>     if (positionedStateNode.hasChangedProperty(ScrollingStateNode::Layer))
>         m_layer = positionedStateNode.layer();
> 
>+    if (positionedStateNode.hasChangedProperty(ScrollingStatePositionedNode::AncestorClippingLayer))
>+        m_ancestorClippingLayer = positionedStateNode.ancestorClippingLayer();
>+
>     if (positionedStateNode.hasChangedProperty(ScrollingStatePositionedNode::RelatedOverflowScrollingNodes))
>         m_relatedOverflowScrollingNodes = positionedStateNode.relatedOverflowScrollingNodes();
> 
>-    if (positionedStateNode.hasChangedProperty(ScrollingStatePositionedNode::LayoutConstraintData))
>-        m_constraints = positionedStateNode.layoutConstraints();
>+    if (positionedStateNode.hasChangedProperty(ScrollingStatePositionedNode::LayerConstraints))
>+        m_layerConstraints = positionedStateNode.layerConstraints();
>+
>+    if (positionedStateNode.hasChangedProperty(ScrollingStatePositionedNode::ClippingLayerConstraints))
>+        m_clippingLayerConstraints = positionedStateNode.clippingLayerConstraints();
> 
>     // Tell the ScrollingTree about non-ancestor overflow nodes which affect this node.
>-    if (m_constraints.scrollPositioningBehavior() == ScrollPositioningBehavior::Moves) {
>+    if (scrollPositioningBehavior() == ScrollPositioningBehavior::Moves) {
>         auto& relatedNodes = scrollingTree().overflowRelatedNodes();
>         for (auto overflowNodeID : m_relatedOverflowScrollingNodes) {
>             relatedNodes.ensure(overflowNodeID, [] {
>@@ -72,7 +78,7 @@ void ScrollingTreePositionedNode::commitStateBeforeChildren(const ScrollingState
>             }).iterator->value.append(scrollingNodeID());
>         }
>     }
>-    if (!m_relatedOverflowScrollingNodes.isEmpty() && m_constraints.scrollPositioningBehavior() != ScrollPositioningBehavior::None)
>+    if (!m_relatedOverflowScrollingNodes.isEmpty() && scrollPositioningBehavior() != ScrollPositioningBehavior::None)
>         scrollingTree().positionedNodesWithRelatedOverflow().add(scrollingNodeID());
> }
> 
>@@ -89,20 +95,32 @@ void ScrollingTreePositionedNode::applyLayerPositions(const FloatRect&, FloatSiz
>             }
>         }
>     }
>-    auto layerOffset = -scrollOffsetSinceLastCommit;
>-    if (m_constraints.scrollPositioningBehavior() == ScrollPositioningBehavior::Stationary) {
>-        // Stationary nodes move in the opposite direction.
>-        layerOffset = -layerOffset;
>-    }
> 
>-    FloatPoint layerPosition = m_constraints.layerPositionAtLastLayout() - layerOffset;
>+    auto adjustLayer = [&] (CALayer* layer, const LayoutConstraints& constraints) {
>+        if (constraints.scrollPositioningBehavior() == ScrollPositioningBehavior::None)
>+            return;
> 
>-    LOG_WITH_STREAM(Scrolling, stream << "ScrollingTreePositionedNode " << scrollingNodeID() << " applyLayerPositions: overflow delta " << scrollOffsetSinceLastCommit << " moving layer to " << layerPosition);
>+        auto layerOffset = -scrollOffsetSinceLastCommit;
>+        if (constraints.scrollPositioningBehavior() == ScrollPositioningBehavior::Stationary) {
>+            // Stationary nodes move in the opposite direction.
>+            layerOffset = -layerOffset;
>+        }
> 
>-    [m_layer _web_setLayerTopLeftPosition:layerPosition - m_constraints.alignmentOffset()];
>+        FloatPoint layerPosition = constraints.layerPositionAtLastLayout() - layerOffset;
> 
>-    // FIXME: Should our scroller deltas propagate to descendants?
>-    cumulativeDelta = layerPosition - m_constraints.layerPositionAtLastLayout();
>+        LOG_WITH_STREAM(Scrolling, stream << "ScrollingTreePositionedNode " << scrollingNodeID() << " applyLayerPositions: overflow delta " << scrollOffsetSinceLastCommit << " moving layer to " << layerPosition);
>+
>+        [layer _web_setLayerTopLeftPosition:layerPosition - constraints.alignmentOffset()];
>+        cumulativeDelta += layerPosition - m_layerConstraints.layerPositionAtLastLayout();
>+    };
>+
>+    if (m_ancestorClippingLayer && m_clippingLayerConstraints.scrollPositioningBehavior() == m_layerConstraints.scrollPositioningBehavior())
>+        adjustLayer(m_ancestorClippingLayer.get(), m_clippingLayerConstraints);
>+    else {
>+        if (m_ancestorClippingLayer)
>+            adjustLayer(m_ancestorClippingLayer.get(), m_clippingLayerConstraints);
>+        adjustLayer(m_layer.get(), m_layerConstraints);
>+    }
> }
> 
> void ScrollingTreePositionedNode::relatedNodeScrollPositionDidChange(const ScrollingTreeScrollingNode& changedNode, const FloatRect& layoutViewport, FloatSize& cumulativeDelta)
>@@ -118,7 +136,8 @@ void ScrollingTreePositionedNode::dumpProperties(TextStream& ts, ScrollingStateT
>     ts << "positioned node";
>     ScrollingTreeNode::dumpProperties(ts, behavior);
> 
>-    ts.dumpProperty("layout constraints", m_constraints);
>+    ts.dumpProperty("layer constraints", m_layerConstraints);
>+    ts.dumpProperty("clipping layer constraints", m_clippingLayerConstraints);
>     ts.dumpProperty("related overflow nodes", m_relatedOverflowScrollingNodes.size());
> 
>     if (behavior & ScrollingStateTreeAsTextBehaviorIncludeNodeIDs) {
>diff --git a/Source/WebCore/rendering/RenderLayer.cpp b/Source/WebCore/rendering/RenderLayer.cpp
>index 3c90cfbae599f60383e7328845d95e23bab68a6c..9499b30aafb83fa8b9149bcfffd52eb0bd1a2cde 100644
>--- a/Source/WebCore/rendering/RenderLayer.cpp
>+++ b/Source/WebCore/rendering/RenderLayer.cpp
>@@ -1618,7 +1618,7 @@ bool RenderLayer::updateLayerPosition(OptionSet<UpdateLayerPositionsFlag>* flags
>             setNeedsCompositingGeometryUpdate();
>         // This layer's position can affect the location of a composited descendant (which may be a sibling in z-order),
>         // so trigger a descendant walk from the paint-order parent.
>-        if (auto* paintParent = paintOrderParent())
>+        if (auto* paintParent = stackingContext()) // FIXME: high enough?
>             paintParent->setDescendantsNeedUpdateBackingAndHierarchyTraversal();
>     }
> 
>diff --git a/Source/WebCore/rendering/RenderLayerBacking.cpp b/Source/WebCore/rendering/RenderLayerBacking.cpp
>index c9a9a3b703b40a584d9abc4686a27702dbbfe535..1835f3bc70f4d83d5dcaddeffc9d8879e3cbfc17 100644
>--- a/Source/WebCore/rendering/RenderLayerBacking.cpp
>+++ b/Source/WebCore/rendering/RenderLayerBacking.cpp
>@@ -1853,7 +1853,7 @@ bool RenderLayerBacking::updateScrollingLayers(bool needsScrollingLayers)
>     return true;
> }
> 
>-OptionSet<ScrollCoordinationRole> RenderLayerBacking::coordinatedScrollingRoles() const
>+std::pair<OptionSet<ScrollCoordinationRole>, ScrollPositioningBehavior> RenderLayerBacking::coordinatedScrollingRoles() const
> {
>     auto& compositor = this->compositor();
> 
>@@ -1867,10 +1867,11 @@ OptionSet<ScrollCoordinationRole> RenderLayerBacking::coordinatedScrollingRoles(
>     if (compositor.isLayerForIFrameWithScrollCoordinatedContents(m_owningLayer))
>         coordinationRoles.add(ScrollCoordinationRole::FrameHosting);
> 
>-    if (compositor.computeCoordinatedPositioningForLayer(m_owningLayer) != ScrollPositioningBehavior::None)
>+    ScrollPositioningBehavior positioningBehavior;
>+    if ((positioningBehavior = compositor.computeCoordinatedPositioningForLayer(m_owningLayer)) != ScrollPositioningBehavior::None)
>         coordinationRoles.add(ScrollCoordinationRole::Positioning);
> 
>-    return coordinationRoles;
>+    return std::make_pair(coordinationRoles, positioningBehavior);
> }
> 
> void RenderLayerBacking::detachFromScrollingCoordinator(OptionSet<ScrollCoordinationRole> roles)
>diff --git a/Source/WebCore/rendering/RenderLayerBacking.h b/Source/WebCore/rendering/RenderLayerBacking.h
>index 132e5a3e606cff5be2154129b3c5e3938a0b7832..15d8fc330ed52b4eee1c3e9627e6bb92d67c04f2 100644
>--- a/Source/WebCore/rendering/RenderLayerBacking.h
>+++ b/Source/WebCore/rendering/RenderLayerBacking.h
>@@ -117,7 +117,7 @@ public:
>     GraphicsLayer* scrollContainerLayer() const { return m_scrollContainerLayer.get(); }
>     GraphicsLayer* scrolledContentsLayer() const { return m_scrolledContentsLayer.get(); }
> 
>-    OptionSet<ScrollCoordinationRole> coordinatedScrollingRoles() const;
>+    std::pair<OptionSet<ScrollCoordinationRole>, ScrollPositioningBehavior> coordinatedScrollingRoles() const;
> 
>     void detachFromScrollingCoordinator(OptionSet<ScrollCoordinationRole>);
> 
>diff --git a/Source/WebCore/rendering/RenderLayerCompositor.cpp b/Source/WebCore/rendering/RenderLayerCompositor.cpp
>index 1c61b49115dc8f209fa36cb43fdb5495c54e39de..97fb5af1b4ca6bb74084313c5ba53cd02d177b62 100644
>--- a/Source/WebCore/rendering/RenderLayerCompositor.cpp
>+++ b/Source/WebCore/rendering/RenderLayerCompositor.cpp
>@@ -583,7 +583,7 @@ void RenderLayerCompositor::didChangePlatformLayerForLayer(RenderLayer& layer, c
>         scrollingCoordinator->setNodeLayers(nodeID, { backing->graphicsLayer() });
> 
>     if (auto nodeID = backing->scrollingNodeIDForRole(ScrollCoordinationRole::Positioning))
>-        scrollingCoordinator->setNodeLayers(nodeID, { backing->graphicsLayer() });
>+        scrollingCoordinator->setNodeLayers(nodeID, { backing->graphicsLayer() }); // FIXME
> }
> 
> void RenderLayerCompositor::didPaintBacking(RenderLayerBacking*)
>@@ -3061,6 +3061,22 @@ static RenderLayer* enclosingCompositedScrollingLayer(const RenderLayer& layer,
>     return nullptr;
> }
> 
>+static RenderLayer* enclosingClippingLayer(const RenderLayer& layer, const RenderLayer& intermediateLayer, bool& sawIntermediateLayer)
>+{
>+    const auto* currLayer = layer.parent();
>+    while (currLayer) {
>+        if (currLayer == &intermediateLayer)
>+            sawIntermediateLayer = true;
>+
>+        if (currLayer->renderer().hasOverflowClip())
>+            return const_cast<RenderLayer*>(currLayer);
>+
>+        currLayer = currLayer->parent();
>+    }
>+
>+    return nullptr;
>+}
>+
> static bool isScrolledByOverflowScrollLayer(const RenderLayer& layer, const RenderLayer& overflowScrollLayer)
> {
>     bool scrolledByOverflowScroll = false;
>@@ -4187,8 +4203,9 @@ void RenderLayerCompositor::detachScrollCoordinatedLayer(RenderLayer& layer, Opt
>     backing->detachFromScrollingCoordinator(roles);
> }
> 
>-ScrollingNodeID RenderLayerCompositor::updateScrollCoordinationForLayer(RenderLayer& layer, ScrollingTreeState& treeState, OptionSet<ScrollCoordinationRole> roles, OptionSet<ScrollingNodeChangeFlags> changes)
>+ScrollingNodeID RenderLayerCompositor::updateScrollCoordinationForLayer(RenderLayer& layer, ScrollingTreeState& treeState, std::pair<OptionSet<ScrollCoordinationRole>, ScrollPositioningBehavior> roleBehaviorPair, OptionSet<ScrollingNodeChangeFlags> changes)
> {
>+    auto roles = roleBehaviorPair.first;
>     bool isViewportConstrained = roles.contains(ScrollCoordinationRole::ViewportConstrained);
> #if PLATFORM(IOS_FAMILY)
>     if (m_legacyScrollingLayerCoordinator) {
>@@ -4223,7 +4240,7 @@ ScrollingNodeID RenderLayerCompositor::updateScrollCoordinationForLayer(RenderLa
> 
>     // If there's a positioning node, it's the parent scrolling node for scrolling/frame hosting.
>     if (roles.contains(ScrollCoordinationRole::Positioning)) {
>-        newNodeID = updateScrollingNodeForPositioningRole(layer, *currentTreeState, changes);
>+        newNodeID = updateScrollingNodeForPositioningRole(layer, *currentTreeState, changes, roleBehaviorPair.second);
>         childTreeState.parentNodeID = newNodeID;
>         currentTreeState = &childTreeState;
>     } else
>@@ -4308,13 +4325,13 @@ void RenderLayerCompositor::updateScrollingNodeLayers(ScrollingNodeID nodeID, Re
> {
>     if (layer.isRenderViewLayer()) {
>         FrameView& frameView = m_renderView.frameView();
>-        scrollingCoordinator.setNodeLayers(nodeID, { nullptr,
>+        scrollingCoordinator.setNodeLayers(nodeID, { nullptr, nullptr,
>             scrollContainerLayer(), scrolledContentsLayer(),
>             fixedRootBackgroundLayer(), clipLayer(), rootContentsLayer(),
>             frameView.layerForHorizontalScrollbar(), frameView.layerForVerticalScrollbar() });
>     } else {
>         auto& backing = *layer.backing();
>-        scrollingCoordinator.setNodeLayers(nodeID, { backing.graphicsLayer(),
>+        scrollingCoordinator.setNodeLayers(nodeID, { backing.graphicsLayer(), nullptr,
>             backing.scrollContainerLayer(), backing.scrolledContentsLayer(),
>             nullptr, nullptr, nullptr,
>             layer.layerForHorizontalScrollbar(), layer.layerForVerticalScrollbar() });
>@@ -4387,7 +4404,7 @@ ScrollingNodeID RenderLayerCompositor::updateScrollingNodeForFrameHostingRole(Re
>     return newNodeID;
> }
> 
>-ScrollingNodeID RenderLayerCompositor::updateScrollingNodeForPositioningRole(RenderLayer& layer, ScrollingTreeState& treeState, OptionSet<ScrollingNodeChangeFlags> changes)
>+ScrollingNodeID RenderLayerCompositor::updateScrollingNodeForPositioningRole(RenderLayer& layer, ScrollingTreeState& treeState, OptionSet<ScrollingNodeChangeFlags> changes, ScrollPositioningBehavior positioningBehavior)
> {
>     auto* scrollingCoordinator = this->scrollingCoordinator();
> 
>@@ -4397,23 +4414,58 @@ ScrollingNodeID RenderLayerCompositor::updateScrollingNodeForPositioningRole(Ren
>         return treeState.parentNodeID.valueOr(0);
>     }
> 
>-    if (changes & ScrollingNodeChangeFlags::Layer) {
>-        auto& backing = *layer.backing();
>-        scrollingCoordinator->setNodeLayers(newNodeID, { backing.graphicsLayer() });
>-    }
>+    auto& backing = *layer.backing();
>+
>+    if (changes & ScrollingNodeChangeFlags::Layer)
>+        scrollingCoordinator->setNodeLayers(newNodeID, { backing.graphicsLayer(), backing.ancestorClippingLayer() });
> 
>     if (changes & ScrollingNodeChangeFlags::LayerGeometry && treeState.parentNodeID) {
>-        // Would be nice to avoid calling computeCoordinatedPositioningForLayer() again.
>-        auto positioningBehavior = computeCoordinatedPositioningForLayer(layer);
>         auto relatedNodeIDs = collectRelatedCoordinatedScrollingNodes(layer, positioningBehavior);
>         scrollingCoordinator->setRelatedOverflowScrollingNodes(newNodeID, WTFMove(relatedNodeIDs));
> 
>-        auto* graphicsLayer = layer.backing()->graphicsLayer();
>-        LayoutConstraints constraints;
>-        constraints.setAlignmentOffset(graphicsLayer->pixelAlignmentOffset());
>-        constraints.setLayerPositionAtLastLayout(graphicsLayer->position());
>-        constraints.setScrollPositioningBehavior(positioningBehavior);
>-        scrollingCoordinator->setPositionedNodeGeometry(newNodeID, constraints);
>+        auto ancestorClippingBehavior = ScrollPositioningBehavior::None;
>+
>+        LayoutConstraints clippingLayerConstraints;
>+
>+        if (backing.ancestorClippingLayer()) {
>+            ancestorClippingBehavior = positioningBehavior;
>+
>+            // If the clip donor moves with the scroller, we need to scroll the ancestor clip layer.
>+            auto* compositedAncestor = layer.ancestorCompositingLayer();
>+
>+            bool compositedAncestorIsInsideScroller = false;
>+            auto* scrollingAncestor = enclosingCompositedScrollingLayer(layer, *compositedAncestor, compositedAncestorIsInsideScroller);
>+
>+            bool compositedAncestorIsInsideClipLayer = false; // FIXME: unused.
>+            auto* clippingLayer = enclosingClippingLayer(layer, *compositedAncestor, compositedAncestorIsInsideClipLayer);
>+
>+            // FIXME: maybe this is just if the clipping ancestor is the scroller, it's move otherwise it's stationary (or same as the main one)
>+            if (clippingLayer == scrollingAncestor) {
>+                ASSERT(positioningBehavior != ScrollPositioningBehavior::Stationary);
>+                ancestorClippingBehavior = ScrollPositioningBehavior::None;
>+            } else {
>+                bool ancestorMovedByScroller = compositedAncestor == scrollingAncestor || isScrolledByOverflowScrollLayer(*compositedAncestor, *scrollingAncestor);
>+                bool clipLayerMovedByScroller = isScrolledByOverflowScrollLayer(*clippingLayer, *scrollingAncestor);
>+
>+                if (ancestorMovedByScroller == clipLayerMovedByScroller)
>+                    ancestorClippingBehavior = ScrollPositioningBehavior::None;
>+                else if (ancestorMovedByScroller)
>+                    ancestorClippingBehavior = ScrollPositioningBehavior::Stationary;
>+                else
>+                    ancestorClippingBehavior = ScrollPositioningBehavior::Moves;
>+            }
>+
>+            // FIXME: filter out redundant move/stationary combinations?
>+            clippingLayerConstraints.setAlignmentOffset(backing.ancestorClippingLayer()->pixelAlignmentOffset());
>+            clippingLayerConstraints.setLayerPositionAtLastLayout(backing.ancestorClippingLayer()->position());
>+            clippingLayerConstraints.setScrollPositioningBehavior(ancestorClippingBehavior);
>+        }
>+
>+        LayoutConstraints layerConstraints;
>+        layerConstraints.setAlignmentOffset(backing.graphicsLayer()->pixelAlignmentOffset());
>+        layerConstraints.setLayerPositionAtLastLayout(backing.graphicsLayer()->position());
>+        layerConstraints.setScrollPositioningBehavior(positioningBehavior);
>+        scrollingCoordinator->setPositionedNodeGeometry(newNodeID, layerConstraints, clippingLayerConstraints);
>     }
> 
>     return newNodeID;
>diff --git a/Source/WebCore/rendering/RenderLayerCompositor.h b/Source/WebCore/rendering/RenderLayerCompositor.h
>index 12c1353c4faeda4f30d836933f1d64b847ebad10..49e6933cb0d595eeeffaee3d0548b5a3f4d7831e 100644
>--- a/Source/WebCore/rendering/RenderLayerCompositor.h
>+++ b/Source/WebCore/rendering/RenderLayerCompositor.h
>@@ -493,13 +493,13 @@ private:
>     ScrollingNodeID attachScrollingNode(RenderLayer&, ScrollingNodeType, struct ScrollingTreeState&);
> 
>     // Returns the ScrollingNodeID which acts as the parent for children.
>-    ScrollingNodeID updateScrollCoordinationForLayer(RenderLayer&, struct ScrollingTreeState&, OptionSet<ScrollCoordinationRole>, OptionSet<ScrollingNodeChangeFlags>);
>+    ScrollingNodeID updateScrollCoordinationForLayer(RenderLayer&, struct ScrollingTreeState&, std::pair<OptionSet<ScrollCoordinationRole>, ScrollPositioningBehavior>, OptionSet<ScrollingNodeChangeFlags>);
> 
>     // These return the ScrollingNodeID which acts as the parent for children.
>     ScrollingNodeID updateScrollingNodeForViewportConstrainedRole(RenderLayer&, struct ScrollingTreeState&, OptionSet<ScrollingNodeChangeFlags>);
>     ScrollingNodeID updateScrollingNodeForScrollingRole(RenderLayer&, struct ScrollingTreeState&, OptionSet<ScrollingNodeChangeFlags>);
>     ScrollingNodeID updateScrollingNodeForFrameHostingRole(RenderLayer&, struct ScrollingTreeState&, OptionSet<ScrollingNodeChangeFlags>);
>-    ScrollingNodeID updateScrollingNodeForPositioningRole(RenderLayer&, struct ScrollingTreeState&, OptionSet<ScrollingNodeChangeFlags>);
>+    ScrollingNodeID updateScrollingNodeForPositioningRole(RenderLayer&, struct ScrollingTreeState&, OptionSet<ScrollingNodeChangeFlags>, ScrollPositioningBehavior);
> 
>     void updateScrollingNodeLayers(ScrollingNodeID, RenderLayer&, ScrollingCoordinator&);
> 
>diff --git a/Source/WebKit/Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp b/Source/WebKit/Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp
>index 35437c7a3562e3896a647da1e2f5dce6778e1e28..686ff308b48bccde2e6db43b163ead9d48ed787b 100644
>--- a/Source/WebKit/Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp
>+++ b/Source/WebKit/Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp
>@@ -395,11 +395,17 @@ void ArgumentCoder<ScrollingStatePositionedNode>::encode(Encoder& encoder, const
> {
>     encoder << static_cast<const ScrollingStateNode&>(node);
> 
>+    if (node.hasChangedProperty(ScrollingStatePositionedNode::AncestorClippingLayer))
>+        encoder << static_cast<GraphicsLayer::PlatformLayerID>(node.ancestorClippingLayer());
>+
>     if (node.hasChangedProperty(ScrollingStatePositionedNode::RelatedOverflowScrollingNodes))
>         encoder << node.relatedOverflowScrollingNodes();
> 
>-    if (node.hasChangedProperty(ScrollingStatePositionedNode::LayoutConstraintData))
>-        encoder << node.layoutConstraints();
>+    if (node.hasChangedProperty(ScrollingStatePositionedNode::LayerConstraints))
>+        encoder << node.layerConstraints();
>+
>+    if (node.hasChangedProperty(ScrollingStatePositionedNode::ClippingLayerConstraints))
>+        encoder << node.clippingLayerConstraints();
> }
> 
> bool ArgumentCoder<ScrollingStatePositionedNode>::decode(Decoder& decoder, ScrollingStatePositionedNode& node)
>@@ -407,6 +413,13 @@ bool ArgumentCoder<ScrollingStatePositionedNode>::decode(Decoder& decoder, Scrol
>     if (!decoder.decode(static_cast<ScrollingStateNode&>(node)))
>         return false;
> 
>+    if (node.hasChangedProperty(ScrollingStatePositionedNode::AncestorClippingLayer)) {
>+        GraphicsLayer::PlatformLayerID layerID;
>+        if (!decoder.decode(layerID))
>+            return false;
>+        node.setAncestorClippingLayer(layerID);
>+    }
>+
>     if (node.hasChangedProperty(ScrollingStatePositionedNode::RelatedOverflowScrollingNodes)) {
>         Vector<ScrollingNodeID> decodedValue;
>         if (!decoder.decode(decodedValue))
>@@ -414,11 +427,18 @@ bool ArgumentCoder<ScrollingStatePositionedNode>::decode(Decoder& decoder, Scrol
>         node.setRelatedOverflowScrollingNodes(WTFMove(decodedValue));
>     }
> 
>-    if (node.hasChangedProperty(ScrollingStatePositionedNode::LayoutConstraintData)) {
>+    if (node.hasChangedProperty(ScrollingStatePositionedNode::LayerConstraints)) {
>         LayoutConstraints decodedValue;
>         if (!decoder.decode(decodedValue))
>             return false;
>-        node.updateConstraints(decodedValue);
>+        node.setLayerConstraints(decodedValue);
>+    }
>+
>+    if (node.hasChangedProperty(ScrollingStatePositionedNode::ClippingLayerConstraints)) {
>+        LayoutConstraints decodedValue;
>+        if (!decoder.decode(decodedValue))
>+            return false;
>+        node.setClippingLayerConstraints(decodedValue);
>     }
> 
>     return true;
>@@ -669,8 +689,11 @@ static void dump(TextStream& ts, const ScrollingStatePositionedNode& node, bool
>     if (!changedPropertiesOnly || node.hasChangedProperty(ScrollingStatePositionedNode::RelatedOverflowScrollingNodes))
>         ts << node.relatedOverflowScrollingNodes();
> 
>-    if (!changedPropertiesOnly || node.hasChangedProperty(ScrollingStatePositionedNode::LayoutConstraintData))
>-        ts << node.layoutConstraints();
>+    if (!changedPropertiesOnly || node.hasChangedProperty(ScrollingStatePositionedNode::LayerConstraints))
>+        ts << node.layerConstraints();
>+
>+    if (!changedPropertiesOnly || node.hasChangedProperty(ScrollingStatePositionedNode::ClippingLayerConstraints))
>+        ts << node.clippingLayerConstraints();
> }
> 
> static void dump(TextStream& ts, const ScrollingStateNode& node, bool changedPropertiesOnly)
>diff --git a/Source/WebKit/UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.cpp b/Source/WebKit/UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.cpp
>index 3b838ea602f8a46e1c218018e68814156a33753a..e1e1105fb8ded174ae921fa04e8fae381773de60 100644
>--- a/Source/WebKit/UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.cpp
>+++ b/Source/WebKit/UIProcess/RemoteLayerTree/RemoteScrollingCoordinatorProxy.cpp
>@@ -156,10 +156,15 @@ void RemoteScrollingCoordinatorProxy::connectStateNodeLayers(ScrollingStateTree&
>                 scrollingStateNode.setHorizontalScrollbarLayer(layerTreeHost.layerForID(scrollingStateNode.horizontalScrollbarLayer()));
>             break;
>         }
>+        case ScrollingNodeType::Positioned: {
>+            ScrollingStatePositionedNode& positionedStateNode = downcast<ScrollingStatePositionedNode>(*currNode);
>+            if (positionedStateNode.hasChangedProperty(ScrollingStatePositionedNode::AncestorClippingLayer))
>+                positionedStateNode.setAncestorClippingLayer(layerTreeHost.layerForID(positionedStateNode.ancestorClippingLayer()));
>+            break;
>+        }
>         case ScrollingNodeType::FrameHosting:
>         case ScrollingNodeType::Fixed:
>         case ScrollingNodeType::Sticky:
>-        case ScrollingNodeType::Positioned:
>             break;
>         }
>     }
>diff --git a/Source/WebKit/UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm b/Source/WebKit/UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm
>index 97dbcb4d757b5f292d40f810bcd154a730c7a06d..e3252000a99141e0e21cde5985af6e653c03b623 100644
>--- a/Source/WebKit/UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm
>+++ b/Source/WebKit/UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm
>@@ -88,10 +88,15 @@ void RemoteScrollingCoordinatorProxy::connectStateNodeLayers(ScrollingStateTree&
>                 scrollingStateNode.setFooterLayer(layerTreeHost.layerForID(scrollingStateNode.footerLayer()));
>             break;
>         }
>+        case ScrollingNodeType::Positioned: {
>+            ScrollingStatePositionedNode& positionedStateNode = downcast<ScrollingStatePositionedNode>(*currNode);
>+            if (positionedStateNode.hasChangedProperty(ScrollingStatePositionedNode::AncestorClippingLayer))
>+                positionedStateNode.setAncestorClippingLayer(layerTreeHost.layerForID(positionedStateNode.ancestorClippingLayer()));
>+            break;
>+        }
>         case ScrollingNodeType::FrameHosting:
>         case ScrollingNodeType::Fixed:
>         case ScrollingNodeType::Sticky:
>-        case ScrollingNodeType::Positioned:
>             break;
>         }
>     }
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index 1df60b48c2f4e004360becf96b1d7a07da931a3a..d73cf3f825cd9c26222604b93b1dffc84d298f72 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,13 @@
>+2019-05-22  Simon Fraser  <simon.fraser@apple.com>
>+
>+        [iOS WK2] Clipped, absolutely positioned elements inside overflow:scroll jiggle
>+        https://bugs.webkit.org/show_bug.cgi?id=196885
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * scrollingcoordinator/ios/nested-absolute-layer-with-clipping-expected.html: Added.
>+        * scrollingcoordinator/ios/nested-absolute-layer-with-clipping.html: Added.
>+
> 2019-05-22  Simon Fraser  <simon.fraser@apple.com>
> 
>         <rdar://problem/50058173> REGRESSION (r243347) Layout tests fast/events/touch/ios/drag-block-without-overflow-scroll-and-passive-observer-on* are failing
>diff --git a/LayoutTests/scrollingcoordinator/ios/nested-absolute-layer-with-clipping-expected.html b/LayoutTests/scrollingcoordinator/ios/nested-absolute-layer-with-clipping-expected.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..618f9dd82d6c887baa1d6cdcd264e0bfe99133d3
>--- /dev/null
>+++ b/LayoutTests/scrollingcoordinator/ios/nested-absolute-layer-with-clipping-expected.html
>@@ -0,0 +1,64 @@
>+<!DOCTYPE html> 
>+<html>
>+<head>
>+    <meta name="viewport" content="initial-scale=1.0">
>+    <style>
>+        #scroller {
>+            margin: 10px;
>+            height: 300px;
>+            width: 300px;
>+            border: 1px solid black;
>+            overflow: scroll;
>+            opacity: 0.999; /* Make this a stacking context */
>+        }
>+        
>+        .absolute {
>+            position: absolute;
>+            overflow: hidden;
>+            width: 200px;
>+            height: 200px;
>+        }
>+
>+        .outer {
>+            top: 50px;
>+            left: 50px;
>+            padding: 20px;
>+            border: 1px solid blue;
>+        }
>+        
>+        .inner {
>+            background-color: blue;
>+        }
>+        
>+        .spacer {
>+            height: 1000px;
>+            background-image: repeating-linear-gradient(white, silver 200px);
>+        }
>+    </style>
>+    <script src="../../resources/ui-helper.js"></script>
>+    <script>
>+        if (window.testRunner)
>+            testRunner.waitUntilDone();
>+
>+        async function doTest()
>+        {
>+            await UIHelper.ensurePresentationUpdate(); // Not sure why this is necessary, but it is.
>+            scroller.scrollTo(0, 100);
>+            await UIHelper.ensurePresentationUpdate();
>+
>+            if (window.testRunner)
>+                testRunner.notifyDone();
>+        }
>+        
>+        window.addEventListener('load', doTest, false);
>+    </script>
>+</head>
>+<body>
>+    <div id="scroller">
>+        <div class="outer absolute">
>+            <div class="inner absolute"></div>
>+        </div>
>+        <div class="spacer"></div>
>+    </div>
>+</body>
>+</html>
>diff --git a/LayoutTests/scrollingcoordinator/ios/nested-absolute-layer-with-clipping.html b/LayoutTests/scrollingcoordinator/ios/nested-absolute-layer-with-clipping.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..674077c217519a4bb830593a5acea4e175083790
>--- /dev/null
>+++ b/LayoutTests/scrollingcoordinator/ios/nested-absolute-layer-with-clipping.html
>@@ -0,0 +1,74 @@
>+<!DOCTYPE html> 
>+<html>
>+<head>
>+    <meta name="viewport" content="initial-scale=1.0">
>+    <style>
>+        #scroller {
>+            margin: 10px;
>+            height: 300px;
>+            width: 300px;
>+            border: 1px solid black;
>+            overflow: scroll;
>+            opacity: 0.999; /* Make this a stacking context */
>+        }
>+        
>+        .absolute {
>+            position: absolute;
>+            overflow: hidden;
>+            width: 200px;
>+            height: 200px;
>+        }
>+
>+        .outer {
>+            top: 50px;
>+            left: 50px;
>+            padding: 20px;
>+            border: 1px solid blue;
>+        }
>+        
>+        .inner {
>+            background-color: blue;
>+        }
>+        
>+        .spacer {
>+            height: 1000px;
>+            background-image: repeating-linear-gradient(white, silver 200px);
>+        }
>+    </style>
>+    <script>
>+        if (window.testRunner)
>+            testRunner.waitUntilDone();
>+
>+        function getUnstableScrollScript(x, y, scrollX, scrollY)
>+        {
>+            return `(function() {
>+                uiController.scrollUpdatesDisabled = true;
>+                uiController.immediateScrollElementAtContentPointToOffset(${x}, ${y}, ${scrollX}, ${scrollY});
>+                uiController.doAfterPresentationUpdate(function() {
>+                    uiController.uiScriptComplete();
>+                });
>+            })();`;
>+        }
>+
>+        function doTest()
>+        {
>+            if (!testRunner.runUIScript)
>+                return
>+
>+            testRunner.runUIScript(getUnstableScrollScript(20, 20, 0, 100), () => {
>+                testRunner.notifyDone();
>+            });
>+        }
>+        
>+        window.addEventListener('load', doTest, false);
>+    </script>
>+</head>
>+<body>
>+    <div id="scroller">
>+        <div class="outer absolute">
>+            <div class="inner absolute"></div>
>+        </div>
>+        <div class="spacer"></div>
>+    </div>
>+</body>
>+</html>

Actions: View | Formatted Diff | Diff

Attachments on bug 196885: 367358 | 367538 | 367636 | 367653 | 367680 | 370483 | 370489 | 370491 | 370571