Changeset 246725 in webkit

Timestamp:

Jun 23, 2019 8:09:40 PM (5 years ago)

Author:

Simon Fraser

Message:

[Async overflow scroll] Clipped composited layers inside overflow scroll jitter and get incorrectly clipped
​https://bugs.webkit.org/show_bug.cgi?id=199133
rdar://problem/43614439

Reviewed by Antti Koivisto.
Source/WebCore:

Currently a composited layer with an overflow:scroll ancestor (which is not a paint-order
ancestor) gets a single "ancestor clip layer" that represents the intersection of all the
clips provided by its containing-block ancestors with non-visible overflow (both scrolling
and non-scrolling ones).

To correctly update clips with async overflow scroll, this single clip layer needs to be
broken up into multiple clipping ancestors. We need a separate layer, and scrolling tree
node for each ancestor that is an overflow scroll, and layers that represent non-moving
clips (i.e. overflow:hidden and 'clip') between them. This patch adds
LayerAncestorClippingStack to represent this stack of clipping layers. For example with the
following content:

<div style="overflow:hidden"> <--- A

<div style="overflow:scroll"> <--- B

<div style="overflow:hidden"> <--- C

<div style="overflow:hidden"> <--- D

<div style="overflow:scroll"> <--- E

<div style="overflow:hidden"> <--- F

<div style="overflow:hidden"> <--- G

<div></div> <--- H

<div>

<div>

<div>

<div>

<div>

<div>

<div>

the composited RenderLayer for H owns a LayerAncestorClippingStack with the following contents:

[clip - A]
[scroller - B]
[clip - intersection of C and D]
[scroller - E]
[clip - intersection of F and G]

Each stack entry has a 'masksToBounds' GraphicsLayer for clipping. Entries representing
overflow:scroll clips have a ScrollingNodeID for their OverflowScrollProxy scrolling tree
node (which references the actual OverflowScrollingNode). The non-scroller clips in this
stack are computed unconstrained by the enclosing overflow:scroll.

When the OverflowScrollingNode is scrolled, the boundsOrigin of related OverflowScrollProxy nodes
is adjusted to move the descendant layers (other clipping layers, or composited layers).

OverflowScrollProxy nodes thus take over the role that "Moves" ScrollingTreePositionedNode had.
With this patch, ScrollingTreePositionedNode are purely for absolute position inside non-containing-block
stacking context overflow scroll. LayoutConstraints is renamed to AbsolutePositionConstraints accordingly.

Tests: compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-clipped-by-scroll.html

compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-nested.html
compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow.html
compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-hidden.html
compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-visible.html
compositing/scrolling/async-overflow-scrolling/layer-in-overflow-gain-clipping-layer.html
compositing/scrolling/async-overflow-scrolling/layer-in-overflow-in-clipped.html
compositing/scrolling/async-overflow-scrolling/layer-in-overflow-lose-clipping-layer.html
compositing/scrolling/async-overflow-scrolling/layer-in-overflow.html
scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-nested.html
scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow.html

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

(WebCore::AsyncScrollingCoordinator::setPositionedNodeConstraints):
(WebCore::AsyncScrollingCoordinator::setPositionedNodeGeometry): Deleted.

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

(WebCore::operator<<):

• page/scrolling/ScrollingConstraints.h:

(WebCore::AbsolutePositionConstraints::operator== const):
(WebCore::AbsolutePositionConstraints::operator!= const):
(WebCore::LayoutConstraints::operator== const): Deleted.
(WebCore::LayoutConstraints::operator!= const): Deleted.
(WebCore::LayoutConstraints::alignmentOffset const): Deleted.
(WebCore::LayoutConstraints::setAlignmentOffset): Deleted.
(WebCore::LayoutConstraints::layerPositionAtLastLayout const): Deleted.
(WebCore::LayoutConstraints::setLayerPositionAtLastLayout): Deleted.
(WebCore::LayoutConstraints::scrollPositioningBehavior const): Deleted.
(WebCore::LayoutConstraints::setScrollPositioningBehavior): Deleted.

• page/scrolling/ScrollingCoordinator.h:

(WebCore::ScrollingCoordinator::setPositionedNodeConstraints):
(WebCore::ScrollingCoordinator::setPositionedNodeGeometry): Deleted.

• page/scrolling/ScrollingStatePositionedNode.cpp:

(WebCore::ScrollingStatePositionedNode::updateConstraints):

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

(WebCore::ScrollingTree::commitTreeState):

• page/scrolling/ScrollingTree.h:

(WebCore::ScrollingTree::nodesWithRelatedOverflow):
(WebCore::ScrollingTree::positionedNodesWithRelatedOverflow): Deleted.

• page/scrolling/cocoa/ScrollingTreeFixedNode.mm:

(WebCore::ScrollingTreeFixedNode::applyLayerPositions):

• page/scrolling/cocoa/ScrollingTreeOverflowScrollProxyNode.mm:

(WebCore::ScrollingTreeOverflowScrollProxyNode::commitStateBeforeChildren):

• page/scrolling/cocoa/ScrollingTreePositionedNode.h:

(WebCore::ScrollingTreePositionedNode::scrollPositioningBehavior const): Deleted.

• page/scrolling/cocoa/ScrollingTreePositionedNode.mm:

(WebCore::ScrollingTreePositionedNode::commitStateBeforeChildren):
(WebCore::ScrollingTreePositionedNode::scrollDeltaSinceLastCommit const):

• page/scrolling/cocoa/ScrollingTreeStickyNode.mm:

(WebCore::ScrollingTreeStickyNode::computeLayerPosition const):

• rendering/LayerAncestorClippingStack.cpp: Added.

(WebCore::LayerAncestorClippingStack::LayerAncestorClippingStack):
(WebCore::LayerAncestorClippingStack::equalToClipData const):
(WebCore::LayerAncestorClippingStack::hasAnyScrollingLayers const):
(WebCore::LayerAncestorClippingStack::clear):
(WebCore::LayerAncestorClippingStack::detachFromScrollingCoordinator):
(WebCore::LayerAncestorClippingStack::firstClippingLayer const):
(WebCore::LayerAncestorClippingStack::lastClippingLayer const):
(WebCore::LayerAncestorClippingStack::lastOverflowScrollProxyNodeID const):
(WebCore::LayerAncestorClippingStack::updateScrollingNodeLayers):
(WebCore::LayerAncestorClippingStack::updateWithClipData):
(WebCore::operator<<):

• rendering/LayerAncestorClippingStack.h: Added.

(WebCore::CompositedClipData::CompositedClipData):
(WebCore::CompositedClipData::operator== const):
(WebCore::CompositedClipData::operator!= const):
(WebCore::LayerAncestorClippingStack::stack):
(WebCore::LayerAncestorClippingStack::stack const):

• rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::~RenderLayerBacking):
(WebCore::RenderLayerBacking::updateDebugIndicators):
(WebCore::RenderLayerBacking::destroyGraphicsLayers):
(WebCore::RenderLayerBacking::updateTransform):
(WebCore::RenderLayerBacking::updateBlendMode):
(WebCore::RenderLayerBacking::updateAfterLayout):
(WebCore::RenderLayerBacking::updateConfiguration):
(WebCore::computeOffsetFromAncestorGraphicsLayer):
(WebCore::RenderLayerBacking::computePrimaryGraphicsLayerRect const):
(WebCore::RenderLayerBacking::computeParentGraphicsLayerRect const):
(WebCore::RenderLayerBacking::updateGeometry):
(WebCore::RenderLayerBacking::updateInternalHierarchy):
(WebCore::RenderLayerBacking::updateAncestorClippingStack):
(WebCore::RenderLayerBacking::updateAncestorClipping):
(WebCore::RenderLayerBacking::detachFromScrollingCoordinator):
(WebCore::RenderLayerBacking::scrollingNodeIDForChildren const):
(WebCore::RenderLayerBacking::childForSuperlayers const):
(WebCore::RenderLayerBacking::backingStoreMemoryEstimate const):
(WebCore::operator<<):
(WebCore::RenderLayerBacking::updateAncestorClippingLayer): Deleted.
(WebCore::RenderLayerBacking::coordinatedScrollingRoles const): Deleted.

• rendering/RenderLayerBacking.h:
• rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::didChangePlatformLayerForLayer):
(WebCore::RenderLayerCompositor::updateBackingAndHierarchy):
(WebCore::RenderLayerCompositor::layerStyleChanged): We need to run the checks for changed
clipping whether or not this layer has backing, because a non-composited layer with clipping can be
represented in the clipping stack of some other layer.
(WebCore::RenderLayerCompositor::clippedByAncestor const):
(WebCore::RenderLayerCompositor::updateAncestorClippingStack const):
(WebCore::RenderLayerCompositor::computeAncestorClippingStack const): The output of this function
is a Vector<CompositedClipData> which represents the ancestor clipping stack, but without the proxy node
and GraphicsLayer information. It's input to LayerAncestorClippingStack::updateWithClipData() which does
the merging of old and new states.
(WebCore::collectRelatedCoordinatedScrollingNodes):
(WebCore::RenderLayerCompositor::removeFromScrollCoordinatedLayers):
(WebCore::scrollCoordinationRoleForNodeType):
(WebCore::RenderLayerCompositor::attachScrollingNode):
(WebCore::RenderLayerCompositor::registerScrollingNodeID):
(WebCore::RenderLayerCompositor::detachScrollCoordinatedLayerWithRole):
(WebCore::RenderLayerCompositor::detachScrollCoordinatedLayer):
(WebCore::RenderLayerCompositor::coordinatedScrollingRolesForLayer const): Code moved from RenderLayerBacking.
(WebCore::RenderLayerCompositor::updateScrollCoordinationForLayer):
(WebCore::RenderLayerCompositor::updateScrollingNodeForScrollingProxyRole):
(WebCore::RenderLayerCompositor::updateScrollingNodeForPositioningRole):

• rendering/RenderLayerCompositor.h:

(WebCore::allScrollCoordinationRoles):

Source/WebKit:

LayoutConstraints -> AbsolutePositionConstraints rename.

• Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp:

(ArgumentCoder<ScrollingStatePositionedNode>::decode):

• Shared/WebCoreArgumentCoders.cpp:

(IPC::ArgumentCoder<AbsolutePositionConstraints>::encode):
(IPC::ArgumentCoder<AbsolutePositionConstraints>::decode):
(IPC::ArgumentCoder<LayoutConstraints>::encode): Deleted.
(IPC::ArgumentCoder<LayoutConstraints>::decode): Deleted.

• Shared/WebCoreArgumentCoders.h:
• Shared/WebRenderLayer.cpp:

(WebKit::WebRenderLayer::WebRenderLayer):

• UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm:

(WebKit::RemoteScrollingCoordinatorProxy::establishLayerTreeScrollingRelations): ScrollingTreeOverflowScrollProxyNode
have overflow scroll relations now too.

LayoutTests:

New baselines for:

• clipping layers no longer have offsetFromRenderer(), which they didn't need.
• positioned nodes don't print scrollBehavior (they are always "Stationary")
• "Moves" positioned nodes are replaced with overflow scroll proxy nodes

• compositing/backing/backing-store-attachment-empty-keyframe-expected.txt:
• compositing/geometry/clip-expected.txt:
• compositing/geometry/clip-inside-expected.txt:
• compositing/geometry/limit-layer-bounds-clipping-ancestor-expected.txt:
• compositing/layer-creation/clipping-scope/nested-scroller-overlap-expected.txt:
• compositing/layer-creation/clipping-scope/nested-scroller-overlap.html:
• compositing/layer-creation/clipping-scope/overlap-constrained-inside-scroller-expected.txt:
• compositing/layer-creation/clipping-scope/scroller-with-negative-z-children-expected.txt:
• compositing/overflow/clip-descendents-expected.txt:
• compositing/overflow/scrolling-content-clip-to-viewport-expected.txt:
• compositing/rtl/rtl-scrolling-with-transformed-descendants-expected.txt:
• compositing/rtl/rtl-scrolling-with-transformed-descendants.html:
• compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-clipped-by-scroll-expected.txt: Added.
• compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-clipped-by-scroll.html: Added.
• compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-expected.txt: Added.
• compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-nested-expected.txt: Added.
• compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-nested.html: Added.
• compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow.html: Added.
• compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-hidden-expected.txt: Added.
• compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-hidden.html: Added.
• compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-visible-expected.txt: Added.
• compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-visible.html: Added.
• compositing/scrolling/async-overflow-scrolling/layer-in-overflow-expected.txt: Added.
• compositing/scrolling/async-overflow-scrolling/layer-in-overflow-gain-clipping-layer-expected.txt: Added.
• compositing/scrolling/async-overflow-scrolling/layer-in-overflow-gain-clipping-layer.html: Added.
• compositing/scrolling/async-overflow-scrolling/layer-in-overflow-in-clipped-expected.txt: Added.
• compositing/scrolling/async-overflow-scrolling/layer-in-overflow-in-clipped.html: Added.
• compositing/scrolling/async-overflow-scrolling/layer-in-overflow-lose-clipping-layer-expected.txt: Added.
• compositing/scrolling/async-overflow-scrolling/layer-in-overflow-lose-clipping-layer.html: Added.
• compositing/scrolling/async-overflow-scrolling/layer-in-overflow.html: Added.
• compositing/shared-backing/overflow-scroll/composited-absolute-in-absolute-in-relative-in-scroller-expected.txt:
• compositing/shared-backing/overflow-scroll/previous-sibling-prevents-inclusiveness-expected.txt:
• compositing/shared-backing/overflow-scroll/previous-sibling-prevents-inclusiveness.html:
• platform/ios-wk2/compositing/layer-creation/clipping-scope/nested-scroller-overlap-expected.txt:
• platform/ios-wk2/compositing/layer-creation/clipping-scope/overlap-constrained-inside-scroller-expected.txt:
• platform/ios-wk2/compositing/layer-creation/clipping-scope/scroller-with-negative-z-children-expected.txt:
• platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-clipped-by-scroll-expected.txt: Added.
• platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-expected.txt: Added.
• platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-nested-expected.txt: Added.
• platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-hidden-expected.txt: Added.
• platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-visible-expected.txt: Added.
• platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-expected.txt: Added.
• platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-gain-clipping-layer-expected.txt: Added.
• platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-in-clipped-expected.txt: Added.
• platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-lose-clipping-layer-expected.txt: Added.
• platform/ios-wk2/compositing/shared-backing/overflow-scroll/composited-absolute-in-absolute-in-relative-in-scroller-expected.txt:
• platform/ios-wk2/compositing/shared-backing/overflow-scroll/previous-sibling-prevents-inclusiveness-expected.txt:
• platform/ios-wk2/scrollingcoordinator/scrolling-tree/absolute-in-nested-sc-scrollers-expected.txt:
• platform/ios-wk2/scrollingcoordinator/scrolling-tree/absolute-inside-stacking-in-scroller-expected.txt:
• platform/ios-wk2/scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-expected.txt: Copied from LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/absolute-inside-stacking-in-scroller-expected.txt.
• platform/ios-wk2/scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-nested-expected.txt: Copied from LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-overflow-scroll-expected.txt.
• platform/ios-wk2/scrollingcoordinator/scrolling-tree/composited-in-absolute-in-stacking-context-overflow-expected.txt:
• platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-absolute-in-absolute-overflow-expected.txt:
• platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-absolute-in-relative-in-overflow-expected.txt:
• platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-absolute-in-sc-overflow-expected.txt:
• platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-overflow-scroll-expected.txt:
• platform/ios-wk2/scrollingcoordinator/scrolling-tree/positioned-nodes-complex-expected.txt:
• platform/ios-wk2/scrollingcoordinator/scrolling-tree/positioned-nodes-expected.txt:
• platform/ios-wk2/scrollingcoordinator/scrolling-tree/sticky-in-overflow-expected.txt:
• platform/ios/compositing/geometry/limit-layer-bounds-clipping-ancestor-expected.txt:
• platform/ios/compositing/rtl/rtl-scrolling-with-transformed-descendants-expected.txt:
• scrollingcoordinator/scrolling-tree/absolute-in-nested-sc-scrollers-expected.txt:
• scrollingcoordinator/scrolling-tree/absolute-inside-stacking-in-scroller-expected.txt:
• scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-expected.txt: Copied from LayoutTests/scrollingcoordinator/scrolling-tree/absolute-inside-stacking-in-scroller-expected.txt.
• scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-nested-expected.txt: Copied from LayoutTests/scrollingcoordinator/scrolling-tree/nested-overflow-scroll-expected.txt.
• scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-nested.html: Added.
• scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow.html: Added.
• scrollingcoordinator/scrolling-tree/composited-in-absolute-in-stacking-context-overflow-expected.txt:
• scrollingcoordinator/scrolling-tree/nested-absolute-in-absolute-overflow-expected.txt:
• scrollingcoordinator/scrolling-tree/nested-absolute-in-relative-in-overflow-expected.txt:
• scrollingcoordinator/scrolling-tree/nested-absolute-in-sc-overflow-expected.txt:
• scrollingcoordinator/scrolling-tree/nested-overflow-scroll-expected.txt:
• scrollingcoordinator/scrolling-tree/positioned-nodes-complex-expected.txt:
• scrollingcoordinator/scrolling-tree/positioned-nodes-expected.txt:
• scrollingcoordinator/scrolling-tree/sticky-in-overflow-expected.txt:

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/compositing/backing/backing-store-attachment-empty-keyframe-expected.txt (modified) (1 diff)
• LayoutTests/compositing/geometry/clip-expected.txt (modified) (1 diff)
• LayoutTests/compositing/geometry/clip-inside-expected.txt (modified) (1 diff)
• LayoutTests/compositing/geometry/limit-layer-bounds-clipping-ancestor-expected.txt (modified) (1 diff)
• LayoutTests/compositing/layer-creation/clipping-scope/nested-scroller-overlap-expected.txt (modified) (5 diffs)
• LayoutTests/compositing/layer-creation/clipping-scope/nested-scroller-overlap.html (modified) (1 diff)
• LayoutTests/compositing/layer-creation/clipping-scope/overlap-constrained-inside-scroller-expected.txt (modified) (4 diffs)
• LayoutTests/compositing/layer-creation/clipping-scope/scroller-with-negative-z-children-expected.txt (modified) (3 diffs)
• LayoutTests/compositing/overflow/clip-descendents-expected.txt (modified) (2 diffs)
• LayoutTests/compositing/overflow/scrolling-content-clip-to-viewport-expected.txt (modified) (1 diff)
• LayoutTests/compositing/rtl/rtl-scrolling-with-transformed-descendants-expected.txt (modified) (4 diffs)
• LayoutTests/compositing/rtl/rtl-scrolling-with-transformed-descendants.html (modified) (1 diff)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-clipped-by-scroll-expected.txt (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-clipped-by-scroll.html (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-expected.txt (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-nested-expected.txt (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-nested.html (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow.html (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-hidden-expected.txt (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-hidden.html (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-visible-expected.txt (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-visible.html (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-expected.txt (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-gain-clipping-layer-expected.txt (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-gain-clipping-layer.html (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-in-clipped-expected.txt (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-in-clipped.html (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-lose-clipping-layer-expected.txt (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-lose-clipping-layer.html (added)
• LayoutTests/compositing/scrolling/async-overflow-scrolling/layer-in-overflow.html (added)
• LayoutTests/compositing/shared-backing/overflow-scroll/composited-absolute-in-absolute-in-relative-in-scroller-expected.txt (modified) (1 diff)
• LayoutTests/compositing/shared-backing/overflow-scroll/previous-sibling-prevents-inclusiveness-expected.txt (modified) (4 diffs)
• LayoutTests/compositing/shared-backing/overflow-scroll/previous-sibling-prevents-inclusiveness.html (modified) (1 diff)
• LayoutTests/legacy-animation-engine/compositing/backing/backing-store-attachment-empty-keyframe-expected.txt (modified) (1 diff)
• LayoutTests/platform/ios-wk2/compositing/layer-creation/clipping-scope/nested-scroller-overlap-expected.txt (modified) (5 diffs)
• LayoutTests/platform/ios-wk2/compositing/layer-creation/clipping-scope/overlap-constrained-inside-scroller-expected.txt (modified) (4 diffs)
• LayoutTests/platform/ios-wk2/compositing/layer-creation/clipping-scope/scroller-with-negative-z-children-expected.txt (modified) (3 diffs)
• LayoutTests/platform/ios-wk2/compositing/scrolling/async-overflow-scrolling (added)
• LayoutTests/platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-clipped-by-scroll-expected.txt (added)
• LayoutTests/platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-expected.txt (added)
• LayoutTests/platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-nested-expected.txt (added)
• LayoutTests/platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-hidden-expected.txt (added)
• LayoutTests/platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-visible-expected.txt (added)
• LayoutTests/platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-expected.txt (added)
• LayoutTests/platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-gain-clipping-layer-expected.txt (added)
• LayoutTests/platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-in-clipped-expected.txt (added)
• LayoutTests/platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-lose-clipping-layer-expected.txt (added)
• LayoutTests/platform/ios-wk2/compositing/shared-backing/overflow-scroll/composited-absolute-in-absolute-in-relative-in-scroller-expected.txt (modified) (1 diff)
• LayoutTests/platform/ios-wk2/compositing/shared-backing/overflow-scroll/previous-sibling-prevents-inclusiveness-expected.txt (modified) (4 diffs)
• LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/absolute-in-nested-sc-scrollers-expected.txt (modified) (1 diff)
• LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/absolute-inside-stacking-in-scroller-expected.txt (modified) (1 diff)
• LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-expected.txt (copied) (copied from trunk/LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/absolute-inside-stacking-in-scroller-expected.txt) (2 diffs)
• LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-nested-expected.txt (copied) (copied from trunk/LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-overflow-scroll-expected.txt) (3 diffs)
• LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/composited-in-absolute-in-stacking-context-overflow-expected.txt (modified) (1 diff)
• LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-absolute-in-absolute-overflow-expected.txt (modified) (1 diff)
• LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-absolute-in-relative-in-overflow-expected.txt (modified) (1 diff)
• LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-absolute-in-sc-overflow-expected.txt (modified) (1 diff)
• LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-overflow-scroll-expected.txt (modified) (1 diff)
• LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/positioned-nodes-complex-expected.txt (modified) (6 diffs)
• LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/positioned-nodes-expected.txt (modified) (2 diffs)
• LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/sticky-in-overflow-expected.txt (modified) (1 diff)
• LayoutTests/platform/ios/compositing/geometry/limit-layer-bounds-clipping-ancestor-expected.txt (modified) (1 diff)
• LayoutTests/platform/ios/compositing/rtl/rtl-scrolling-with-transformed-descendants-expected.txt (modified) (2 diffs)
• LayoutTests/platform/ios/media/video-play-glyph-composited-outside-overflow-scrolling-touch-container-expected.txt (modified) (1 diff)
• LayoutTests/platform/mac-wk1/compositing/overflow/scrolling-content-clip-to-viewport-expected.txt (modified) (1 diff)
• LayoutTests/platform/mac-wk1/compositing/rtl/rtl-scrolling-with-transformed-descendants-expected.txt (modified) (2 diffs)
• LayoutTests/scrollingcoordinator/scrolling-tree/absolute-in-nested-sc-scrollers-expected.txt (modified) (1 diff)
• LayoutTests/scrollingcoordinator/scrolling-tree/absolute-inside-stacking-in-scroller-expected.txt (modified) (1 diff)
• LayoutTests/scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-expected.txt (copied) (copied from trunk/LayoutTests/scrollingcoordinator/scrolling-tree/absolute-inside-stacking-in-scroller-expected.txt) (2 diffs)
• LayoutTests/scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-nested-expected.txt (copied) (copied from trunk/LayoutTests/scrollingcoordinator/scrolling-tree/nested-overflow-scroll-expected.txt) (2 diffs)
• LayoutTests/scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-nested.html (added)
• LayoutTests/scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow.html (added)
• LayoutTests/scrollingcoordinator/scrolling-tree/composited-in-absolute-in-stacking-context-overflow-expected.txt (modified) (1 diff)
• LayoutTests/scrollingcoordinator/scrolling-tree/nested-absolute-in-absolute-overflow-expected.txt (modified) (1 diff)
• LayoutTests/scrollingcoordinator/scrolling-tree/nested-absolute-in-relative-in-overflow-expected.txt (modified) (1 diff)
• LayoutTests/scrollingcoordinator/scrolling-tree/nested-absolute-in-sc-overflow-expected.txt (modified) (1 diff)
• LayoutTests/scrollingcoordinator/scrolling-tree/nested-overflow-scroll-expected.txt (modified) (1 diff)
• LayoutTests/scrollingcoordinator/scrolling-tree/positioned-nodes-complex-expected.txt (modified) (6 diffs)
• LayoutTests/scrollingcoordinator/scrolling-tree/positioned-nodes-expected.txt (modified) (2 diffs)
• LayoutTests/scrollingcoordinator/scrolling-tree/sticky-in-overflow-expected.txt (modified) (1 diff)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/Headers.cmake (modified) (1 diff)
• Source/WebCore/Sources.txt (modified) (1 diff)
• Source/WebCore/WebCore.xcodeproj/project.pbxproj (modified) (4 diffs)
• Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp (modified) (1 diff)
• Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h (modified) (1 diff)
• Source/WebCore/page/scrolling/ScrollingConstraints.cpp (modified) (1 diff)
• Source/WebCore/page/scrolling/ScrollingConstraints.h (modified) (3 diffs)
• Source/WebCore/page/scrolling/ScrollingCoordinator.h (modified) (2 diffs)
• Source/WebCore/page/scrolling/ScrollingStatePositionedNode.cpp (modified) (1 diff)
• Source/WebCore/page/scrolling/ScrollingStatePositionedNode.h (modified) (3 diffs)
• Source/WebCore/page/scrolling/ScrollingTree.cpp (modified) (1 diff)
• Source/WebCore/page/scrolling/ScrollingTree.h (modified) (2 diffs)
• Source/WebCore/page/scrolling/cocoa/ScrollingTreeFixedNode.mm (modified) (2 diffs)
• Source/WebCore/page/scrolling/cocoa/ScrollingTreeOverflowScrollProxyNode.mm (modified) (1 diff)
• Source/WebCore/page/scrolling/cocoa/ScrollingTreePositionedNode.h (modified) (2 diffs)
• Source/WebCore/page/scrolling/cocoa/ScrollingTreePositionedNode.mm (modified) (2 diffs)
• Source/WebCore/page/scrolling/cocoa/ScrollingTreeStickyNode.mm (modified) (2 diffs)
• Source/WebCore/platform/graphics/GraphicsContext.h (modified) (2 diffs)
• Source/WebCore/rendering/LayerAncestorClippingStack.cpp (added)
• Source/WebCore/rendering/LayerAncestorClippingStack.h (added)
• Source/WebCore/rendering/RenderLayer.cpp (modified) (1 diff)
• Source/WebCore/rendering/RenderLayerBacking.cpp (modified) (25 diffs)
• Source/WebCore/rendering/RenderLayerBacking.h (modified) (8 diffs)
• Source/WebCore/rendering/RenderLayerCompositor.cpp (modified) (21 diffs)
• Source/WebCore/rendering/RenderLayerCompositor.h (modified) (5 diffs)
• Source/WebKit/ChangeLog (modified) (1 diff)
• Source/WebKit/Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp (modified) (1 diff)
• Source/WebKit/Shared/WebCoreArgumentCoders.cpp (modified) (3 diffs)
• Source/WebKit/Shared/WebCoreArgumentCoders.h (modified) (3 diffs)
• Source/WebKit/Shared/WebRenderLayer.cpp (modified) (1 diff)
• Source/WebKit/UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm (modified) (2 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2019-06-23  Simon Fraser  <simon.fraser@apple.com>
+
+        [Async overflow scroll] Clipped composited layers inside overflow scroll jitter and get incorrectly clipped
+        https://bugs.webkit.org/show_bug.cgi?id=199133
+        rdar://problem/43614439
+
+        Reviewed by Antti Koivisto.
+        
+        New baselines for:
+        - clipping layers no longer have offsetFromRenderer(), which they didn't need.
+        - positioned nodes don't print scrollBehavior (they are always "Stationary")
+        - "Moves" positioned nodes are replaced with overflow scroll proxy nodes
+
+        * compositing/backing/backing-store-attachment-empty-keyframe-expected.txt:
+        * compositing/geometry/clip-expected.txt:
+        * compositing/geometry/clip-inside-expected.txt:
+        * compositing/geometry/limit-layer-bounds-clipping-ancestor-expected.txt:
+        * compositing/layer-creation/clipping-scope/nested-scroller-overlap-expected.txt:
+        * compositing/layer-creation/clipping-scope/nested-scroller-overlap.html:
+        * compositing/layer-creation/clipping-scope/overlap-constrained-inside-scroller-expected.txt:
+        * compositing/layer-creation/clipping-scope/scroller-with-negative-z-children-expected.txt:
+        * compositing/overflow/clip-descendents-expected.txt:
+        * compositing/overflow/scrolling-content-clip-to-viewport-expected.txt:
+        * compositing/rtl/rtl-scrolling-with-transformed-descendants-expected.txt:
+        * compositing/rtl/rtl-scrolling-with-transformed-descendants.html:
+        * compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-clipped-by-scroll-expected.txt: Added.
+        * compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-clipped-by-scroll.html: Added.
+        * compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-expected.txt: Added.
+        * compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-nested-expected.txt: Added.
+        * compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-nested.html: Added.
+        * compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow.html: Added.
+        * compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-hidden-expected.txt: Added.
+        * compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-hidden.html: Added.
+        * compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-visible-expected.txt: Added.
+        * compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-visible.html: Added.
+        * compositing/scrolling/async-overflow-scrolling/layer-in-overflow-expected.txt: Added.
+        * compositing/scrolling/async-overflow-scrolling/layer-in-overflow-gain-clipping-layer-expected.txt: Added.
+        * compositing/scrolling/async-overflow-scrolling/layer-in-overflow-gain-clipping-layer.html: Added.
+        * compositing/scrolling/async-overflow-scrolling/layer-in-overflow-in-clipped-expected.txt: Added.
+        * compositing/scrolling/async-overflow-scrolling/layer-in-overflow-in-clipped.html: Added.
+        * compositing/scrolling/async-overflow-scrolling/layer-in-overflow-lose-clipping-layer-expected.txt: Added.
+        * compositing/scrolling/async-overflow-scrolling/layer-in-overflow-lose-clipping-layer.html: Added.
+        * compositing/scrolling/async-overflow-scrolling/layer-in-overflow.html: Added.
+        * compositing/shared-backing/overflow-scroll/composited-absolute-in-absolute-in-relative-in-scroller-expected.txt:
+        * compositing/shared-backing/overflow-scroll/previous-sibling-prevents-inclusiveness-expected.txt:
+        * compositing/shared-backing/overflow-scroll/previous-sibling-prevents-inclusiveness.html:
+        * platform/ios-wk2/compositing/layer-creation/clipping-scope/nested-scroller-overlap-expected.txt:
+        * platform/ios-wk2/compositing/layer-creation/clipping-scope/overlap-constrained-inside-scroller-expected.txt:
+        * platform/ios-wk2/compositing/layer-creation/clipping-scope/scroller-with-negative-z-children-expected.txt:
+        * platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-clipped-by-scroll-expected.txt: Added.
+        * platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-expected.txt: Added.
+        * platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-nested-expected.txt: Added.
+        * platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-hidden-expected.txt: Added.
+        * platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-visible-expected.txt: Added.
+        * platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-expected.txt: Added.
+        * platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-gain-clipping-layer-expected.txt: Added.
+        * platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-in-clipped-expected.txt: Added.
+        * platform/ios-wk2/compositing/scrolling/async-overflow-scrolling/layer-in-overflow-lose-clipping-layer-expected.txt: Added.
+        * platform/ios-wk2/compositing/shared-backing/overflow-scroll/composited-absolute-in-absolute-in-relative-in-scroller-expected.txt:
+        * platform/ios-wk2/compositing/shared-backing/overflow-scroll/previous-sibling-prevents-inclusiveness-expected.txt:
+        * platform/ios-wk2/scrollingcoordinator/scrolling-tree/absolute-in-nested-sc-scrollers-expected.txt:
+        * platform/ios-wk2/scrollingcoordinator/scrolling-tree/absolute-inside-stacking-in-scroller-expected.txt:
+        * platform/ios-wk2/scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-expected.txt: Copied from LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/absolute-inside-stacking-in-scroller-expected.txt.
+        * platform/ios-wk2/scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-nested-expected.txt: Copied from LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-overflow-scroll-expected.txt.
+        * platform/ios-wk2/scrollingcoordinator/scrolling-tree/composited-in-absolute-in-stacking-context-overflow-expected.txt:
+        * platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-absolute-in-absolute-overflow-expected.txt:
+        * platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-absolute-in-relative-in-overflow-expected.txt:
+        * platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-absolute-in-sc-overflow-expected.txt:
+        * platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-overflow-scroll-expected.txt:
+        * platform/ios-wk2/scrollingcoordinator/scrolling-tree/positioned-nodes-complex-expected.txt:
+        * platform/ios-wk2/scrollingcoordinator/scrolling-tree/positioned-nodes-expected.txt:
+        * platform/ios-wk2/scrollingcoordinator/scrolling-tree/sticky-in-overflow-expected.txt:
+        * platform/ios/compositing/geometry/limit-layer-bounds-clipping-ancestor-expected.txt:
+        * platform/ios/compositing/rtl/rtl-scrolling-with-transformed-descendants-expected.txt:
+        * scrollingcoordinator/scrolling-tree/absolute-in-nested-sc-scrollers-expected.txt:
+        * scrollingcoordinator/scrolling-tree/absolute-inside-stacking-in-scroller-expected.txt:
+        * scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-expected.txt: Copied from LayoutTests/scrollingcoordinator/scrolling-tree/absolute-inside-stacking-in-scroller-expected.txt.
+        * scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-nested-expected.txt: Copied from LayoutTests/scrollingcoordinator/scrolling-tree/nested-overflow-scroll-expected.txt.
+        * scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-nested.html: Added.
+        * scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow.html: Added.
+        * scrollingcoordinator/scrolling-tree/composited-in-absolute-in-stacking-context-overflow-expected.txt:
+        * scrollingcoordinator/scrolling-tree/nested-absolute-in-absolute-overflow-expected.txt:
+        * scrollingcoordinator/scrolling-tree/nested-absolute-in-relative-in-overflow-expected.txt:
+        * scrollingcoordinator/scrolling-tree/nested-absolute-in-sc-overflow-expected.txt:
+        * scrollingcoordinator/scrolling-tree/nested-overflow-scroll-expected.txt:
+        * scrollingcoordinator/scrolling-tree/positioned-nodes-complex-expected.txt:
+        * scrollingcoordinator/scrolling-tree/positioned-nodes-expected.txt:
+        * scrollingcoordinator/scrolling-tree/sticky-in-overflow-expected.txt:
+
 2019-06-23  Antoine Quint  <graouts@apple.com>
 

trunk/LayoutTests/compositing/backing/backing-store-attachment-empty-keyframe-expected.txt

@@ -10 +10 @@
       (children 1
         (GraphicsLayer
-          (offsetFromRenderer width=-501 height=0)
           (position 9.00 101.00)
           (bounds 501.00 150.00)

trunk/LayoutTests/compositing/geometry/clip-expected.txt

@@ -17 +17 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=5 height=5)
           (position 215.00 15.00)
           (bounds 110.00 110.00)

trunk/LayoutTests/compositing/geometry/clip-inside-expected.txt

@@ -18 +18 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=15 height=25)
           (position 225.00 35.00)
           (bounds 90.00 80.00)

trunk/LayoutTests/compositing/geometry/limit-layer-bounds-clipping-ancestor-expected.txt

@@ -23 +23 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=0 height=100)
           (position 28.00 250.00)
           (bounds 185.00 200.00)

trunk/LayoutTests/compositing/layer-creation/clipping-scope/nested-scroller-overlap-expected.txt

@@ -2 +2 @@
   (anchor 0.00 0.00)
   (bounds 800.00 600.00)
+  (clips 1)
   (children 1
     (GraphicsLayer
@@ -16 +17 @@
               (position 1.00 1.00)
               (bounds 385.00 350.00)
+              (clips 1)
               (children 1
                 (GraphicsLayer
@@ -32 +34 @@
                           (position 1.00 1.00)
                           (bounds 285.00 200.00)
+                          (clips 1)
                           (children 1
                             (GraphicsLayer
@@ -50 +53 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-10 height=-10)
           (position 24.00 106.00)
           (bounds 385.00 350.00)
+          (clips 1)
           (children 1
             (GraphicsLayer
@@ -66 +69 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-10 height=-10)
-          (position 45.00 217.00)
-          (bounds 285.00 200.00)
+          (position 24.00 106.00)
+          (bounds 385.00 350.00)
+          (clips 1)
           (children 1
             (GraphicsLayer
-              (position 10.00 10.00)
-              (bounds 100.00 80.00)
-              (contentsOpaque 1)
+              (position 21.00 111.00)
+              (bounds 285.00 200.00)
+              (clips 1)
+              (children 1
+                (GraphicsLayer
+                  (position 10.00 10.00)
+                  (bounds 100.00 80.00)
+                  (contentsOpaque 1)
+                )
+              )
             )
           )
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-10 height=-100)
-          (position 45.00 217.00)
-          (bounds 285.00 200.00)
+          (position 24.00 106.00)
+          (bounds 385.00 350.00)
+          (clips 1)
           (children 1
             (GraphicsLayer
-              (position 10.00 100.00)
-              (bounds 100.00 80.00)
-              (contentsOpaque 1)
+              (position 21.00 111.00)
+              (bounds 285.00 200.00)
+              (clips 1)
+              (children 1
+                (GraphicsLayer
+                  (position 10.00 100.00)
+                  (bounds 100.00 80.00)
+                  (contentsOpaque 1)
+                )
+              )
             )
           )
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-10 height=-190)
-          (position 45.00 217.00)
-          (bounds 285.00 200.00)
+          (position 24.00 106.00)
+          (bounds 385.00 350.00)
+          (clips 1)
           (children 1
             (GraphicsLayer
-              (position 10.00 190.00)
-              (bounds 100.00 80.00)
-              (contentsOpaque 1)
+              (position 21.00 111.00)
+              (bounds 285.00 200.00)
+              (clips 1)
+              (children 1
+                (GraphicsLayer
+                  (position 10.00 190.00)
+                  (bounds 100.00 80.00)
+                  (contentsOpaque 1)
+                )
+              )
             )
           )

trunk/LayoutTests/compositing/layer-creation/clipping-scope/nested-scroller-overlap.html

@@ -50 +50 @@
                 window.addEventListener('load', () => {
                         if (window.testRunner)
-                                document.getElementById('layers').innerText = window.internals.layerTreeAsText(document);
+                                document.getElementById('layers').innerText = window.internals.layerTreeAsText(document, internals.LAYER_TREE_INCLUDES_CLIPPING);
                 }, false);
         </script>

trunk/LayoutTests/compositing/layer-creation/clipping-scope/overlap-constrained-inside-scroller-expected.txt

@@ -27 +27 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-10 height=-10)
           (position 9.00 9.00)
           (bounds 285.00 300.00)
@@ -39 +38 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-40 height=-20)
           (position 9.00 9.00)
           (bounds 285.00 300.00)
@@ -51 +49 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-40 height=-140)
           (position 9.00 9.00)
           (bounds 285.00 300.00)
@@ -63 +60 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-40 height=-260)
           (position 9.00 9.00)
           (bounds 285.00 300.00)

trunk/LayoutTests/compositing/layer-creation/clipping-scope/scroller-with-negative-z-children-expected.txt

@@ -27 +27 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-10 height=-10)
           (position 9.00 9.00)
           (bounds 285.00 300.00)
@@ -39 +38 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-40 height=-20)
           (position 9.00 9.00)
           (bounds 285.00 300.00)
@@ -51 +49 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-40 height=-260)
           (position 9.00 9.00)
           (bounds 285.00 300.00)

trunk/LayoutTests/compositing/overflow/clip-descendents-expected.txt

@@ -8 +8 @@
       (children 4
         (GraphicsLayer
-          (offsetFromRenderer width=-2 height=-12)
           (position 48.00 38.00)
           (bounds 60.00 70.00)
@@ -21 +20 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-2 height=-12)
           (position 240.00 38.00)
           (bounds 60.00 70.00)

trunk/LayoutTests/compositing/overflow/scrolling-content-clip-to-viewport-expected.txt

@@ -22 +22 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-10 height=-10)
           (bounds 305.00 325.00)
           (children 1

trunk/LayoutTests/compositing/rtl/rtl-scrolling-with-transformed-descendants-expected.txt

@@ -3 +3 @@
   (anchor 0.00 0.00)
   (bounds 800.00 600.00)
+  (clips 1)
   (children 1
     (GraphicsLayer
@@ -18 +19 @@
               (bounds origin 366.00 0.00)
               (bounds 400.00 204.00)
+              (clips 1)
               (children 1
                 (GraphicsLayer
@@ -31 +33 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-96 height=0)
           (position 10.00 10.00)
+          (bounds origin 366.00 0.00)
           (bounds 400.00 204.00)
+          (clips 1)
           (children 1
             (GraphicsLayer
-              (position 96.00 0.00)
+              (position 462.00 0.00)
               (anchor 0.00 0.00)
               (bounds 150.00 200.00)
@@ -44 +47 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=58 height=0)
           (position 10.00 10.00)
+          (bounds origin 366.00 0.00)
           (bounds 400.00 204.00)
+          (clips 1)
           (children 1
             (GraphicsLayer
-              (position -58.00 0.00)
+              (position 308.00 0.00)
               (bounds 150.00 200.00)
               (contentsOpaque 1)

trunk/LayoutTests/compositing/rtl/rtl-scrolling-with-transformed-descendants.html

@@ -31 +31 @@
         function dumpLayers()
         {
-            document.getElementById('layertree').textContent = window.internals.layerTreeAsText(document);
+            document.getElementById('layertree').textContent = window.internals.layerTreeAsText(document, internals.LAYER_TREE_INCLUDES_CLIPPING);
         }
         window.addEventListener('load', dumpLayers, false);

trunk/LayoutTests/compositing/shared-backing/overflow-scroll/composited-absolute-in-absolute-in-relative-in-scroller-expected.txt

@@ -28 +28 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-34 height=-134)
           (position 10.00 10.00)
           (bounds 385.00 400.00)

trunk/LayoutTests/compositing/shared-backing/overflow-scroll/previous-sibling-prevents-inclusiveness-expected.txt

@@ -2 +2 @@
   (anchor 0.00 0.00)
   (bounds 800.00 600.00)
+  (clips 1)
   (children 1
     (GraphicsLayer
@@ -15 +16 @@
               (position 2.00 2.00)
               (bounds 320.00 320.00)
+              (clips 1)
               (children 1
                 (GraphicsLayer
@@ -25 +27 @@
                       (position 2.00 2.00)
                       (bounds 281.00 296.00)
+                      (clips 1)
                       (children 1
                         (GraphicsLayer
@@ -45 +48 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-20 height=-20)
-          (position 42.00 34.00)
-          (bounds 281.00 296.00)
+          (position 30.00 22.00)
+          (bounds 320.00 320.00)
+          (clips 1)
           (children 1
             (GraphicsLayer
-              (position 20.00 20.00)
-              (bounds 241.00 24.00)
-              (drawsContent 1)
+              (position 12.00 12.00)
+              (bounds 281.00 296.00)
+              (clips 1)
+              (children 1
+                (GraphicsLayer
+                  (position 20.00 20.00)
+                  (bounds 241.00 24.00)
+                  (drawsContent 1)
+                )
+              )
             )
           )

trunk/LayoutTests/compositing/shared-backing/overflow-scroll/previous-sibling-prevents-inclusiveness.html

@@ -48 +48 @@
         window.addEventListener('load', () => {
             if (window.internals)
-                document.getElementById('layers').textContent = internals.layerTreeAsText(document);
+                document.getElementById('layers').textContent = internals.layerTreeAsText(document, internals.LAYER_TREE_INCLUDES_CLIPPING);
         }, false);
     </script>

trunk/LayoutTests/legacy-animation-engine/compositing/backing/backing-store-attachment-empty-keyframe-expected.txt

@@ -10 +10 @@
       (children 1
         (GraphicsLayer
-          (offsetFromRenderer width=-501 height=0)
           (position 9.00 101.00)
           (bounds 501.00 150.00)

trunk/LayoutTests/platform/ios-wk2/compositing/layer-creation/clipping-scope/nested-scroller-overlap-expected.txt

@@ -2 +2 @@
   (anchor 0.00 0.00)
   (bounds 800.00 600.00)
+  (clips 1)
   (children 1
     (GraphicsLayer
@@ -16 +17 @@
               (position 1.00 1.00)
               (bounds 400.00 350.00)
+              (clips 1)
               (children 1
                 (GraphicsLayer
@@ -32 +34 @@
                           (position 1.00 1.00)
                           (bounds 300.00 200.00)
+                          (clips 1)
                           (children 1
                             (GraphicsLayer
@@ -50 +53 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-10 height=-10)
           (position 24.00 106.00)
           (bounds 400.00 350.00)
+          (clips 1)
           (children 1
             (GraphicsLayer
@@ -66 +69 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-10 height=-10)
-          (position 45.00 217.00)
-          (bounds 300.00 200.00)
+          (position 24.00 106.00)
+          (bounds 400.00 350.00)
+          (clips 1)
           (children 1
             (GraphicsLayer
-              (position 10.00 10.00)
-              (bounds 100.00 80.00)
-              (contentsOpaque 1)
+              (position 21.00 111.00)
+              (bounds 300.00 200.00)
+              (clips 1)
+              (children 1
+                (GraphicsLayer
+                  (position 10.00 10.00)
+                  (bounds 100.00 80.00)
+                  (contentsOpaque 1)
+                )
+              )
             )
           )
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-10 height=-100)
-          (position 45.00 217.00)
-          (bounds 300.00 200.00)
+          (position 24.00 106.00)
+          (bounds 400.00 350.00)
+          (clips 1)
           (children 1
             (GraphicsLayer
-              (position 10.00 100.00)
-              (bounds 100.00 80.00)
-              (contentsOpaque 1)
+              (position 21.00 111.00)
+              (bounds 300.00 200.00)
+              (clips 1)
+              (children 1
+                (GraphicsLayer
+                  (position 10.00 100.00)
+                  (bounds 100.00 80.00)
+                  (contentsOpaque 1)
+                )
+              )
             )
           )
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-10 height=-190)
-          (position 45.00 217.00)
-          (bounds 300.00 200.00)
+          (position 24.00 106.00)
+          (bounds 400.00 350.00)
+          (clips 1)
           (children 1
             (GraphicsLayer
-              (position 10.00 190.00)
-              (bounds 100.00 80.00)
-              (contentsOpaque 1)
+              (position 21.00 111.00)
+              (bounds 300.00 200.00)
+              (clips 1)
+              (children 1
+                (GraphicsLayer
+                  (position 10.00 190.00)
+                  (bounds 100.00 80.00)
+                  (contentsOpaque 1)
+                )
+              )
             )
           )

trunk/LayoutTests/platform/ios-wk2/compositing/layer-creation/clipping-scope/overlap-constrained-inside-scroller-expected.txt

@@ -27 +27 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-10 height=-10)
           (position 9.00 9.00)
           (bounds 300.00 300.00)
@@ -39 +38 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-40 height=-20)
           (position 9.00 9.00)
           (bounds 300.00 300.00)
@@ -51 +49 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-40 height=-140)
           (position 9.00 9.00)
           (bounds 300.00 300.00)
@@ -63 +60 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-40 height=-260)
           (position 9.00 9.00)
           (bounds 300.00 300.00)

trunk/LayoutTests/platform/ios-wk2/compositing/layer-creation/clipping-scope/scroller-with-negative-z-children-expected.txt

@@ -27 +27 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-10 height=-10)
           (position 9.00 9.00)
           (bounds 300.00 300.00)
@@ -39 +38 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-40 height=-20)
           (position 9.00 9.00)
           (bounds 300.00 300.00)
@@ -51 +49 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-40 height=-260)
           (position 9.00 9.00)
           (bounds 300.00 300.00)

trunk/LayoutTests/platform/ios-wk2/compositing/shared-backing/overflow-scroll/composited-absolute-in-absolute-in-relative-in-scroller-expected.txt

@@ -28 +28 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-34 height=-134)
           (position 10.00 10.00)
           (bounds 400.00 400.00)

trunk/LayoutTests/platform/ios-wk2/compositing/shared-backing/overflow-scroll/previous-sibling-prevents-inclusiveness-expected.txt

@@ -2 +2 @@
   (anchor 0.00 0.00)
   (bounds 800.00 600.00)
+  (clips 1)
   (children 1
     (GraphicsLayer
@@ -15 +16 @@
               (position 2.00 2.00)
               (bounds 320.00 320.00)
+              (clips 1)
               (children 1
                 (GraphicsLayer
@@ -25 +27 @@
                       (position 2.00 2.00)
                       (bounds 296.00 296.00)
+                      (clips 1)
                       (children 1
                         (GraphicsLayer
@@ -45 +48 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=-20 height=-20)
-          (position 42.00 34.00)
-          (bounds 296.00 296.00)
+          (position 30.00 22.00)
+          (bounds 320.00 320.00)
+          (clips 1)
           (children 1
             (GraphicsLayer
-              (position 20.00 20.00)
-              (bounds 256.00 24.00)
-              (drawsContent 1)
+              (position 12.00 12.00)
+              (bounds 296.00 296.00)
+              (clips 1)
+              (children 1
+                (GraphicsLayer
+                  (position 20.00 20.00)
+                  (bounds 256.00 24.00)
+                  (drawsContent 1)
+                )
+              )
             )
           )

trunk/LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/absolute-in-nested-sc-scrollers-expected.txt

@@ -38 +38 @@
             (Positioned node
               (layout constraints 
-                (layer-position-at-last-layout (-2,6))
-                (positioning-behavior stationary))
+                (layer-position-at-last-layout (-2,6)))
               (related overflow nodes 2)
             )

trunk/LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/absolute-inside-stacking-in-scroller-expected.txt

@@ -25 +25 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,10))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
       (children 1
         (Positioned node
           (layout constraints 
-            (layer-position-at-last-layout (71,22))
-            (positioning-behavior stationary))
+            (layer-position-at-last-layout (71,22)))
           (related overflow nodes 1)
         )

trunk/LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-expected.txt

@@ -15 +15 @@
   (children 2
     (Overflow scrolling node
-      (scrollable area size 220 170)
-      (contents size 220 1020)
-      (parent relative scrollable rect at (19,11) size 220x170)
+      (scroll position 0 50)
+      (scrollable area size 316 316)
+      (contents size 316 540)
+      (requested scroll position 0 50)
+      (requested scroll position represents programmatic scroll 1)
+      (parent relative scrollable rect at (41,33) size 316x316)
       (scrollable area parameters 
         (horizontal scroll elasticity 1)
@@ -25 +28 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,10))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
-      (children 1
-        (Positioned node
-          (layout constraints 
-            (layer-position-at-last-layout (71,22))
-            (positioning-behavior stationary))
-          (related overflow nodes 1)
-        )
-      )
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,50))
     )
   )

trunk/LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-nested-expected.txt

@@ -13 +13 @@
   (max layout viewport origin (0,0))
   (behavior for fixed 0)
-  (children 2
+  (children 3
     (Overflow scrolling node
-      (scrollable area size 300 300)
-      (contents size 300 464)
-      (parent relative scrollable rect at (30,22) size 300x300)
+      (scroll position 0 50)
+      (scrollable area size 316 316)
+      (contents size 316 640)
+      (requested scroll position 0 50)
+      (requested scroll position represents programmatic scroll 1)
+      (parent relative scrollable rect at (41,33) size 316x316)
       (scrollable area parameters 
         (horizontal scroll elasticity 1)
@@ -24 +27 @@
         (vertical scrollbar mode 0)
         (has enabled vertical scrollbar 1))
-    )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,130))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
       (children 1
         (Overflow scrolling node
+          (scroll position 0 150)
           (scrollable area size 200 200)
-          (contents size 200 520)
-          (parent relative scrollable rect at (2,2) size 200x200)
+          (contents size 200 554)
+          (requested scroll position 0 150)
+          (requested scroll position represents programmatic scroll 1)
+          (parent relative scrollable rect at (56,206) size 200x200)
           (scrollable area parameters 
             (horizontal scroll elasticity 1)
@@ -44 +44 @@
       )
     )
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,50))
+    )
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,150))
+    )
   )
 )
 
+

trunk/LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/composited-in-absolute-in-stacking-context-overflow-expected.txt

@@ -27 +27 @@
         (Positioned node
           (layout constraints 
-            (layer-position-at-last-layout (20,28))
-            (positioning-behavior stationary))
+            (layer-position-at-last-layout (20,28)))
           (related overflow nodes 1)
         )
         (Positioned node
           (layout constraints 
-            (layer-position-at-last-layout (40,48))
-            (positioning-behavior stationary))
+            (layer-position-at-last-layout (40,48)))
           (related overflow nodes 1)
         )

trunk/LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-absolute-in-absolute-overflow-expected.txt

@@ -28 +28 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,10))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (50,50))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (62,82))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (77,77))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
   )

trunk/LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-absolute-in-relative-in-overflow-expected.txt

@@ -27 +27 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,10))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (0,30))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (13,43))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (53,83))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (65,115))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (80,110))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
   )

trunk/LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-absolute-in-sc-overflow-expected.txt

@@ -29 +29 @@
         (Positioned node
           (layout constraints 
-            (layer-position-at-last-layout (20,28))
-            (positioning-behavior stationary))
+            (layer-position-at-last-layout (20,28)))
           (related overflow nodes 1)
         )
         (Positioned node
           (layout constraints 
-            (layer-position-at-last-layout (32,60))
-            (positioning-behavior stationary))
+            (layer-position-at-last-layout (32,60)))
           (related overflow nodes 1)
         )
         (Positioned node
           (layout constraints 
-            (layer-position-at-last-layout (47,55))
-            (positioning-behavior stationary))
+            (layer-position-at-last-layout (47,55)))
           (related overflow nodes 1)
         )

trunk/LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/nested-overflow-scroll-expected.txt

@@ -25 +25 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,130))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
       (children 1
         (Overflow scrolling node
           (scrollable area size 200 200)
           (contents size 200 520)
-          (parent relative scrollable rect at (2,2) size 200x200)
+          (parent relative scrollable rect at (0,0) size 200x200)
           (scrollable area parameters 
             (horizontal scroll elasticity 1)

trunk/LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/positioned-nodes-complex-expected.txt

@@ -39 +39 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,40))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,60))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,80))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
     (Overflow scrolling node
@@ -68 +59 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,40))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,60))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
     (Overflow scrolling node
@@ -91 +76 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,40))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
     (Overflow scrolling node
@@ -108 +90 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,40))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
     (Overflow scrolling node
@@ -125 +104 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,40))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,60))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,90))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (110,110))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
     (Overflow scrolling node
@@ -160 +127 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,40))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,60))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
       (children 1
         (Positioned node
           (layout constraints 
-            (layer-position-at-last-layout (79,50))
-            (positioning-behavior stationary))
+            (layer-position-at-last-layout (79,50)))
           (related overflow nodes 1)
         )

trunk/LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/positioned-nodes-expected.txt

@@ -55 +55 @@
       )
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,30))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
     (Overflow scrolling node
@@ -85 +82 @@
         (Positioned node
           (layout constraints 
-            (layer-position-at-last-layout (81,30))
-            (positioning-behavior stationary))
+            (layer-position-at-last-layout (81,30)))
           (related overflow nodes 1)
         )

trunk/LayoutTests/platform/ios-wk2/scrollingcoordinator/scrolling-tree/sticky-in-overflow-expected.txt

@@ -26 +26 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (50,50))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
       (children 1
         (Sticky node

trunk/LayoutTests/platform/ios/compositing/geometry/limit-layer-bounds-clipping-ancestor-expected.txt

@@ -23 +23 @@
         )
         (GraphicsLayer
-          (offsetFromRenderer width=0 height=100)
           (position 28.00 250.00)
           (bounds 185.00 200.00)

trunk/LayoutTests/platform/ios/compositing/rtl/rtl-scrolling-with-transformed-descendants-expected.txt

@@ -3 +3 @@
   (anchor 0.00 0.00)
   (bounds 800.00 600.00)
+  (clips 1)
   (children 1
     (GraphicsLayer
@@ -18 +19 @@
               (bounds origin 366.00 0.00)
               (bounds 400.00 205.00)
+              (clips 1)
               (children 1
                 (GraphicsLayer

trunk/LayoutTests/platform/ios/media/video-play-glyph-composited-outside-overflow-scrolling-touch-container-expected.txt

@@ -21 +21 @@
                   (children 1
                     (GraphicsLayer
-                      (offsetFromRenderer width=-114 height=-300)
                       (bounds 300.00 672.00)
                       (children 1

trunk/LayoutTests/platform/mac-wk1/compositing/overflow/scrolling-content-clip-to-viewport-expected.txt

@@ -8 +8 @@
       (children 1
         (GraphicsLayer
-          (offsetFromRenderer width=-10 height=-10)
           (bounds 305.00 325.00)
           (children 1

trunk/LayoutTests/platform/mac-wk1/compositing/rtl/rtl-scrolling-with-transformed-descendants-expected.txt

@@ -3 +3 @@
   (anchor 0.00 0.00)
   (bounds 800.00 600.00)
+  (clips 1)
   (children 1
     (GraphicsLayer
@@ -9 +10 @@
       (children 1
         (GraphicsLayer
-          (offsetFromRenderer width=-96 height=0)
           (position 10.00 10.00)
           (bounds 400.00 204.00)
+          (clips 1)
           (children 1
             (GraphicsLayer

trunk/LayoutTests/scrollingcoordinator/scrolling-tree/absolute-in-nested-sc-scrollers-expected.txt

@@ -38 +38 @@
             (Positioned node
               (layout constraints 
-                (layer-position-at-last-layout (-2,6))
-                (positioning-behavior stationary))
+                (layer-position-at-last-layout (-2,6)))
               (related overflow nodes 2)
             )

trunk/LayoutTests/scrollingcoordinator/scrolling-tree/absolute-inside-stacking-in-scroller-expected.txt

@@ -25 +25 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,10))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
       (children 1
         (Positioned node
           (layout constraints 
-            (layer-position-at-last-layout (71,22))
-            (positioning-behavior stationary))
+            (layer-position-at-last-layout (71,22)))
           (related overflow nodes 1)
         )

trunk/LayoutTests/scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-expected.txt

@@ -15 +15 @@
   (children 2
     (Overflow scrolling node
-      (scrollable area size 205 155)
-      (contents size 205 1020)
-      (parent relative scrollable rect at (19,11) size 205x155)
+      (scroll position 0 50)
+      (scrollable area size 301 316)
+      (contents size 301 540)
+      (requested scroll position 0 50)
+      (requested scroll position represents programmatic scroll 1)
+      (parent relative scrollable rect at (41,33) size 301x316)
       (scrollable area parameters 
-        (horizontal scroll elasticity 0)
+        (horizontal scroll elasticity 1)
         (vertical scroll elasticity 0)
         (horizontal scrollbar mode 0)
@@ -25 +28 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,10))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
-      (children 1
-        (Positioned node
-          (layout constraints 
-            (layer-position-at-last-layout (71,22))
-            (positioning-behavior stationary))
-          (related overflow nodes 1)
-        )
-      )
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,50))
     )
   )

trunk/LayoutTests/scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-nested-expected.txt

@@ -13 +13 @@
   (max layout viewport origin (0,0))
   (behavior for fixed 0)
-  (children 2
+  (children 3
     (Overflow scrolling node
-      (scrollable area size 285 285)
-      (contents size 285 464)
-      (parent relative scrollable rect at (30,22) size 285x285)
+      (scroll position 0 50)
+      (scrollable area size 301 316)
+      (contents size 301 640)
+      (requested scroll position 0 50)
+      (requested scroll position represents programmatic scroll 1)
+      (parent relative scrollable rect at (41,33) size 301x316)
       (scrollable area parameters 
-        (horizontal scroll elasticity 0)
+        (horizontal scroll elasticity 1)
         (vertical scroll elasticity 0)
         (horizontal scrollbar mode 0)
         (vertical scrollbar mode 0)
         (has enabled vertical scrollbar 1))
-    )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,130))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
       (children 1
         (Overflow scrolling node
-          (scrollable area size 185 185)
-          (contents size 185 520)
-          (parent relative scrollable rect at (2,2) size 185x185)
+          (scroll position 0 150)
+          (scrollable area size 185 200)
+          (contents size 185 554)
+          (requested scroll position 0 150)
+          (requested scroll position represents programmatic scroll 1)
+          (parent relative scrollable rect at (56,206) size 185x200)
           (scrollable area parameters 
-            (horizontal scroll elasticity 0)
+            (horizontal scroll elasticity 1)
             (vertical scroll elasticity 0)
             (horizontal scrollbar mode 0)
@@ -44 +44 @@
       )
     )
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,50))
+    )
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,150))
+    )
   )
 )
 
+

trunk/LayoutTests/scrollingcoordinator/scrolling-tree/composited-in-absolute-in-stacking-context-overflow-expected.txt

@@ -27 +27 @@
         (Positioned node
           (layout constraints 
-            (layer-position-at-last-layout (20,28))
-            (positioning-behavior stationary))
+            (layer-position-at-last-layout (20,28)))
           (related overflow nodes 1)
         )
         (Positioned node
           (layout constraints 
-            (layer-position-at-last-layout (40,48))
-            (positioning-behavior stationary))
+            (layer-position-at-last-layout (40,48)))
           (related overflow nodes 1)
         )

trunk/LayoutTests/scrollingcoordinator/scrolling-tree/nested-absolute-in-absolute-overflow-expected.txt

@@ -28 +28 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,10))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (50,50))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (62,80))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (77,77))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
   )

trunk/LayoutTests/scrollingcoordinator/scrolling-tree/nested-absolute-in-relative-in-overflow-expected.txt

@@ -27 +27 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,10))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (0,30))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (13,43))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (53,83))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (65,113))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (80,110))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
   )

trunk/LayoutTests/scrollingcoordinator/scrolling-tree/nested-absolute-in-sc-overflow-expected.txt

@@ -29 +29 @@
         (Positioned node
           (layout constraints 
-            (layer-position-at-last-layout (20,28))
-            (positioning-behavior stationary))
+            (layer-position-at-last-layout (20,28)))
           (related overflow nodes 1)
         )
         (Positioned node
           (layout constraints 
-            (layer-position-at-last-layout (32,58))
-            (positioning-behavior stationary))
+            (layer-position-at-last-layout (32,58)))
           (related overflow nodes 1)
         )
         (Positioned node
           (layout constraints 
-            (layer-position-at-last-layout (47,55))
-            (positioning-behavior stationary))
+            (layer-position-at-last-layout (47,55)))
           (related overflow nodes 1)
         )

trunk/LayoutTests/scrollingcoordinator/scrolling-tree/nested-overflow-scroll-expected.txt

@@ -25 +25 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,130))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
       (children 1
         (Overflow scrolling node
           (scrollable area size 185 185)
           (contents size 185 520)
-          (parent relative scrollable rect at (2,2) size 185x185)
+          (parent relative scrollable rect at (0,0) size 185x185)
           (scrollable area parameters 
             (horizontal scroll elasticity 0)

trunk/LayoutTests/scrollingcoordinator/scrolling-tree/positioned-nodes-complex-expected.txt

@@ -41 +41 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,38))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,58))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,76))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
     (Overflow scrolling node
@@ -71 +62 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,38))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,58))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
     (Overflow scrolling node
@@ -94 +79 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,38))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
     (Overflow scrolling node
@@ -111 +93 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,38))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
     (Overflow scrolling node
@@ -129 +108 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,38))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,58))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,86))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (110,106))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
     (Overflow scrolling node
@@ -164 +131 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (20,38))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,58))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
       (children 1
         (Positioned node
           (layout constraints 
-            (layer-position-at-last-layout (79,48))
-            (positioning-behavior stationary))
+            (layer-position-at-last-layout (79,48)))
           (related overflow nodes 1)
         )

trunk/LayoutTests/scrollingcoordinator/scrolling-tree/positioned-nodes-expected.txt

@@ -56 +56 @@
       )
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (10,28))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
     )
     (Overflow scrolling node
@@ -86 +83 @@
         (Positioned node
           (layout constraints 
-            (layer-position-at-last-layout (81,28))
-            (positioning-behavior stationary))
+            (layer-position-at-last-layout (81,28)))
           (related overflow nodes 1)
         )

trunk/LayoutTests/scrollingcoordinator/scrolling-tree/sticky-in-overflow-expected.txt

@@ -26 +26 @@
         (has enabled vertical scrollbar 1))
     )
-    (Positioned node
-      (layout constraints 
-        (layer-position-at-last-layout (50,50))
-        (positioning-behavior moves))
-      (related overflow nodes 1)
+    (Overflow scroll proxy node
+      (related overflow scrolling node scroll position (0,0))
       (children 1
         (Sticky node

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2019-06-23  Simon Fraser  <simon.fraser@apple.com>
+
+        [Async overflow scroll] Clipped composited layers inside overflow scroll jitter and get incorrectly clipped
+        https://bugs.webkit.org/show_bug.cgi?id=199133
+        rdar://problem/43614439
+
+        Reviewed by Antti Koivisto.
+
+        Currently a composited layer with an overflow:scroll ancestor (which is not a paint-order
+        ancestor) gets a single "ancestor clip layer" that represents the intersection of all the
+        clips provided by its containing-block ancestors with non-visible overflow (both scrolling
+        and non-scrolling ones).
+
+        To correctly update clips with async overflow scroll, this single clip layer needs to be
+        broken up into multiple clipping ancestors. We need a separate layer, and scrolling tree
+        node for each ancestor that is an overflow scroll, and layers that represent non-moving
+        clips (i.e. overflow:hidden and 'clip') between them. This patch adds
+        LayerAncestorClippingStack to represent this stack of clipping layers. For example with the
+        following content:
+        
+        <div style="overflow:hidden"> <--- A
+            <div style="overflow:scroll"> <--- B
+                <div style="overflow:hidden"> <--- C
+                    <div style="overflow:hidden"> <--- D
+                        <div style="overflow:scroll">  <--- E
+                            <div style="overflow:hidden"> <--- F
+                                <div style="overflow:hidden"> <--- G
+                                    <div></div> <--- H
+                                <div>
+                            <div>
+                        <div>
+                    <div>
+                <div>
+            <div>
+        <div>
+        
+        the composited RenderLayer for H owns a LayerAncestorClippingStack with the following contents:
+            [clip - A]
+            [scroller - B]
+            [clip - intersection of C and D]
+            [scroller - E]
+            [clip - intersection of F and G]
+
+        Each stack entry has a 'masksToBounds' GraphicsLayer for clipping. Entries representing
+        overflow:scroll clips have a ScrollingNodeID for their OverflowScrollProxy scrolling tree
+        node (which references the actual OverflowScrollingNode). The non-scroller clips in this
+        stack are computed unconstrained by the enclosing overflow:scroll.
+
+        When the OverflowScrollingNode is scrolled, the boundsOrigin of related OverflowScrollProxy nodes
+        is adjusted to move the descendant layers (other clipping layers, or composited layers).
+
+        OverflowScrollProxy nodes thus take over the role that "Moves" ScrollingTreePositionedNode had.
+        With this patch, ScrollingTreePositionedNode are purely for absolute position inside non-containing-block
+        stacking context overflow scroll. LayoutConstraints is renamed to AbsolutePositionConstraints accordingly.
+
+        Tests: compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-clipped-by-scroll.html
+               compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow-nested.html
+               compositing/scrolling/async-overflow-scrolling/clipped-layer-in-overflow.html
+               compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-hidden.html
+               compositing/scrolling/async-overflow-scrolling/layer-in-overflow-clip-to-visible.html
+               compositing/scrolling/async-overflow-scrolling/layer-in-overflow-gain-clipping-layer.html
+               compositing/scrolling/async-overflow-scrolling/layer-in-overflow-in-clipped.html
+               compositing/scrolling/async-overflow-scrolling/layer-in-overflow-lose-clipping-layer.html
+               compositing/scrolling/async-overflow-scrolling/layer-in-overflow.html
+               scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow-nested.html
+               scrollingcoordinator/scrolling-tree/clipped-layer-in-overflow.html
+
+        * Sources.txt:
+        * WebCore.xcodeproj/project.pbxproj:
+        * page/scrolling/AsyncScrollingCoordinator.cpp:
+        (WebCore::AsyncScrollingCoordinator::setPositionedNodeConstraints):
+        (WebCore::AsyncScrollingCoordinator::setPositionedNodeGeometry): Deleted.
+        * page/scrolling/AsyncScrollingCoordinator.h:
+        * page/scrolling/ScrollingConstraints.cpp:
+        (WebCore::operator<<):
+        * page/scrolling/ScrollingConstraints.h:
+        (WebCore::AbsolutePositionConstraints::operator== const):
+        (WebCore::AbsolutePositionConstraints::operator!= const):
+        (WebCore::LayoutConstraints::operator== const): Deleted.
+        (WebCore::LayoutConstraints::operator!= const): Deleted.
+        (WebCore::LayoutConstraints::alignmentOffset const): Deleted.
+        (WebCore::LayoutConstraints::setAlignmentOffset): Deleted.
+        (WebCore::LayoutConstraints::layerPositionAtLastLayout const): Deleted.
+        (WebCore::LayoutConstraints::setLayerPositionAtLastLayout): Deleted.
+        (WebCore::LayoutConstraints::scrollPositioningBehavior const): Deleted.
+        (WebCore::LayoutConstraints::setScrollPositioningBehavior): Deleted.
+        * page/scrolling/ScrollingCoordinator.h:
+        (WebCore::ScrollingCoordinator::setPositionedNodeConstraints):
+        (WebCore::ScrollingCoordinator::setPositionedNodeGeometry): Deleted.
+        * page/scrolling/ScrollingStatePositionedNode.cpp:
+        (WebCore::ScrollingStatePositionedNode::updateConstraints):
+        * page/scrolling/ScrollingStatePositionedNode.h:
+        * page/scrolling/ScrollingTree.cpp:
+        (WebCore::ScrollingTree::commitTreeState):
+        * page/scrolling/ScrollingTree.h:
+        (WebCore::ScrollingTree::nodesWithRelatedOverflow):
+        (WebCore::ScrollingTree::positionedNodesWithRelatedOverflow): Deleted.
+        * page/scrolling/cocoa/ScrollingTreeFixedNode.mm:
+        (WebCore::ScrollingTreeFixedNode::applyLayerPositions):
+        * page/scrolling/cocoa/ScrollingTreeOverflowScrollProxyNode.mm:
+        (WebCore::ScrollingTreeOverflowScrollProxyNode::commitStateBeforeChildren):
+        * page/scrolling/cocoa/ScrollingTreePositionedNode.h:
+        (WebCore::ScrollingTreePositionedNode::scrollPositioningBehavior const): Deleted.
+        * page/scrolling/cocoa/ScrollingTreePositionedNode.mm:
+        (WebCore::ScrollingTreePositionedNode::commitStateBeforeChildren):
+        (WebCore::ScrollingTreePositionedNode::scrollDeltaSinceLastCommit const):
+        * page/scrolling/cocoa/ScrollingTreeStickyNode.mm:
+        (WebCore::ScrollingTreeStickyNode::computeLayerPosition const):
+        * rendering/LayerAncestorClippingStack.cpp: Added.
+        (WebCore::LayerAncestorClippingStack::LayerAncestorClippingStack):
+        (WebCore::LayerAncestorClippingStack::equalToClipData const):
+        (WebCore::LayerAncestorClippingStack::hasAnyScrollingLayers const):
+        (WebCore::LayerAncestorClippingStack::clear):
+        (WebCore::LayerAncestorClippingStack::detachFromScrollingCoordinator):
+        (WebCore::LayerAncestorClippingStack::firstClippingLayer const):
+        (WebCore::LayerAncestorClippingStack::lastClippingLayer const):
+        (WebCore::LayerAncestorClippingStack::lastOverflowScrollProxyNodeID const):
+        (WebCore::LayerAncestorClippingStack::updateScrollingNodeLayers):
+        (WebCore::LayerAncestorClippingStack::updateWithClipData):
+        (WebCore::operator<<):
+        * rendering/LayerAncestorClippingStack.h: Added.
+        (WebCore::CompositedClipData::CompositedClipData):
+        (WebCore::CompositedClipData::operator== const):
+        (WebCore::CompositedClipData::operator!= const):
+        (WebCore::LayerAncestorClippingStack::stack):
+        (WebCore::LayerAncestorClippingStack::stack const):
+        * rendering/RenderLayerBacking.cpp:
+        (WebCore::RenderLayerBacking::~RenderLayerBacking):
+        (WebCore::RenderLayerBacking::updateDebugIndicators):
+        (WebCore::RenderLayerBacking::destroyGraphicsLayers):
+        (WebCore::RenderLayerBacking::updateTransform):
+        (WebCore::RenderLayerBacking::updateBlendMode):
+        (WebCore::RenderLayerBacking::updateAfterLayout):
+        (WebCore::RenderLayerBacking::updateConfiguration):
+        (WebCore::computeOffsetFromAncestorGraphicsLayer):
+        (WebCore::RenderLayerBacking::computePrimaryGraphicsLayerRect const):
+        (WebCore::RenderLayerBacking::computeParentGraphicsLayerRect const):
+        (WebCore::RenderLayerBacking::updateGeometry):
+        (WebCore::RenderLayerBacking::updateInternalHierarchy):
+        (WebCore::RenderLayerBacking::updateAncestorClippingStack):
+        (WebCore::RenderLayerBacking::updateAncestorClipping):
+        (WebCore::RenderLayerBacking::detachFromScrollingCoordinator):
+        (WebCore::RenderLayerBacking::scrollingNodeIDForChildren const):
+        (WebCore::RenderLayerBacking::childForSuperlayers const):
+        (WebCore::RenderLayerBacking::backingStoreMemoryEstimate const):
+        (WebCore::operator<<):
+        (WebCore::RenderLayerBacking::updateAncestorClippingLayer): Deleted.
+        (WebCore::RenderLayerBacking::coordinatedScrollingRoles const): Deleted.
+        * rendering/RenderLayerBacking.h:
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::didChangePlatformLayerForLayer):
+        (WebCore::RenderLayerCompositor::updateBackingAndHierarchy):
+        (WebCore::RenderLayerCompositor::layerStyleChanged): We need to run the checks for changed
+        clipping whether or not this layer has backing, because a non-composited layer with clipping can be
+        represented in the clipping stack of some other layer.
+        (WebCore::RenderLayerCompositor::clippedByAncestor const):
+        (WebCore::RenderLayerCompositor::updateAncestorClippingStack const):
+        (WebCore::RenderLayerCompositor::computeAncestorClippingStack const): The output of this function
+        is a Vector<CompositedClipData> which represents the ancestor clipping stack, but without the proxy node
+        and GraphicsLayer information. It's input to LayerAncestorClippingStack::updateWithClipData() which does
+        the merging of old and new states.
+        (WebCore::collectRelatedCoordinatedScrollingNodes):
+        (WebCore::RenderLayerCompositor::removeFromScrollCoordinatedLayers):
+        (WebCore::scrollCoordinationRoleForNodeType):
+        (WebCore::RenderLayerCompositor::attachScrollingNode):
+        (WebCore::RenderLayerCompositor::registerScrollingNodeID):
+        (WebCore::RenderLayerCompositor::detachScrollCoordinatedLayerWithRole):
+        (WebCore::RenderLayerCompositor::detachScrollCoordinatedLayer):
+        (WebCore::RenderLayerCompositor::coordinatedScrollingRolesForLayer const): Code moved from RenderLayerBacking.
+        (WebCore::RenderLayerCompositor::updateScrollCoordinationForLayer):
+        (WebCore::RenderLayerCompositor::updateScrollingNodeForScrollingProxyRole):
+        (WebCore::RenderLayerCompositor::updateScrollingNodeForPositioningRole):
+        * rendering/RenderLayerCompositor.h:
+        (WebCore::allScrollCoordinationRoles):
+
 2019-06-23  Simon Fraser  <simon.fraser@apple.com>
 

trunk/Source/WebCore/Headers.cmake

@@ -1244 +1244 @@
     rendering/InlineBox.h
     rendering/InlineFlowBox.h
+    rendering/LayerAncestorClippingStack.h
     rendering/LayerFragment.h
     rendering/MarkedText.h

trunk/Source/WebCore/Sources.txt

@@ -1987 +1987 @@
 rendering/InlineIterator.cpp
 rendering/InlineTextBox.cpp
+rendering/LayerAncestorClippingStack.cpp
 rendering/LayerOverlapMap.cpp
 rendering/LayoutDisallowedScope.cpp

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

@@ -368 +368 @@
                 0FEA3E84191B31BF000F1B55 /* ScrollingStateOverflowScrollingNode.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FEA3E82191B31BF000F1B55 /* ScrollingStateOverflowScrollingNode.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 0FEA3E88191B3BD7000F1B55 /* ScrollingTreeFrameScrollingNode.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FEA3E86191B3BD7000F1B55 /* ScrollingTreeFrameScrollingNode.h */; settings = {ATTRIBUTES = (Private, ); }; };
+                0FEC120C22BF2CD2004E9D35 /* LayerAncestorClippingStack.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FEC120922BF2CC7004E9D35 /* LayerAncestorClippingStack.h */; settings = {ATTRIBUTES = (Private, ); }; };
                 0FF3B9291EE3B6DE00B84144 /* JSDOMQuad.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FF3B9251EE3B6DE00B84144 /* JSDOMQuad.h */; };
                 0FF3B92B1EE3B6DE00B84144 /* JSDOMQuadInit.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FF3B9271EE3B6DE00B84144 /* JSDOMQuadInit.h */; };
@@ -5816 +5817 @@
                 0FEA3E85191B3BD7000F1B55 /* ScrollingTreeFrameScrollingNode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ScrollingTreeFrameScrollingNode.cpp; sourceTree = "<group>"; };
                 0FEA3E86191B3BD7000F1B55 /* ScrollingTreeFrameScrollingNode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScrollingTreeFrameScrollingNode.h; sourceTree = "<group>"; };
+                0FEC120922BF2CC7004E9D35 /* LayerAncestorClippingStack.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = LayerAncestorClippingStack.h; sourceTree = "<group>"; };
+                0FEC120B22BF2CC7004E9D35 /* LayerAncestorClippingStack.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = LayerAncestorClippingStack.cpp; sourceTree = "<group>"; };
                 0FEF20CD1BD4A24100128E5D /* LengthSize.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LengthSize.cpp; sourceTree = "<group>"; };
                 0FEF20CF1BD4A64F00128E5D /* RenderStyleConstants.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderStyleConstants.cpp; sourceTree = "<group>"; };
@@ -26998 +27001 @@
                                 BCEA481A097D93020094C9E4 /* InlineTextBox.cpp */,
                                 BCEA481B097D93020094C9E4 /* InlineTextBox.h */,
+                                0FEC120B22BF2CC7004E9D35 /* LayerAncestorClippingStack.cpp */,
+                                0FEC120922BF2CC7004E9D35 /* LayerAncestorClippingStack.h */,
                                 580371631A66F1D300BAF519 /* LayerFragment.h */,
                                 0F69F2B7228B98FF008D3565 /* LayerOverlapMap.cpp */,
@@ -30511 +30516 @@
                                 450CEBF115073BBE002BB149 /* LabelableElement.h in Headers */,
                                 A456FA2711AD4A830020B420 /* LabelsNodeList.h in Headers */,
+                                0FEC120C22BF2CD2004E9D35 /* LayerAncestorClippingStack.h in Headers */,
                                 E4916FF7195DF6A0005AB349 /* LayerFlushThrottleState.h in Headers */,
                                 580371641A66F1D300BAF519 /* LayerFragment.h in Headers */,

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

@@ -695 +695 @@
 }
 
-void AsyncScrollingCoordinator::setPositionedNodeGeometry(ScrollingNodeID nodeID, const LayoutConstraints& constraints)
+void AsyncScrollingCoordinator::setPositionedNodeConstraints(ScrollingNodeID nodeID, const AbsolutePositionConstraints& constraints)
 {
     auto* node = m_scrollingStateTree->stateNodeForID(nodeID);

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

@@ -116 +116 @@
     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 setPositionedNodeConstraints(ScrollingNodeID, const AbsolutePositionConstraints&) override;
     WEBCORE_EXPORT void setRelatedOverflowScrollingNodes(ScrollingNodeID, Vector<ScrollingNodeID>&&) override;
 

trunk/Source/WebCore/page/scrolling/ScrollingConstraints.cpp

@@ -111 +111 @@
 }
 
-TextStream& operator<<(TextStream& ts, const LayoutConstraints& constraints)
+TextStream& operator<<(TextStream& ts, const AbsolutePositionConstraints& constraints)
 {
     ts.dumpProperty("layer-position-at-last-layout", constraints.layerPositionAtLastLayout());
-    ts.dumpProperty("positioning-behavior", constraints.scrollPositioningBehavior());
 
     return ts;

trunk/Source/WebCore/page/scrolling/ScrollingConstraints.h

@@ -31 +31 @@
 namespace WebCore {
 
-// LayoutConstraints classes encapsulate data and logic required to reposition elements whose layout
-// depends on the scroll position of ancestor elements.
-class LayoutConstraints {
+class AbsolutePositionConstraints {
     WTF_MAKE_FAST_ALLOCATED;
 public:
-    LayoutConstraints() = default;
-
-    bool operator==(const LayoutConstraints& other) const
+    AbsolutePositionConstraints() = default;
+
+    bool operator==(const AbsolutePositionConstraints& other) const
     {
         return alignmentOffset() == other.alignmentOffset()
-            && layerPositionAtLastLayout() == other.layerPositionAtLastLayout()
-            && scrollPositioningBehavior() == other.scrollPositioningBehavior();
+            && layerPositionAtLastLayout() == other.layerPositionAtLastLayout();
     }
 
-    bool operator!=(const LayoutConstraints& other) const { return !(*this == other); }
+    bool operator!=(const AbsolutePositionConstraints& other) const { return !(*this == other); }
     
     FloatSize alignmentOffset() const { return m_alignmentOffset; }
@@ -53 +50 @@
     void setLayerPositionAtLastLayout(FloatPoint position) { m_layerPositionAtLastLayout = position; }
     
-    ScrollPositioningBehavior scrollPositioningBehavior() const { return m_scrollPositioningBehavior; }
-    void setScrollPositioningBehavior(ScrollPositioningBehavior behavior) { m_scrollPositioningBehavior = behavior; }
-
 private:
     FloatSize m_alignmentOffset;
     FloatPoint m_layerPositionAtLastLayout;
-    ScrollPositioningBehavior m_scrollPositioningBehavior { ScrollPositioningBehavior::None };
 };
 
@@ -206 +199 @@
 
 WEBCORE_EXPORT WTF::TextStream& operator<<(WTF::TextStream&, ScrollPositioningBehavior);
-WEBCORE_EXPORT WTF::TextStream& operator<<(WTF::TextStream&, const LayoutConstraints&);
+WEBCORE_EXPORT WTF::TextStream& operator<<(WTF::TextStream&, const AbsolutePositionConstraints&);
 WEBCORE_EXPORT WTF::TextStream& operator<<(WTF::TextStream&, const FixedPositionViewportConstraints&);
 WEBCORE_EXPORT WTF::TextStream& operator<<(WTF::TextStream&, const StickyPositionViewportConstraints&);

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

@@ -53 +53 @@
 namespace WebCore {
 
+class AbsolutePositionConstraints;
 class Document;
 class Frame;
 class FrameView;
 class GraphicsLayer;
-class LayoutConstraints;
 class Page;
 class Region;
@@ -150 +150 @@
     virtual void setFrameScrollingNodeState(ScrollingNodeID, const FrameView&) { }
     virtual void setViewportConstraintedNodeConstraints(ScrollingNodeID, const ViewportConstraints&) { }
-    virtual void setPositionedNodeGeometry(ScrollingNodeID, const LayoutConstraints&) { }
+    virtual void setPositionedNodeConstraints(ScrollingNodeID, const AbsolutePositionConstraints&) { }
     virtual void setRelatedOverflowScrollingNodes(ScrollingNodeID, Vector<ScrollingNodeID>&&) { }
 

trunk/Source/WebCore/page/scrolling/ScrollingStatePositionedNode.cpp

@@ -76 +76 @@
 }
 
-void ScrollingStatePositionedNode::updateConstraints(const LayoutConstraints& constraints)
+void ScrollingStatePositionedNode::updateConstraints(const AbsolutePositionConstraints& constraints)
 {
     if (m_constraints == constraints)

trunk/Source/WebCore/page/scrolling/ScrollingStatePositionedNode.h

@@ -36 +36 @@
 
 // ScrollingStatePositionedNode is used to manage the layers for z-order composited descendants of overflow:scroll
-// which are not containing block descendants. These layers must have their position inside their ancestor clipping
+// which are not containing block descendants (i.e. position:absolute). These layers must have their position inside their ancestor clipping
 // layer adjusted on the scrolling thread.
 class ScrollingStatePositionedNode final : public ScrollingStateNode {
@@ -55 +55 @@
     WEBCORE_EXPORT void setRelatedOverflowScrollingNodes(Vector<ScrollingNodeID>&&);
 
-    WEBCORE_EXPORT void updateConstraints(const LayoutConstraints&);
-    const LayoutConstraints& layoutConstraints() const { return m_constraints; }
+    WEBCORE_EXPORT void updateConstraints(const AbsolutePositionConstraints&);
+    const AbsolutePositionConstraints& layoutConstraints() const { return m_constraints; }
 
 private:
@@ -67 +67 @@
 
     Vector<ScrollingNodeID> m_relatedOverflowScrollingNodes;
-    LayoutConstraints m_constraints;
+    AbsolutePositionConstraints m_constraints;
 };
 

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

@@ -170 +170 @@
 
     m_overflowRelatedNodesMap.clear();
-    m_positionedNodesWithRelatedOverflow.clear();
+    m_nodesWithRelatedOverflow.clear();
 
     // orphanNodes keeps child nodes alive while we rebuild child lists.

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

@@ -155 +155 @@
     RelatedNodesMap& overflowRelatedNodes() { return m_overflowRelatedNodesMap; }
 
-    HashSet<ScrollingNodeID>& positionedNodesWithRelatedOverflow() { return m_positionedNodesWithRelatedOverflow; }
+    HashSet<ScrollingNodeID>& nodesWithRelatedOverflow() { return m_nodesWithRelatedOverflow; }
 
     WEBCORE_EXPORT String scrollingTreeAsText(ScrollingStateTreeAsTextBehavior = ScrollingStateTreeAsTextBehaviorNormal);
@@ -180 +180 @@
 
     RelatedNodesMap m_overflowRelatedNodesMap;
-    HashSet<ScrollingNodeID> m_positionedNodesWithRelatedOverflow;
+    HashSet<ScrollingNodeID> m_nodesWithRelatedOverflow;
 
     struct TreeState {

trunk/Source/WebCore/page/scrolling/cocoa/ScrollingTreeFixedNode.mm

@@ -33 +33 @@
 #import "ScrollingTree.h"
 #import "ScrollingTreeFrameScrollingNode.h"
+#import "ScrollingTreeOverflowScrollProxyNode.h"
 #import "ScrollingTreeOverflowScrollingNode.h"
 #import "ScrollingTreePositionedNode.h"
@@ -84 +85 @@
                 // To keep the layer still during async scrolling we adjust by how much the position has changed since layout.
                 auto& overflowNode = downcast<ScrollingTreeOverflowScrollingNode>(*ancestor);
+                overflowScrollDelta -= overflowNode.scrollDeltaSinceLastCommit();
+                continue;
+            }
+
+            if (is<ScrollingTreeOverflowScrollProxyNode>(*ancestor)) {
+                // To keep the layer still during async scrolling we adjust by how much the position has changed since layout.
+                auto& overflowNode = downcast<ScrollingTreeOverflowScrollProxyNode>(*ancestor);
                 overflowScrollDelta -= overflowNode.scrollDeltaSinceLastCommit();
                 continue;

trunk/Source/WebCore/page/scrolling/cocoa/ScrollingTreeOverflowScrollProxyNode.mm

@@ -63 +63 @@
     }).iterator->value.append(scrollingNodeID());
 
-    scrollingTree().positionedNodesWithRelatedOverflow().add(scrollingNodeID());
+    scrollingTree().nodesWithRelatedOverflow().add(scrollingNodeID());
 }
 

trunk/Source/WebCore/page/scrolling/cocoa/ScrollingTreePositionedNode.h

@@ -44 +44 @@
     CALayer *layer() const { return m_layer.get(); }
 
-    ScrollPositioningBehavior scrollPositioningBehavior() const { return m_constraints.scrollPositioningBehavior(); }
     const Vector<ScrollingNodeID>& relatedOverflowScrollingNodes() const { return m_relatedOverflowScrollingNodes; }
 
@@ -59 +58 @@
 
     Vector<ScrollingNodeID> m_relatedOverflowScrollingNodes;
-    LayoutConstraints m_constraints;
+    AbsolutePositionConstraints m_constraints;
     RetainPtr<CALayer> m_layer;
 };

trunk/Source/WebCore/page/scrolling/cocoa/ScrollingTreePositionedNode.mm

@@ -64 +64 @@
         m_constraints = positionedStateNode.layoutConstraints();
 
-    // Tell the ScrollingTree about non-ancestor overflow nodes which affect this node.
-    if (m_constraints.scrollPositioningBehavior() == ScrollPositioningBehavior::Moves) {
-        auto& relatedNodes = scrollingTree().overflowRelatedNodes();
-        for (auto overflowNodeID : m_relatedOverflowScrollingNodes) {
-            relatedNodes.ensure(overflowNodeID, [] {
-                return Vector<ScrollingNodeID>();
-            }).iterator->value.append(scrollingNodeID());
-        }
-    }
-    if (!m_relatedOverflowScrollingNodes.isEmpty() && m_constraints.scrollPositioningBehavior() != ScrollPositioningBehavior::None)
-        scrollingTree().positionedNodesWithRelatedOverflow().add(scrollingNodeID());
+    if (!m_relatedOverflowScrollingNodes.isEmpty())
+        scrollingTree().nodesWithRelatedOverflow().add(scrollingNodeID());
 }
 
@@ -88 +79 @@
         }
     }
-    if (m_constraints.scrollPositioningBehavior() == ScrollPositioningBehavior::Stationary) {
-        // Stationary nodes move in the opposite direction.
-        return -delta;
-    }
-
-    return delta;
+    
+    // Positioned nodes compensate for scrolling, so negate the scroll delta.
+    return -delta;
 }
 

trunk/Source/WebCore/page/scrolling/cocoa/ScrollingTreeStickyNode.mm

@@ -34 +34 @@
 #import "ScrollingTreeFixedNode.h"
 #import "ScrollingTreeFrameScrollingNode.h"
+#import "ScrollingTreeOverflowScrollProxyNode.h"
 #import "ScrollingTreeOverflowScrollingNode.h"
 #import "WebCoreCALayerExtras.h"
@@ -82 +83 @@
 
     for (auto* ancestor = parent(); ancestor; ancestor = ancestor->parent()) {
-        if (is<ScrollingTreePositionedNode>(*ancestor)) {
-            auto& positioningAncestor = downcast<ScrollingTreePositionedNode>(*ancestor);
+        if (is<ScrollingTreeOverflowScrollProxyNode>(*ancestor)) {
+            auto& overflowProxyNode = downcast<ScrollingTreeOverflowScrollProxyNode>(*ancestor);
+            auto overflowNode = scrollingTree().nodeForID(overflowProxyNode.overflowScrollingNodeID());
+            if (!overflowNode)
+                break;
 
-            // FIXME: Do we need to do anything for ScrollPositioningBehavior::Stationary?
-            if (positioningAncestor.scrollPositioningBehavior() == ScrollPositioningBehavior::Moves) {
-                if (positioningAncestor.relatedOverflowScrollingNodes().isEmpty())
-                    break;
-                auto overflowNode = scrollingTree().nodeForID(positioningAncestor.relatedOverflowScrollingNodes()[0]);
-                if (!overflowNode)
-                    break;
+            return computeLayerPositionForScrollingNode(*overflowNode);
+        }
 
-                auto position = computeLayerPositionForScrollingNode(*overflowNode);
-
-                if (positioningAncestor.layer() == m_layer) {
-                    // We'll also do the adjustment the positioning node would do.
-                    position -= positioningAncestor.scrollDeltaSinceLastCommit();
-                }
-
-                return position;
-            }
-        }
         if (is<ScrollingTreeScrollingNode>(*ancestor))
             return computeLayerPositionForScrollingNode(*ancestor);

trunk/Source/WebCore/platform/graphics/GraphicsContext.h

@@ -355 +355 @@
     WEBCORE_EXPORT void save();
     WEBCORE_EXPORT void restore();
+    
+    unsigned stackSize() const { return m_stack.size(); }
 
     // These draw methods will do both stroking and filling.
@@ -698 +700 @@
 };
 
+
+class GraphicsContextStateStackChecker {
+public:
+    GraphicsContextStateStackChecker(GraphicsContext& context)
+        : m_context(context)
+        , m_stackSize(context.stackSize())
+    { }
+    
+    ~GraphicsContextStateStackChecker()
+    {
+        if (m_context.stackSize() != m_stackSize)
+            WTFLogAlways("GraphicsContext %p stack changed by %d", this, (int)m_context.stackSize() - (int)m_stackSize);
+    }
+
+private:
+    GraphicsContext& m_context;
+    unsigned m_stackSize;
+};
+
+
+
 class InterpolationQualityMaintainer {
 public:

trunk/Source/WebCore/rendering/RenderLayer.cpp

@@ -4390 +4390 @@
         return;
 
+    GraphicsContextStateStackChecker checker(context);
+
     updateLayerListsIfNeeded();
 

trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

@@ -48 +48 @@
 #include "InspectorInstrumentation.h"
 #include "KeyframeList.h"
+#include "LayerAncestorClippingStack.h"
 #include "Logging.h"
 #include "Page.h"
@@ -239 +240 @@
 {
     // Note that m_owningLayer->backing() is null here.
-    updateAncestorClippingLayer(false);
+    updateAncestorClipping(false, nullptr);
     updateChildClippingStrategy(false);
     updateDescendantClippingLayer(false);
@@ -425 +426 @@
     m_graphicsLayer->setShowRepaintCounter(showRepaintCounter);
     
-    if (m_ancestorClippingLayer)
-        m_ancestorClippingLayer->setShowDebugBorder(showBorder);
+    if (m_ancestorClippingStack) {
+        for (auto& entry : m_ancestorClippingStack->stack())
+            entry.clippingLayer->setShowDebugBorder(showBorder);
+    }
 
     if (m_foregroundLayer) {
@@ -540 +543 @@
     GraphicsLayer::clear(m_maskLayer);
 
-    GraphicsLayer::unparentAndClear(m_ancestorClippingLayer);
+    if (m_ancestorClippingStack) {
+        for (auto& entry : m_ancestorClippingStack->stack())
+            GraphicsLayer::unparentAndClear(entry.clippingLayer);
+    }
+
     GraphicsLayer::unparentAndClear(m_contentsContainmentLayer);
     GraphicsLayer::unparentAndClear(m_foregroundLayer);
@@ -569 +576 @@
     if (m_contentsContainmentLayer) {
         m_contentsContainmentLayer->setTransform(t);
-        m_graphicsLayer->setTransform(TransformationMatrix());
+        m_graphicsLayer->setTransform({ });
     } else
         m_graphicsLayer->setTransform(t);
@@ -612 +619 @@
 void RenderLayerBacking::updateBlendMode(const RenderStyle& style)
 {
-    // FIXME: where is the blend mode updated when m_ancestorClippingLayers come and go?
-    if (m_ancestorClippingLayer) {
-        m_ancestorClippingLayer->setBlendMode(style.blendMode());
+    // FIXME: where is the blend mode updated when m_ancestorClippingStacks come and go?
+    if (m_ancestorClippingStack) {
+        m_ancestorClippingStack->stack().first().clippingLayer->setBlendMode(style.blendMode());
         m_graphicsLayer->setBlendMode(BlendMode::Normal);
     } else
@@ -737 +744 @@
         // This layer's geometry affects those of its children.
         m_owningLayer.setChildrenNeedCompositingGeometryUpdate();
-    } else if (needsClippingUpdate)
+    } else if (needsClippingUpdate) {
+        m_owningLayer.setNeedsCompositingConfigurationUpdate();
         m_owningLayer.setNeedsCompositingGeometryUpdate();
+    }
     
     if (needsFullRepaint && canIssueSetNeedsDisplay())
@@ -805 +814 @@
         layerConfigChanged = true;
 
-    // clippedByAncestor() does a tree walk.
-    if (updateAncestorClippingLayer(compositor.clippedByAncestor(m_owningLayer)))
+    auto* compositingAncestor = m_owningLayer.ancestorCompositingLayer();
+    if (updateAncestorClipping(compositor.clippedByAncestor(m_owningLayer, compositingAncestor), compositingAncestor))
         layerConfigChanged = true;
 
@@ -950 +959 @@
 }
 
-static LayoutSize computeOffsetFromAncestorGraphicsLayer(RenderLayer* compositedAncestor, const LayoutPoint& location, float deviceScaleFactor)
+static LayoutSize computeOffsetFromAncestorGraphicsLayer(const RenderLayer* compositedAncestor, const LayoutPoint& location, float deviceScaleFactor)
 {
     if (!compositedAncestor)
@@ -1014 +1023 @@
 LayoutRect RenderLayerBacking::computePrimaryGraphicsLayerRect(const LayoutRect& parentGraphicsLayerRect) const
 {
-    ComputedOffsets compositedBoundsOffset(m_owningLayer, compositedBounds(), parentGraphicsLayerRect, LayoutRect());
+    ComputedOffsets compositedBoundsOffset(m_owningLayer, compositedBounds(), parentGraphicsLayerRect, { });
     return LayoutRect(encloseRectToDevicePixels(LayoutRect(toLayoutPoint(compositedBoundsOffset.fromParentGraphicsLayer()), compositedBounds().size()),
         deviceScaleFactor()));
@@ -1020 +1029 @@
 
 // FIXME: See if we need this now that updateGeometry() is always called in post-order traversal.
-LayoutRect RenderLayerBacking::computeParentGraphicsLayerRect(RenderLayer* compositedAncestor, LayoutSize& ancestorClippingLayerOffset) const
+LayoutRect RenderLayerBacking::computeParentGraphicsLayerRect(const RenderLayer* compositedAncestor) const
 {
     if (!compositedAncestor || !compositedAncestor->backing())
@@ -1049 +1058 @@
     }
 
-    if (m_ancestorClippingLayer) {
-        // Call calculateRects to get the backgroundRect which is what is used to clip the contents of this
-        // layer. Note that we call it with temporaryClipRects = true because normally when computing clip rects
-        // for a compositing layer, rootLayer is the layer itself.
-        ShouldRespectOverflowClip shouldRespectOverflowClip = compositedAncestor->isolatesCompositedBlending() ? RespectOverflowClip : IgnoreOverflowClip;
-        RenderLayer::ClipRectsContext clipRectsContext(compositedAncestor, TemporaryClipRects, IgnoreOverlayScrollbarSize, shouldRespectOverflowClip);
-        LayoutRect parentClipRect = m_owningLayer.backgroundClipRect(clipRectsContext).rect(); // FIXME: Incorrect for CSS regions.
-        ASSERT(!parentClipRect.isInfinite());
-        LayoutSize clippingOffset = computeOffsetFromAncestorGraphicsLayer(compositedAncestor, parentClipRect.location(), deviceScaleFactor());
-        LayoutRect snappedClippingLayerRect = snappedGraphicsLayer(clippingOffset, parentClipRect.size(), deviceScaleFactor()).m_snappedRect;
-        // The primary layer is then parented in, and positioned relative to this clipping layer.
-        ancestorClippingLayerOffset = snappedClippingLayerRect.location() - parentGraphicsLayerRect.location();
-        parentGraphicsLayerRect = snappedClippingLayerRect;
-    }
     return parentGraphicsLayerRect;
 }
@@ -1092 +1087 @@
 #endif
 
+    auto* compositedAncestor = m_owningLayer.ancestorCompositingLayer();
+    LayoutRect parentGraphicsLayerRect = computeParentGraphicsLayerRect(compositedAncestor);
+
+    if (m_ancestorClippingStack) {
+        // All clipRects in the stack are computed relative to m_owningLayer, so convert them back to compositedAncestor.
+        auto offsetFromCompositedAncestor = toLayoutSize(m_owningLayer.convertToLayerCoords(compositedAncestor, { }, RenderLayer::AdjustForColumns));
+        LayoutRect lastClipLayerRect = parentGraphicsLayerRect;
+
+        for (auto& entry : m_ancestorClippingStack->stack()) {
+            auto clipRect = entry.clipData.clipRect;
+            LayoutSize clippingOffset = computeOffsetFromAncestorGraphicsLayer(compositedAncestor, clipRect.location() + offsetFromCompositedAncestor, deviceScaleFactor());
+            LayoutRect snappedClippingLayerRect = snappedGraphicsLayer(clippingOffset, clipRect.size(), deviceScaleFactor()).m_snappedRect;
+
+            entry.clippingLayer->setPosition(toLayoutPoint(snappedClippingLayerRect.location() - lastClipLayerRect.location()));
+            lastClipLayerRect = snappedClippingLayerRect;
+
+            entry.clippingLayer->setSize(snappedClippingLayerRect.size());
+
+            if (entry.clipData.isOverflowScroll) {
+                ScrollOffset scrollOffset = entry.clipData.clippingLayer->scrollOffset();
+
+                entry.clippingLayer->setBoundsOrigin(scrollOffset);
+                lastClipLayerRect.moveBy(-scrollOffset);
+            }
+        }
+
+        parentGraphicsLayerRect = lastClipLayerRect;
+    }
+
+    LayoutRect primaryGraphicsLayerRect = computePrimaryGraphicsLayerRect(parentGraphicsLayerRect);
+
+    ComputedOffsets compositedBoundsOffset(m_owningLayer, compositedBounds(), parentGraphicsLayerRect, primaryGraphicsLayerRect);
+    ComputedOffsets rendererOffset(m_owningLayer, { }, parentGraphicsLayerRect, primaryGraphicsLayerRect);
+
+    m_compositedBoundsOffsetFromGraphicsLayer = compositedBoundsOffset.fromPrimaryGraphicsLayer();
+
+    auto primaryLayerPosition = primaryGraphicsLayerRect.location();
+
     // FIXME: reflections should force transform-style to be flat in the style: https://bugs.webkit.org/show_bug.cgi?id=106959
     bool preserves3D = style.transformStyle3D() == TransformStyle3D::Preserve3D && !renderer().hasReflection();
-    m_graphicsLayer->setPreserves3D(preserves3D);
-    m_graphicsLayer->setBackfaceVisibility(style.backfaceVisibility() == BackfaceVisibility::Visible);
-
-    auto* compositedAncestor = m_owningLayer.ancestorCompositingLayer();
-    LayoutSize ancestorClippingLayerOffset;
-    LayoutRect parentGraphicsLayerRect = computeParentGraphicsLayerRect(compositedAncestor, ancestorClippingLayerOffset);
-    LayoutRect primaryGraphicsLayerRect = computePrimaryGraphicsLayerRect(parentGraphicsLayerRect);
-
-    ComputedOffsets compositedBoundsOffset(m_owningLayer, compositedBounds(), parentGraphicsLayerRect, primaryGraphicsLayerRect);
-    m_compositedBoundsOffsetFromGraphicsLayer = compositedBoundsOffset.fromPrimaryGraphicsLayer();
-    m_graphicsLayer->setPosition(primaryGraphicsLayerRect.location());
-    m_graphicsLayer->setSize(primaryGraphicsLayerRect.size());
+    if (m_contentsContainmentLayer) {
+        m_contentsContainmentLayer->setPreserves3D(preserves3D);
+        m_contentsContainmentLayer->setPosition(primaryLayerPosition);
+        primaryLayerPosition = { };
+        // Use the same size as m_graphicsLayer so transforms behave correctly.
+        m_contentsContainmentLayer->setSize(primaryGraphicsLayerRect.size());
+    }
 
     auto computeAnimationExtent = [&] () -> Optional<FloatRect> {
@@ -1114 +1142 @@
     };
     m_graphicsLayer->setAnimationExtent(computeAnimationExtent());
-
-    ComputedOffsets rendererOffset(m_owningLayer, LayoutRect(), parentGraphicsLayerRect, primaryGraphicsLayerRect);
-    if (m_ancestorClippingLayer) {
-        // Clipping layer is parented in the ancestor layer.
-        m_ancestorClippingLayer->setPosition(toLayoutPoint(ancestorClippingLayerOffset));
-        m_ancestorClippingLayer->setSize(parentGraphicsLayerRect.size());
-        m_ancestorClippingLayer->setOffsetFromRenderer(-rendererOffset.fromParentGraphicsLayer());
-    }
-
-    if (m_contentsContainmentLayer) {
-        m_contentsContainmentLayer->setPreserves3D(preserves3D);
-        m_contentsContainmentLayer->setPosition(primaryGraphicsLayerRect.location());
-        m_graphicsLayer->setPosition(FloatPoint());
-        // Use the same size as m_graphicsLayer so transforms behave correctly.
-        m_contentsContainmentLayer->setSize(primaryGraphicsLayerRect.size());
-    }
+    m_graphicsLayer->setPreserves3D(preserves3D);
+    m_graphicsLayer->setBackfaceVisibility(style.backfaceVisibility() == BackfaceVisibility::Visible);
+
+    m_graphicsLayer->setPosition(primaryLayerPosition);
+    m_graphicsLayer->setSize(primaryGraphicsLayerRect.size());
 
     // Compute renderer offset from primary graphics layer. Note that primaryGraphicsLayerRect is in parentGraphicsLayer's coordinate system which is not necessarily
@@ -1396 +1413 @@
     // m_foregroundLayer has to be inserted in the correct order with child layers,
     // so it's not inserted here.
-    if (m_ancestorClippingLayer)
-        m_ancestorClippingLayer->removeAllChildren();
+    GraphicsLayer* lastClippingLayer = nullptr;
+    if (m_ancestorClippingStack) {
+        auto& clippingStack = m_ancestorClippingStack->stack();
+        for (unsigned i = 0; i < clippingStack.size() - 1; ++i) {
+            auto& entry = clippingStack.at(i);
+            Vector<Ref<GraphicsLayer>> children;
+            children.append(*clippingStack.at(i + 1).clippingLayer);
+            entry.clippingLayer->setChildren(WTFMove(children));
+        }
+        
+        lastClippingLayer = clippingStack.last().clippingLayer.get();
+        lastClippingLayer->removeAllChildren();
+    }
     
     if (m_contentsContainmentLayer) {
         m_contentsContainmentLayer->removeAllChildren();
-        if (m_ancestorClippingLayer)
-            m_ancestorClippingLayer->addChild(*m_contentsContainmentLayer);
+        if (lastClippingLayer)
+            lastClippingLayer->addChild(*m_contentsContainmentLayer);
     }
     
@@ -1410 +1438 @@
     if (m_contentsContainmentLayer)
         m_contentsContainmentLayer->addChild(*m_graphicsLayer);
-    else if (m_ancestorClippingLayer)
-        m_ancestorClippingLayer->addChild(*m_graphicsLayer);
+    else if (lastClippingLayer)
+        lastClippingLayer->addChild(*m_graphicsLayer);
 
     if (m_childContainmentLayer)
@@ -1526 +1554 @@
 }
 
+bool RenderLayerBacking::updateAncestorClippingStack(Vector<CompositedClipData>&& clippingData)
+{
+    if (!m_ancestorClippingStack && clippingData.isEmpty())
+        return false;
+
+    auto* scrollingCoordinator = m_owningLayer.page().scrollingCoordinator();
+
+    if (m_ancestorClippingStack && clippingData.isEmpty()) {
+        m_ancestorClippingStack->clear(scrollingCoordinator);
+        m_ancestorClippingStack = nullptr;
+        return true;
+    }
+    
+    if (!m_ancestorClippingStack) {
+        m_ancestorClippingStack = std::make_unique<LayerAncestorClippingStack>(WTFMove(clippingData));
+        LOG_WITH_STREAM(Compositing, stream << "layer " << &m_owningLayer << "  ancestorClippingStack " << *m_ancestorClippingStack);
+        return true;
+    }
+    
+    if (m_ancestorClippingStack->equalToClipData(clippingData)) {
+        LOG_WITH_STREAM(Compositing, stream << "layer " << &m_owningLayer << "  ancestorClippingStack " << *m_ancestorClippingStack);
+        return false;
+    }
+    
+    m_ancestorClippingStack->updateWithClipData(scrollingCoordinator, WTFMove(clippingData));
+    LOG_WITH_STREAM(Compositing, stream << "layer " << &m_owningLayer << "  ancestorClippingStack " << *m_ancestorClippingStack);
+    return true;
+}
+
 // Return true if the layer changed.
-bool RenderLayerBacking::updateAncestorClippingLayer(bool needsAncestorClip)
+bool RenderLayerBacking::updateAncestorClipping(bool needsAncestorClip, const RenderLayer* compositingAncestor)
 {
     bool layersChanged = false;
 
     if (needsAncestorClip) {
-        if (!m_ancestorClippingLayer) {
-            m_ancestorClippingLayer = createGraphicsLayer("ancestor clipping");
-            m_ancestorClippingLayer->setMasksToBounds(true);
+        if (compositor().updateAncestorClippingStack(m_owningLayer, compositingAncestor)) {
+            // Make any layers we don't have.
+            if (m_ancestorClippingStack) {
+                for (auto& entry : m_ancestorClippingStack->stack()) {
+                    if (!entry.clippingLayer) {
+                        entry.clippingLayer = createGraphicsLayer(entry.clipData.isOverflowScroll ? "clip for scroller" : "ancestor clipping");
+                        entry.clippingLayer->setMasksToBounds(true);
+                        entry.clippingLayer->setPaintingPhase({ });
+                    }
+                }
+            }
+
             layersChanged = true;
         }
-    } else if (hasAncestorClippingLayer()) {
-        willDestroyLayer(m_ancestorClippingLayer.get());
-        GraphicsLayer::unparentAndClear(m_ancestorClippingLayer);
+    } else if (m_ancestorClippingStack) {
+        for (auto& entry : m_ancestorClippingStack->stack())
+            GraphicsLayer::unparentAndClear(entry.clippingLayer);
+
+        m_ancestorClippingStack = nullptr;
         layersChanged = true;
     }
@@ -1861 +1929 @@
 }
 
-OptionSet<ScrollCoordinationRole> RenderLayerBacking::coordinatedScrollingRoles() const
-{
-    auto& compositor = this->compositor();
-
-    OptionSet<ScrollCoordinationRole> coordinationRoles;
-    if (compositor.isViewportConstrainedFixedOrStickyLayer(m_owningLayer))
-        coordinationRoles.add(ScrollCoordinationRole::ViewportConstrained);
-
-    if (compositor.useCoordinatedScrollingForLayer(m_owningLayer))
-        coordinationRoles.add(ScrollCoordinationRole::Scrolling);
-
-    if (compositor.isLayerForIFrameWithScrollCoordinatedContents(m_owningLayer))
-        coordinationRoles.add(ScrollCoordinationRole::FrameHosting);
-
-    if (compositor.computeCoordinatedPositioningForLayer(m_owningLayer) != ScrollPositioningBehavior::None)
-        coordinationRoles.add(ScrollCoordinationRole::Positioning);
-
-    return coordinationRoles;
-}
-
 void RenderLayerBacking::detachFromScrollingCoordinator(OptionSet<ScrollCoordinationRole> roles)
 {
-    if (!m_scrollingNodeID && !m_frameHostingNodeID && !m_viewportConstrainedNodeID && !m_positioningNodeID)
+    if (!m_scrollingNodeID && !m_ancestorClippingStack && !m_frameHostingNodeID && !m_viewportConstrainedNodeID && !m_positioningNodeID)
         return;
 
@@ -1891 +1939 @@
 
     if (roles.contains(ScrollCoordinationRole::Scrolling) && m_scrollingNodeID) {
-        LOG(Compositing, "Detaching Scrolling node %" PRIu64, m_scrollingNodeID);
+        LOG_WITH_STREAM(Compositing, stream << "Detaching Scrolling node " << m_scrollingNodeID);
         scrollingCoordinator->unparentChildrenAndDestroyNode(m_scrollingNodeID);
         m_scrollingNodeID = 0;
     }
 
+    if (roles.contains(ScrollCoordinationRole::ScrollingProxy) && m_ancestorClippingStack) {
+        m_ancestorClippingStack->detachFromScrollingCoordinator(*scrollingCoordinator);
+        LOG_WITH_STREAM(Compositing, stream << "Detaching nodes in ancestor clipping stack");
+    }
+
     if (roles.contains(ScrollCoordinationRole::FrameHosting) && m_frameHostingNodeID) {
-        LOG(Compositing, "Detaching FrameHosting node %" PRIu64, m_frameHostingNodeID);
+        LOG_WITH_STREAM(Compositing, stream << "Detaching FrameHosting node " << m_frameHostingNodeID);
         scrollingCoordinator->unparentChildrenAndDestroyNode(m_frameHostingNodeID);
         m_frameHostingNodeID = 0;
@@ -1903 +1956 @@
 
     if (roles.contains(ScrollCoordinationRole::ViewportConstrained) && m_viewportConstrainedNodeID) {
-        LOG(Compositing, "Detaching ViewportConstrained node %" PRIu64, m_viewportConstrainedNodeID);
+        LOG_WITH_STREAM(Compositing, stream << "Detaching ViewportConstrained node " << m_viewportConstrainedNodeID);
         scrollingCoordinator->unparentChildrenAndDestroyNode(m_viewportConstrainedNodeID);
         m_viewportConstrainedNodeID = 0;
@@ -1909 +1962 @@
 
     if (roles.contains(ScrollCoordinationRole::Positioning) && m_positioningNodeID) {
-        LOG(Compositing, "Detaching Positioned node %" PRIu64, m_positioningNodeID);
+        LOG_WITH_STREAM(Compositing, stream << "Detaching Positioned node " << m_positioningNodeID);
         scrollingCoordinator->unparentChildrenAndDestroyNode(m_positioningNodeID);
         m_positioningNodeID = 0;
     }
+}
+
+ScrollingNodeID RenderLayerBacking::scrollingNodeIDForChildren() const
+{
+    if (m_frameHostingNodeID)
+        return m_frameHostingNodeID;
+
+    if (m_scrollingNodeID)
+        return m_scrollingNodeID;
+
+    if (m_viewportConstrainedNodeID)
+        return m_viewportConstrainedNodeID;
+
+    if (m_ancestorClippingStack) {
+        if (auto lastOverflowScrollProxyNode = m_ancestorClippingStack->lastOverflowScrollProxyNodeID())
+            return lastOverflowScrollProxyNode;
+    }
+
+    return m_positioningNodeID;
 }
 
@@ -2499 +2571 @@
 GraphicsLayer* RenderLayerBacking::childForSuperlayers() const
 {
-    if (m_ancestorClippingLayer)
-        return m_ancestorClippingLayer.get();
+    if (m_ancestorClippingStack)
+        return m_ancestorClippingStack->firstClippingLayer();
 
     if (m_contentsContainmentLayer)
@@ -2655 +2727 @@
         return;
     }
+
+    GraphicsContextStateStackChecker checker(context);
 
     OptionSet<RenderLayer::PaintLayerFlag> paintFlags;
@@ -3312 +3386 @@
     double backingMemory;
     
-    // m_ancestorClippingLayer, m_contentsContainmentLayer and m_childContainmentLayer are just used for masking or containment, so have no backing.
+    // Layers in m_ancestorClippingStack, m_contentsContainmentLayer and m_childContainmentLayer are just used for masking or containment, so have no backing.
     backingMemory = m_graphicsLayer->backingStoreMemoryEstimate();
     if (m_foregroundLayer)
@@ -3354 +3428 @@
     if (auto nodeID = backing.scrollingNodeIDForRole(ScrollCoordinationRole::Scrolling))
         ts << " scrolling node " << nodeID;
+
+    if (backing.ancestorClippingStack())
+        ts << " ancestor clip stack " << *backing.ancestorClippingStack();
+
     if (auto nodeID = backing.scrollingNodeIDForRole(ScrollCoordinationRole::FrameHosting))
         ts << " frame hosting node " << nodeID;

trunk/Source/WebCore/rendering/RenderLayerBacking.h

@@ -45 +45 @@
     NormalCompositingLayer, // non-tiled layer with backing store
     TiledCompositingLayer, // tiled layer (always has backing store)
-    MediaCompositingLayer, // layer that contains an image, video, webGL or plugin
+    MediaCompositingLayer, // layer that contains an image, video, WebGL or plugin
     ContainerCompositingLayer // layer with no backing store
 };
@@ -101 +101 @@
     GraphicsLayer* clippingLayer() const { return !m_isFrameLayerWithTiledBacking ? m_childContainmentLayer.get() : nullptr; }
 
-    // Layer to get clipped by ancestor
-    bool hasAncestorClippingLayer() const { return m_ancestorClippingLayer != nullptr; }
-    GraphicsLayer* ancestorClippingLayer() const { return m_ancestorClippingLayer.get(); }
+    bool hasAncestorClippingLayers() const { return !!m_ancestorClippingStack; }
+    LayerAncestorClippingStack* ancestorClippingStack() const { return m_ancestorClippingStack.get(); }
+    bool updateAncestorClippingStack(Vector<CompositedClipData>&&);
 
     GraphicsLayer* contentsContainmentLayer() const { return m_contentsContainmentLayer.get(); }
@@ -117 +117 @@
     GraphicsLayer* scrollContainerLayer() const { return m_scrollContainerLayer.get(); }
     GraphicsLayer* scrolledContentsLayer() const { return m_scrolledContentsLayer.get(); }
-
-    OptionSet<ScrollCoordinationRole> coordinatedScrollingRoles() const;
 
     void detachFromScrollingCoordinator(OptionSet<ScrollCoordinationRole>);
@@ -127 +125 @@
         case ScrollCoordinationRole::Scrolling:
             return m_scrollingNodeID;
+        case ScrollCoordinationRole::ScrollingProxy:
+            // These nodeIDs are stored in m_ancestorClippingStack.
+            ASSERT_NOT_REACHED();
+            return 0;
         case ScrollCoordinationRole::FrameHosting:
             return m_frameHostingNodeID;
@@ -142 +144 @@
         case ScrollCoordinationRole::Scrolling:
             m_scrollingNodeID = nodeID;
+            break;
+        case ScrollCoordinationRole::ScrollingProxy:
+            // These nodeIDs are stored in m_ancestorClippingStack.
+            ASSERT_NOT_REACHED();
             break;
         case ScrollCoordinationRole::FrameHosting:
@@ -156 +162 @@
     }
 
-    ScrollingNodeID scrollingNodeIDForChildren() const
-    {
-        if (m_frameHostingNodeID)
-            return m_frameHostingNodeID;
-
-        if (m_scrollingNodeID)
-            return m_scrollingNodeID;
-
-        if (m_viewportConstrainedNodeID)
-            return m_viewportConstrainedNodeID;
-
-        return m_positioningNodeID;
-    }
-
+    ScrollingNodeID scrollingNodeIDForChildren() const;
     void setIsScrollCoordinatedWithViewportConstrainedRole(bool);
 
@@ -314 +307 @@
 
     void updateInternalHierarchy();
-    bool updateAncestorClippingLayer(bool needsAncestorClip);
+    bool updateAncestorClipping(bool needsAncestorClip, const RenderLayer* compositingAncestor);
     bool updateDescendantClippingLayer(bool needsDescendantClip);
     bool updateOverflowControlsLayers(bool needsHorizontalScrollbarLayer, bool needsVerticalScrollbarLayer, bool needsScrollCornerLayer);
@@ -392 +385 @@
 
     bool canIssueSetNeedsDisplay() const { return !paintsIntoWindow() && !paintsIntoCompositedAncestor(); }
-    LayoutRect computeParentGraphicsLayerRect(RenderLayer* compositedAncestor, LayoutSize& ancestorClippingLayerOffset) const;
+    LayoutRect computeParentGraphicsLayerRect(const RenderLayer* compositedAncestor) const;
     LayoutRect computePrimaryGraphicsLayerRect(const LayoutRect& parentGraphicsLayerRect) const;
 
     RenderLayer& m_owningLayer;
-
+    
     // A list other layers that paint into this backing store, later than m_owningLayer in paint order.
     Vector<WeakPtr<RenderLayer>> m_backingSharingLayers;
 
-    RefPtr<GraphicsLayer> m_ancestorClippingLayer; // Only used if we are clipped by an ancestor which is not a stacking context.
+    std::unique_ptr<LayerAncestorClippingStack> m_ancestorClippingStack; // Only used if we are clipped by an ancestor which is not a stacking context.
+
     RefPtr<GraphicsLayer> m_contentsContainmentLayer; // Only used if we have a background layer; takes the transform.
     RefPtr<GraphicsLayer> m_graphicsLayer;

trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

@@ -43 +43 @@
 #include "HitTestResult.h"
 #include "InspectorInstrumentation.h"
+#include "LayerAncestorClippingStack.h"
 #include "LayerOverlapMap.h"
 #include "Logging.h"
@@ -577 +578 @@
         updateScrollingNodeLayers(nodeID, layer, *scrollingCoordinator);
 
+    if (auto* clippingStack = layer.backing()->ancestorClippingStack())
+        clippingStack->updateScrollingNodeLayers(*scrollingCoordinator);
+
     if (auto nodeID = backing->scrollingNodeIDForRole(ScrollCoordinationRole::ViewportConstrained))
         scrollingCoordinator->setNodeLayers(nodeID, { backing->graphicsLayer() });
@@ -1229 +1233 @@
         // FIXME: do based on dirty flags. Need to do this for changes of geometry, configuration and hierarchy.
         // Need to be careful to do the right thing when a scroll-coordinated layer loses a scroll-coordinated ancestor.
-        stateForDescendants.parentNodeID = updateScrollCoordinationForLayer(layer, scrollingTreeState, layerBacking->coordinatedScrollingRoles(), scrollingNodeChanges);
+        stateForDescendants.parentNodeID = updateScrollCoordinationForLayer(layer, scrollingTreeState, scrollingNodeChanges);
         stateForDescendants.nextChildIndex = 0;
 
@@ -1470 +1474 @@
         layer.setNeedsPostLayoutCompositingUpdate();
 
-    if (diff >= StyleDifference::LayoutPositionedMovementOnly && hasContentCompositingLayers()) {
-        layer.setNeedsPostLayoutCompositingUpdate();
-        layer.setNeedsCompositingGeometryUpdate();
+    const auto& newStyle = layer.renderer().style();
+
+    if (hasContentCompositingLayers()) {
+        if (diff >= StyleDifference::LayoutPositionedMovementOnly) {
+            layer.setNeedsPostLayoutCompositingUpdate();
+            layer.setNeedsCompositingGeometryUpdate();
+        }
+
+        if (diff >= StyleDifference::Layout) {
+            // FIXME: only set flags here if we know we have a composited descendant, but we might not know at this point.
+            if (oldStyle && clippingChanged(*oldStyle, newStyle)) {
+                if (layer.isStackingContext()) {
+                    layer.setNeedsPostLayoutCompositingUpdate(); // Layer needs to become composited if it has composited descendants.
+                    layer.setNeedsCompositingConfigurationUpdate(); // If already composited, layer needs to create/destroy clipping layer.
+                } else {
+                    // Descendant (in containing block order) compositing layers need to re-evaluate their clipping,
+                    // but they might be siblings in z-order so go up to our stacking context.
+                    if (auto* stackingContext = layer.stackingContext())
+                        stackingContext->setDescendantsNeedUpdateBackingAndHierarchyTraversal();
+                }
+            }
+
+            // These properties trigger compositing if some descendant is composited.
+            if (oldStyle && styleChangeMayAffectIndirectCompositingReasons(*oldStyle, newStyle))
+                layer.setNeedsPostLayoutCompositingUpdate();
+
+            layer.setNeedsCompositingGeometryUpdate();
+        }
     }
 
@@ -1480 +1509 @@
 
     backing->updateConfigurationAfterStyleChange();
-
-    const auto& newStyle = layer.renderer().style();
 
     if (diff >= StyleDifference::Repaint) {
@@ -1502 +1529 @@
         // FIXME: transform changes really need to trigger layout. See RenderElement::adjustStyleDifference().
         layer.setNeedsPostLayoutCompositingUpdate();
-        layer.setNeedsCompositingGeometryUpdate();
-    }
-
-    if (diff >= StyleDifference::Layout) {
-        // FIXME: only set flags here if we know we have a composited descendant, but we might not know at this point.
-        if (oldStyle && clippingChanged(*oldStyle, newStyle)) {
-            if (layer.isStackingContext()) {
-                layer.setNeedsPostLayoutCompositingUpdate(); // Layer needs to become composited if it has composited descendants.
-                layer.setNeedsCompositingConfigurationUpdate(); // If already composited, layer needs to create/destroy clipping layer.
-            } else {
-                // Descendant (in containing block order) compositing layers need to re-evaluate their clipping,
-                // but they might be siblings in z-order so go up to our stacking context.
-                if (auto* stackingContext = layer.stackingContext())
-                    stackingContext->setDescendantsNeedUpdateBackingAndHierarchyTraversal();
-            }
-        }
-
-        // These properties trigger compositing if some descendant is composited.
-        if (oldStyle && styleChangeMayAffectIndirectCompositingReasons(*oldStyle, newStyle))
-            layer.setNeedsPostLayoutCompositingUpdate();
-
         layer.setNeedsCompositingGeometryUpdate();
     }
@@ -2587 +2593 @@
 // but a sibling in the z-order hierarchy.
 // FIXME: can we do this without a tree walk?
-bool RenderLayerCompositor::clippedByAncestor(RenderLayer& layer) const
+bool RenderLayerCompositor::clippedByAncestor(RenderLayer& layer, const RenderLayer* compositingAncestor) const
 {
     ASSERT(layer.isComposited());
-    if (!layer.parent())
-        return false;
-
-    // On first pass in WK1, the root may not have become composited yet.
-    auto* compositingAncestor = layer.ancestorCompositingLayer();
     if (!compositingAncestor)
         return false;
@@ -2623 +2624 @@
 }
 
+bool RenderLayerCompositor::updateAncestorClippingStack(const RenderLayer& layer, const RenderLayer* compositingAncestor) const
+{
+    ASSERT(layer.isComposited());
+
+    auto clippingStack = computeAncestorClippingStack(layer, compositingAncestor);
+    return layer.backing()->updateAncestorClippingStack(WTFMove(clippingStack));
+}
+
+Vector<CompositedClipData> RenderLayerCompositor::computeAncestorClippingStack(const RenderLayer& layer, const RenderLayer* compositingAncestor) const
+{
+    // On first pass in WK1, the root may not have become composited yet.
+    if (!compositingAncestor)
+        return { };
+
+    // We'll start by building a child-to-ancestors stack.
+    Vector<CompositedClipData> newStack;
+
+    // Walk up the containing block chain to composited ancestor, prepending an entry to the clip stack for:
+    // * each composited scrolling layer
+    // * each set of RenderLayers which contribute a clip.
+    bool haveNonScrollableClippingIntermediateLayer = false;
+    const RenderLayer* currentClippedLayer = &layer;
+    
+    auto pushNonScrollableClip = [&](const RenderLayer& clippedLayer, const RenderLayer& clippingRoot, ShouldRespectOverflowClip respectClip = IgnoreOverflowClip) {
+        // Pass IgnoreOverflowClip to ignore overflow contributed by clippingRoot (which may be a scroller).
+        auto clipRect = clippedLayer.backgroundClipRect(RenderLayer::ClipRectsContext(&clippingRoot, TemporaryClipRects, IgnoreOverlayScrollbarSize, respectClip)).rect();
+        auto offset = layer.convertToLayerCoords(&clippingRoot, { }, RenderLayer::AdjustForColumns);
+        clipRect.moveBy(-offset);
+
+        CompositedClipData clipData { const_cast<RenderLayer*>(&clippedLayer), clipRect, false };
+        newStack.insert(0, WTFMove(clipData));
+    };
+
+    traverseAncestorLayers(layer, [&](const RenderLayer& ancestorLayer, bool isContainingBlockChain, bool /*isPaintOrderAncestor*/) {
+        if (&ancestorLayer == compositingAncestor) {
+        
+            if (haveNonScrollableClippingIntermediateLayer)
+                pushNonScrollableClip(*currentClippedLayer, ancestorLayer, ancestorLayer.isolatesCompositedBlending() ? RespectOverflowClip : IgnoreOverflowClip);
+            else if (ancestorLayer.isolatesCompositedBlending() && newStack.isEmpty())
+                pushNonScrollableClip(*currentClippedLayer, ancestorLayer, RespectOverflowClip);
+
+            return AncestorTraversal::Stop;
+        }
+
+        if (isContainingBlockChain && ancestorLayer.renderer().hasClipOrOverflowClip()) {
+            if (ancestorLayer.hasCompositedScrollableOverflow()) {
+                if (haveNonScrollableClippingIntermediateLayer) {
+                    pushNonScrollableClip(*currentClippedLayer, ancestorLayer);
+                    haveNonScrollableClippingIntermediateLayer = false;
+                }
+
+                auto clipRect = parentRelativeScrollableRect(ancestorLayer, &ancestorLayer);
+                auto offset = layer.convertToLayerCoords(&ancestorLayer, { }, RenderLayer::AdjustForColumns);
+                clipRect.moveBy(-offset);
+
+                CompositedClipData clipData { const_cast<RenderLayer*>(&ancestorLayer), clipRect, true };
+                newStack.insert(0, WTFMove(clipData));
+                currentClippedLayer = &ancestorLayer;
+            } else
+                haveNonScrollableClippingIntermediateLayer = true;
+        }
+
+        return AncestorTraversal::Continue;
+    });
+    
+    return newStack;
+}
+
 // Return true if the given layer is a stacking context and has compositing child
 // layers that it needs to clip. In this case we insert a clipping GraphicsLayer
@@ -3184 +3253 @@
 static Vector<ScrollingNodeID> collectRelatedCoordinatedScrollingNodes(const RenderLayer& layer, ScrollPositioningBehavior positioningBehavior)
 {
-    Vector<ScrollingNodeID> overflowNodeData;
+    Vector<ScrollingNodeID> overflowNodeIDs;
 
     switch (positioningBehavior) {
-    case ScrollPositioningBehavior::Moves: {
-        // Collect all the composited scrollers between this layer and its composited ancestor.
-        auto* compositedAncestor = layer.ancestorCompositingLayer();
-        for (const auto* currLayer = layer.parent(); currLayer != compositedAncestor; currLayer = currLayer->parent()) {
-            if (currLayer->hasCompositedScrollableOverflow()) {
-                auto scrollingNodeID = currLayer->isComposited() ? currLayer->backing()->scrollingNodeIDForRole(ScrollCoordinationRole::Scrolling) : 0;
-                if (scrollingNodeID)
-                    overflowNodeData.append(scrollingNodeID);
-                else
-                    LOG(Scrolling, "Layer %p isn't composited or doesn't have scrolling node ID yet", &layer);
-            }
-        }
-        break;
-    }
     case ScrollPositioningBehavior::Stationary: {
         auto* compositedAncestor = layer.ancestorCompositingLayer();
         if (!compositedAncestor)
-            return overflowNodeData;
-        collectStationaryLayerRelatedOverflowNodes(layer, *compositedAncestor, overflowNodeData);
+            return overflowNodeIDs;
+        collectStationaryLayerRelatedOverflowNodes(layer, *compositedAncestor, overflowNodeIDs);
         break;
     }
+    case ScrollPositioningBehavior::Moves:
     case ScrollPositioningBehavior::None:
         ASSERT_NOT_REACHED();
@@ -3213 +3269 @@
     }
 
-    return overflowNodeData;
+    return overflowNodeIDs;
 }
 
@@ -4048 +4104 @@
 #endif
 
-    detachScrollCoordinatedLayer(layer, { ScrollCoordinationRole::Scrolling, ScrollCoordinationRole::ViewportConstrained, ScrollCoordinationRole::FrameHosting, ScrollCoordinationRole::Positioning });
+    detachScrollCoordinatedLayer(layer, allScrollCoordinationRoles());
 }
 
@@ -4110 +4166 @@
     case ScrollingNodeType::Overflow:
         return ScrollCoordinationRole::Scrolling;
+    case ScrollingNodeType::OverflowProxy:
+        return ScrollCoordinationRole::ScrollingProxy;
     case ScrollingNodeType::FrameHosting:
         return ScrollCoordinationRole::FrameHosting;
@@ -4117 +4175 @@
     case ScrollingNodeType::Positioned:
         return ScrollCoordinationRole::Positioning;
-    case ScrollingNodeType::OverflowProxy:
-        break;
     }
     ASSERT_NOT_REACHED();
@@ -4138 +4194 @@
     ScrollCoordinationRole role = scrollCoordinationRoleForNodeType(nodeType);
     ScrollingNodeID nodeID = backing->scrollingNodeIDForRole(role);
+    
+    nodeID = registerScrollingNodeID(*scrollingCoordinator, nodeID, nodeType, treeState);
+
+    LOG_WITH_STREAM(Scrolling, stream << "RenderLayerCompositor " << this << " attachScrollingNode " << nodeID << " (layer " << backing->graphicsLayer()->primaryLayerID() << ") type " << nodeType << " parent " << treeState.parentNodeID.valueOr(0));
+
     if (!nodeID)
-        nodeID = scrollingCoordinator->uniqueScrollingNodeID();
-
-    LOG_WITH_STREAM(Scrolling, stream << "RenderLayerCompositor " << this << " attachScrollingNode " << nodeID << " (layer " << backing->graphicsLayer()->primaryLayerID() << ") type " << nodeType << " parent " << treeState.parentNodeID.valueOr(0));
+        return 0;
+    
+    backing->setScrollingNodeIDForRole(nodeID, role);
+    m_scrollingNodeToLayerMap.add(nodeID, &layer);
+    
+    return nodeID;
+}
+
+ScrollingNodeID RenderLayerCompositor::registerScrollingNodeID(ScrollingCoordinator& scrollingCoordinator, ScrollingNodeID nodeID, ScrollingNodeType nodeType, struct ScrollingTreeState& treeState)
+{
+    if (!nodeID)
+        nodeID = scrollingCoordinator.uniqueScrollingNodeID();
 
     if (nodeType == ScrollingNodeType::Subframe && !treeState.parentNodeID)
-        nodeID = scrollingCoordinator->createNode(nodeType, nodeID);
+        nodeID = scrollingCoordinator.createNode(nodeType, nodeID);
     else {
-        auto newNodeID = scrollingCoordinator->insertNode(nodeType, nodeID, treeState.parentNodeID.valueOr(0), treeState.nextChildIndex);
+        auto newNodeID = scrollingCoordinator.insertNode(nodeType, nodeID, treeState.parentNodeID.valueOr(0), treeState.nextChildIndex);
         if (newNodeID != nodeID) {
             // We'll get a new nodeID if the type changed (and not if the node is new).
-            scrollingCoordinator->unparentChildrenAndDestroyNode(nodeID);
+            scrollingCoordinator.unparentChildrenAndDestroyNode(nodeID);
             m_scrollingNodeToLayerMap.remove(nodeID);
         }
@@ -4159 +4229 @@
         return 0;
     
-    backing->setScrollingNodeIDForRole(nodeID, role);
-    m_scrollingNodeToLayerMap.add(nodeID, &layer);
-    
     ++treeState.nextChildIndex;
     return nodeID;
@@ -4168 +4235 @@
 void RenderLayerCompositor::detachScrollCoordinatedLayerWithRole(RenderLayer& layer, ScrollingCoordinator& scrollingCoordinator, ScrollCoordinationRole role)
 {
+    auto unregisterNode = [&](ScrollingNodeID nodeID) {
+        auto childNodes = scrollingCoordinator.childrenOfNode(nodeID);
+        for (auto childNodeID : childNodes) {
+            if (auto* layer = m_scrollingNodeToLayerMap.get(childNodeID))
+                layer->setNeedsScrollingTreeUpdate();
+        }
+
+        m_scrollingNodeToLayerMap.remove(nodeID);
+    };
+
+    if (role == ScrollCoordinationRole::ScrollingProxy) {
+        ASSERT(layer.isComposited());
+        auto* clippingStack = layer.backing()->ancestorClippingStack();
+        if (!clippingStack)
+            return;
+        
+        auto& stack = clippingStack->stack();
+        for (auto& entry : stack) {
+            if (entry.overflowScrollProxyNodeID)
+                unregisterNode(entry.overflowScrollProxyNodeID);
+        }
+        return;
+    }
+
     auto nodeID = layer.backing()->scrollingNodeIDForRole(role);
     if (!nodeID)
         return;
 
-    auto childNodes = scrollingCoordinator.childrenOfNode(nodeID);
-    for (auto childNodeID : childNodes) {
-        // FIXME: The child might be in a child frame. Need to do something that crosses frame boundaries.
-        if (auto* layer = m_scrollingNodeToLayerMap.get(childNodeID))
-            layer->setNeedsScrollingTreeUpdate();
-    }
-
-    m_scrollingNodeToLayerMap.remove(nodeID);
+    unregisterNode(nodeID);
 }
 
@@ -4193 +4277 @@
         detachScrollCoordinatedLayerWithRole(layer, *scrollingCoordinator, ScrollCoordinationRole::Scrolling);
 
+    if (roles.contains(ScrollCoordinationRole::ScrollingProxy))
+        detachScrollCoordinatedLayerWithRole(layer, *scrollingCoordinator, ScrollCoordinationRole::ScrollingProxy);
+
     if (roles.contains(ScrollCoordinationRole::FrameHosting))
         detachScrollCoordinatedLayerWithRole(layer, *scrollingCoordinator, ScrollCoordinationRole::FrameHosting);
@@ -4205 +4292 @@
 }
 
-ScrollingNodeID RenderLayerCompositor::updateScrollCoordinationForLayer(RenderLayer& layer, ScrollingTreeState& treeState, OptionSet<ScrollCoordinationRole> roles, OptionSet<ScrollingNodeChangeFlags> changes)
-{
+OptionSet<ScrollCoordinationRole> RenderLayerCompositor::coordinatedScrollingRolesForLayer(const RenderLayer& layer) const
+{
+    OptionSet<ScrollCoordinationRole> coordinationRoles;
+    if (isViewportConstrainedFixedOrStickyLayer(layer))
+        coordinationRoles.add(ScrollCoordinationRole::ViewportConstrained);
+
+    if (useCoordinatedScrollingForLayer(layer))
+        coordinationRoles.add(ScrollCoordinationRole::Scrolling);
+
+    auto coordinatedPositioning = computeCoordinatedPositioningForLayer(layer);
+    switch (coordinatedPositioning) {
+    case ScrollPositioningBehavior::Moves:
+        coordinationRoles.add(ScrollCoordinationRole::ScrollingProxy);
+        break;
+    case ScrollPositioningBehavior::Stationary:
+        coordinationRoles.add(ScrollCoordinationRole::Positioning);
+        break;
+    case ScrollPositioningBehavior::None:
+        break;
+    }
+
+    if (isLayerForIFrameWithScrollCoordinatedContents(layer))
+        coordinationRoles.add(ScrollCoordinationRole::FrameHosting);
+
+    return coordinationRoles;
+}
+
+ScrollingNodeID RenderLayerCompositor::updateScrollCoordinationForLayer(RenderLayer& layer, ScrollingTreeState& treeState, OptionSet<ScrollingNodeChangeFlags> changes)
+{
+    auto roles = coordinatedScrollingRolesForLayer(layer);
+
     bool isViewportConstrained = roles.contains(ScrollCoordinationRole::ViewportConstrained);
 #if PLATFORM(IOS_FAMILY)
@@ -4237 +4353 @@
     } else
         detachScrollCoordinatedLayer(layer, ScrollCoordinationRole::Positioning);
+
+    // If there's a scrolling proxy node, it's the parent scrolling node for fixed/sticky/scrolling/frame hosting.
+    if (roles.contains(ScrollCoordinationRole::ScrollingProxy)) {
+        newNodeID = updateScrollingNodeForScrollingProxyRole(layer, *currentTreeState, changes);
+        childTreeState.parentNodeID = newNodeID;
+        currentTreeState = &childTreeState;
+    } else
+        detachScrollCoordinatedLayer(layer, ScrollCoordinationRole::ScrollingProxy);
 
     // If is fixed or sticky, it's the parent scrolling node for scrolling/frame hosting.
@@ -4384 +4508 @@
 }
 
+ScrollingNodeID RenderLayerCompositor::updateScrollingNodeForScrollingProxyRole(RenderLayer& layer, ScrollingTreeState& treeState, OptionSet<ScrollingNodeChangeFlags> changes)
+{
+    auto* scrollingCoordinator = this->scrollingCoordinator();
+    auto* clippingStack = layer.backing()->ancestorClippingStack();
+    if (!clippingStack)
+        return 0;
+
+    ScrollingNodeID nodeID = 0;
+    for (auto& entry : clippingStack->stack()) {
+        if (!entry.clipData.isOverflowScroll)
+            continue;
+
+        nodeID = registerScrollingNodeID(*scrollingCoordinator, entry.overflowScrollProxyNodeID, ScrollingNodeType::OverflowProxy, treeState);
+        if (!nodeID) {
+            ASSERT_NOT_REACHED();
+            return treeState.parentNodeID.valueOr(0);
+        }
+        entry.overflowScrollProxyNodeID = nodeID;
+
+        if (changes & ScrollingNodeChangeFlags::Layer)
+            scrollingCoordinator->setNodeLayers(entry.overflowScrollProxyNodeID, { entry.clippingLayer.get() });
+
+        if (changes & ScrollingNodeChangeFlags::LayerGeometry) {
+            ASSERT(entry.clipData.clippingLayer);
+            ASSERT(entry.clipData.clippingLayer->isComposited());
+
+            auto overflowScrollNodeID = 0;
+            if (auto* backing = entry.clipData.clippingLayer->backing())
+                overflowScrollNodeID = backing->scrollingNodeIDForRole(ScrollCoordinationRole::Scrolling);
+        
+            Vector<ScrollingNodeID> scrollingNodeIDs;
+            if (overflowScrollNodeID)
+                scrollingNodeIDs.append(overflowScrollNodeID);
+            scrollingCoordinator->setRelatedOverflowScrollingNodes(entry.overflowScrollProxyNodeID, WTFMove(scrollingNodeIDs));
+        }
+    }
+
+    return nodeID;
+}
+
 ScrollingNodeID RenderLayerCompositor::updateScrollingNodeForFrameHostingRole(RenderLayer& layer, ScrollingTreeState& treeState, OptionSet<ScrollingNodeChangeFlags> changes)
 {
@@ -4427 +4591 @@
 
         auto* graphicsLayer = layer.backing()->graphicsLayer();
-        LayoutConstraints constraints;
+        AbsolutePositionConstraints constraints;
         constraints.setAlignmentOffset(graphicsLayer->pixelAlignmentOffset());
         constraints.setLayerPositionAtLastLayout(graphicsLayer->position());
-        constraints.setScrollPositioningBehavior(positioningBehavior);
-        scrollingCoordinator->setPositionedNodeGeometry(newNodeID, constraints);
+        scrollingCoordinator->setPositionedNodeConstraints(newNodeID, constraints);
     }
 

trunk/Source/WebCore/rendering/RenderLayerCompositor.h

@@ -29 +29 @@
 #include "GraphicsLayerClient.h"
 #include "GraphicsLayerUpdater.h"
+#include "LayerAncestorClippingStack.h"
 #include "RenderLayer.h"
 #include <wtf/HashMap.h>
@@ -89 +90 @@
     ViewportConstrained = 1 << 0,
     Scrolling           = 1 << 1,
-    FrameHosting        = 1 << 2,
-    Positioning         = 1 << 3,
+    ScrollingProxy      = 1 << 2,
+    FrameHosting        = 1 << 3,
+    Positioning         = 1 << 4,
 };
+
+static constexpr OptionSet<ScrollCoordinationRole> allScrollCoordinationRoles()
+{
+    return {
+        ScrollCoordinationRole::Scrolling,
+        ScrollCoordinationRole::ScrollingProxy,
+        ScrollCoordinationRole::ViewportConstrained,
+        ScrollCoordinationRole::FrameHosting,
+        ScrollCoordinationRole::Positioning
+    };
+}
 
 #if PLATFORM(IOS_FAMILY)
@@ -202 +215 @@
 
     // Whether layer's backing needs a graphics layer to do clipping by an ancestor (non-stacking-context parent with overflow).
-    bool clippedByAncestor(RenderLayer&) const;
+    bool clippedByAncestor(RenderLayer&, const RenderLayer* compositingAncestor) const;
+
+    bool updateAncestorClippingStack(const RenderLayer&, const RenderLayer* compositingAncestor) const;
+
     // Whether layer's backing needs a graphics layer to clip z-order children of the given layer.
     static bool clipsCompositingDescendants(const RenderLayer&);
@@ -492 +508 @@
 
     ScrollingNodeID attachScrollingNode(RenderLayer&, ScrollingNodeType, struct ScrollingTreeState&);
+    ScrollingNodeID registerScrollingNodeID(ScrollingCoordinator&, ScrollingNodeID, ScrollingNodeType, struct ScrollingTreeState&);
+
+    OptionSet<ScrollCoordinationRole> coordinatedScrollingRolesForLayer(const RenderLayer&) const;
 
     // Returns the ScrollingNodeID which acts as the parent for children.
-    ScrollingNodeID updateScrollCoordinationForLayer(RenderLayer&, struct ScrollingTreeState&, OptionSet<ScrollCoordinationRole>, OptionSet<ScrollingNodeChangeFlags>);
+    ScrollingNodeID updateScrollCoordinationForLayer(RenderLayer&, struct ScrollingTreeState&, 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 updateScrollingNodeForScrollingProxyRole(RenderLayer&, struct ScrollingTreeState&, OptionSet<ScrollingNodeChangeFlags>);
     ScrollingNodeID updateScrollingNodeForFrameHostingRole(RenderLayer&, struct ScrollingTreeState&, OptionSet<ScrollingNodeChangeFlags>);
     ScrollingNodeID updateScrollingNodeForPositioningRole(RenderLayer&, struct ScrollingTreeState&, OptionSet<ScrollingNodeChangeFlags>);
@@ -512 +532 @@
     LayoutRect rootParentRelativeScrollableRect() const;
     LayoutRect parentRelativeScrollableRect(const RenderLayer&, const RenderLayer* ancestorLayer) const;
+
+    // Returns list of layers and their clip rects required to clip the given layer, which include clips in the
+    // containing block chain between the given layer and its composited ancestor.
+    Vector<CompositedClipData> computeAncestorClippingStack(const RenderLayer&, const RenderLayer* compositingAncestor) const;
 
     bool requiresScrollLayer(RootLayerAttachment) const;

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2019-06-23  Simon Fraser  <simon.fraser@apple.com>
+
+        [Async overflow scroll] Clipped composited layers inside overflow scroll jitter and get incorrectly clipped
+        https://bugs.webkit.org/show_bug.cgi?id=199133
+        rdar://problem/43614439
+
+        Reviewed by Antti Koivisto.
+        
+        LayoutConstraints -> AbsolutePositionConstraints rename.
+
+        * Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp:
+        (ArgumentCoder<ScrollingStatePositionedNode>::decode):
+        * Shared/WebCoreArgumentCoders.cpp:
+        (IPC::ArgumentCoder<AbsolutePositionConstraints>::encode):
+        (IPC::ArgumentCoder<AbsolutePositionConstraints>::decode):
+        (IPC::ArgumentCoder<LayoutConstraints>::encode): Deleted.
+        (IPC::ArgumentCoder<LayoutConstraints>::decode): Deleted.
+        * Shared/WebCoreArgumentCoders.h:
+        * Shared/WebRenderLayer.cpp:
+        (WebKit::WebRenderLayer::WebRenderLayer):
+        * UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm:
+        (WebKit::RemoteScrollingCoordinatorProxy::establishLayerTreeScrollingRelations): ScrollingTreeOverflowScrollProxyNode
+        have overflow scroll relations now too.
+
 2019-06-23  Simon Fraser  <simon.fraser@apple.com>
 

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

@@ -437 +437 @@
 
     if (node.hasChangedProperty(ScrollingStatePositionedNode::LayoutConstraintData)) {
-        LayoutConstraints decodedValue;
+        AbsolutePositionConstraints decodedValue;
         if (!decoder.decode(decodedValue))
             return false;

trunk/Source/WebKit/Shared/WebCoreArgumentCoders.cpp

@@ -2202 +2202 @@
 }
 
-void ArgumentCoder<LayoutConstraints>::encode(Encoder& encoder, const LayoutConstraints& layoutConstraints)
+void ArgumentCoder<AbsolutePositionConstraints>::encode(Encoder& encoder, const AbsolutePositionConstraints& layoutConstraints)
 {
     encoder << layoutConstraints.alignmentOffset();
     encoder << layoutConstraints.layerPositionAtLastLayout();
-    encoder.encodeEnum(layoutConstraints.scrollPositioningBehavior());
-}
-
-bool ArgumentCoder<LayoutConstraints>::decode(Decoder& decoder, LayoutConstraints& layoutConstraints)
+}
+
+bool ArgumentCoder<AbsolutePositionConstraints>::decode(Decoder& decoder, AbsolutePositionConstraints& layoutConstraints)
 {
     FloatSize alignmentOffset;
@@ -2217 +2216 @@
     FloatPoint layerPosition;
     if (!decoder.decode(layerPosition))
-        return false;
-
-    ScrollPositioningBehavior positioningBehavior;
-    if (!decoder.decodeEnum(positioningBehavior))
         return false;
 
@@ -2226 +2221 @@
     layoutConstraints.setAlignmentOffset(alignmentOffset);
     layoutConstraints.setLayerPositionAtLastLayout(layerPosition);
-    layoutConstraints.setScrollPositioningBehavior(positioningBehavior);
     return true;
 }

trunk/Source/WebKit/Shared/WebCoreArgumentCoders.h

@@ -58 +58 @@
 
 namespace WebCore {
+class AbsolutePositionConstraints;
 class AffineTransform;
 class AuthenticationChallenge;
@@ -83 +84 @@
 class LayoutSize;
 class LayoutPoint;
-class LayoutConstraints;
 class LinearTimingFunction;
 class Notification;
@@ -545 +545 @@
 };
 
-template<> struct ArgumentCoder<WebCore::LayoutConstraints> {
-    static void encode(Encoder&, const WebCore::LayoutConstraints&);
-    static bool decode(Decoder&, WebCore::LayoutConstraints&);
+template<> struct ArgumentCoder<WebCore::AbsolutePositionConstraints> {
+    static void encode(Encoder&, const WebCore::AbsolutePositionConstraints&);
+    static bool decode(Decoder&, WebCore::AbsolutePositionConstraints&);
 };
 

trunk/Source/WebKit/Shared/WebRenderLayer.cpp

@@ -74 +74 @@
         WebCore::RenderLayerBacking* backing = layer->backing();
         m_isClipping = backing->hasClippingLayer();
-        m_isClipped = backing->hasAncestorClippingLayer();
+        m_isClipped = backing->hasAncestorClippingLayers();
         switch (backing->compositingLayerType()) {
         case WebCore::NormalCompositingLayer:

trunk/Source/WebKit/UIProcess/RemoteLayerTree/ios/RemoteScrollingCoordinatorProxyIOS.mm

@@ -133 +133 @@
     // Usually a scroll view scrolls its descendant layers. In some positioning cases it also controls non-descendants, or doesn't control a descendant.
     // To do overlap hit testing correctly we tell layers about such relations.
-    for (auto positionedNodeID : m_scrollingTree->positionedNodesWithRelatedOverflow()) {
-        auto* positionedNode = downcast<ScrollingTreePositionedNode>(m_scrollingTree->nodeForID(positionedNodeID));
-        if (!positionedNode) {
+    
+    for (auto nodeID : m_scrollingTree->nodesWithRelatedOverflow()) {
+        auto* node = m_scrollingTree->nodeForID(nodeID);
+        if (!node) {
             ASSERT_NOT_REACHED();
             continue;
         }
+
         Vector<GraphicsLayer::PlatformLayerID> scrollContainerLayerIDs;
-
-        for (auto overflowNodeID : positionedNode->relatedOverflowScrollingNodes()) {
-            auto* overflowNode = downcast<ScrollingTreeOverflowScrollingNode>(m_scrollingTree->nodeForID(overflowNodeID));
+        RemoteLayerTreeNode* layerNode = nullptr;
+        ScrollPositioningBehavior behavior = ScrollPositioningBehavior::None;
+
+        if (is<ScrollingTreePositionedNode>(*node)) {
+            auto& positionedNode = downcast<ScrollingTreePositionedNode>(*node);
+            for (auto overflowNodeID : positionedNode.relatedOverflowScrollingNodes()) {
+                auto* overflowNode = downcast<ScrollingTreeOverflowScrollingNode>(m_scrollingTree->nodeForID(overflowNodeID));
+                if (!overflowNode) {
+                    ASSERT_NOT_REACHED();
+                    continue;
+                }
+                scrollContainerLayerIDs.append(RemoteLayerTreeNode::layerID(overflowNode->scrollContainerLayer()));
+            }
+            layerNode = RemoteLayerTreeNode::forCALayer(positionedNode.layer());
+            behavior = ScrollPositioningBehavior::Stationary;
+        } else if (is<ScrollingTreeOverflowScrollProxyNode>(*node)) {
+            auto& scrollProxyNode = downcast<ScrollingTreeOverflowScrollProxyNode>(*node);
+            auto* overflowNode = downcast<ScrollingTreeOverflowScrollingNode>(m_scrollingTree->nodeForID(scrollProxyNode.overflowScrollingNodeID()));
             if (!overflowNode) {
                 ASSERT_NOT_REACHED();
@@ -148 +165 @@
             }
             scrollContainerLayerIDs.append(RemoteLayerTreeNode::layerID(overflowNode->scrollContainerLayer()));
-        }
-
-        auto* positionedLayerNode = RemoteLayerTreeNode::forCALayer(positionedNode->layer());
-        if (!positionedLayerNode) {
+            layerNode = RemoteLayerTreeNode::forCALayer(scrollProxyNode.layer());
+            behavior = ScrollPositioningBehavior::Moves;
+        }
+
+        if (!layerNode) {
             ASSERT_NOT_REACHED();
             continue;
         }
-        positionedLayerNode->setRelatedScrollContainerBehaviorAndIDs(positionedNode->scrollPositioningBehavior(), WTFMove(scrollContainerLayerIDs));
-
-        m_layersWithScrollingRelations.add(positionedLayerNode->layerID());
+        layerNode->setRelatedScrollContainerBehaviorAndIDs(behavior, WTFMove(scrollContainerLayerIDs));
+
+        m_layersWithScrollingRelations.add(layerNode->layerID());
     }
 }