Changeset 257920 in webkit

Timestamp:

Mar 5, 2020 9:18:00 AM (4 years ago)

Author:

Simon Fraser

Message:

Track "scrolling scope" on RenderLayers
​https://bugs.webkit.org/show_bug.cgi?id=208620

Reviewed by Zalan Bujtas.

Keep track of a "scrolling scope" on RenderLayers. Layers that share a scrolling scope
get scrolled by some common async-scrollable containing-block ancestor. The scope is just
a unique identifier.

Each layer has two scopes; a "box" scope that applies to the background/borders, and
a "content" scope that applies to (potentially) scrollable content. For most layers,
these will be the same, and shared with the layer's containing block ancestor layer.

For async-scrollable overflow, "box" scope is shared with the cb ancestor, but "content" scope
will have a new value that applies to all the layers moved by that scroller.

Having this value makes it easy to ask the question "is this layer scrolled by some ancestor",
which is a tricky computation for things like a position:absolute layer inside a non-containing block
stacking context overflow:scroll. Also, position:fixed whose containing block is the root will share
the scrolling scope of the root.

No behavior change.

• rendering/RenderLayer.cpp:

(WebCore::nextScrollingScope):
(WebCore::RenderLayer::RenderLayer):
(WebCore::RenderLayer::updateLayerPositions):
(WebCore::RenderLayer::updateLayerPosition):
(WebCore::outputPaintOrderTreeLegend):
(WebCore::outputPaintOrderTreeRecursive):

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

(WebCore::isScrolledByOverflowScrollLayer):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• rendering/RenderLayer.cpp (modified) (6 diffs)
• rendering/RenderLayer.h (modified) (4 diffs)
• rendering/RenderLayerCompositor.cpp (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2020-03-05  Simon Fraser  <simon.fraser@apple.com>
+
+        Track "scrolling scope" on RenderLayers
+        https://bugs.webkit.org/show_bug.cgi?id=208620
+
+        Reviewed by Zalan Bujtas.
+
+        Keep track of a "scrolling scope" on RenderLayers. Layers that share a scrolling scope
+        get scrolled by some common async-scrollable containing-block ancestor. The scope is just
+        a unique identifier.
+        
+        Each layer has two scopes; a "box" scope that applies to the background/borders, and
+        a "content" scope that applies to (potentially) scrollable content. For most layers,
+        these will be the same, and shared with the layer's containing block ancestor layer.
+
+        For async-scrollable overflow, "box" scope is shared with the cb ancestor, but "content" scope
+        will have a new value that applies to all the layers moved by that scroller.
+
+        Having this value makes it easy to ask the question "is this layer scrolled by some ancestor",
+        which is a tricky computation for things like a position:absolute layer inside a non-containing block
+        stacking context overflow:scroll. Also, position:fixed whose containing block is the root will share
+        the scrolling scope of the root.
+
+        No behavior change.
+
+        * rendering/RenderLayer.cpp:
+        (WebCore::nextScrollingScope):
+        (WebCore::RenderLayer::RenderLayer):
+        (WebCore::RenderLayer::updateLayerPositions):
+        (WebCore::RenderLayer::updateLayerPosition):
+        (WebCore::outputPaintOrderTreeLegend):
+        (WebCore::outputPaintOrderTreeRecursive):
+        * rendering/RenderLayer.h:
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::isScrolledByOverflowScrollLayer):
+
 2020-03-05  youenn fablet  <youenn@apple.com>
 

trunk/Source/WebCore/rendering/RenderLayer.cpp

@@ -284 +284 @@
 #endif
 
+static ScrollingScope nextScrollingScope()
+{
+    static ScrollingScope currentScope = 0;
+    return ++currentScope;
+}
+
 DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(RenderLayer);
 
@@ -344 +350 @@
     m_isSelfPaintingLayer = shouldBeSelfPaintingLayer();
 
+    if (isRenderViewLayer())
+        m_boxScrollingScope = m_contentsScrollingScope = nextScrollingScope();
+
     if (!renderer().firstChild()) {
         m_visibleContentStatusDirty = false;
@@ -959 +968 @@
     // Clear our cached clip rect information.
     clearClipRects();
-    
+
     if (hasOverflowControls()) {
         LayoutSize offsetFromRoot;
@@ -1735 +1744 @@
             localPoint -= toLayoutSize(positionedParent->scrollPosition());
         
-        if (renderer().isOutOfFlowPositioned() && positionedParent->renderer().isInFlowPositioned() && is<RenderInline>(positionedParent->renderer())) {
+        if (positionedParent->renderer().isInFlowPositioned() && is<RenderInline>(positionedParent->renderer())) {
             LayoutSize offset = downcast<RenderInline>(positionedParent->renderer()).offsetForInFlowPositionedInline(&downcast<RenderBox>(renderer()));
             localPoint += offset;
         }
-    } else if (parent()) {
-        if (parent()->renderer().hasOverflowClip())
+
+        ASSERT(positionedParent->contentsScrollingScope());
+        m_boxScrollingScope = positionedParent->contentsScrollingScope();
+    } else if (auto* parentLayer = parent()) {
+        if (parentLayer->renderer().hasOverflowClip())
             localPoint -= toLayoutSize(parent()->scrollPosition());
-    }
-    
+
+        ASSERT(parentLayer->contentsScrollingScope());
+        m_boxScrollingScope = parentLayer->contentsScrollingScope();
+    }
+
+    if (hasCompositedScrollableOverflow()) {
+        if (!m_contentsScrollingScope)
+            m_contentsScrollingScope = nextScrollingScope();
+    } else if (!m_contentsScrollingScope)
+        m_contentsScrollingScope = m_boxScrollingScope;
+
     bool positionOrOffsetChanged = false;
     if (renderer().isInFlowPositioned()) {
@@ -7098 +7119 @@
         "Dirty (z)-lists, Dirty (n)ormal flow lists\n"
         "Traversal needs: requirements (t)raversal on descendants, (b)acking or hierarchy traversal on descendants, (r)equirements traversal on all descendants, requirements traversal on all (s)ubsequent layers, (h)ierarchy traversal on all descendants, update of paint (o)rder children\n"
-        "Update needs:    post-(l)ayout requirements, (g)eometry, (k)ids geometry, (c)onfig, layer conne(x)ion, (s)crolling tree\n";
+        "Update needs:    post-(l)ayout requirements, (g)eometry, (k)ids geometry, (c)onfig, layer conne(x)ion, (s)crolling tree\n"
+        "Scrolling scope: box contents\n";
     stream.nextLine();
 }
@@ -7169 +7191 @@
     stream << " ";
 
+    stream << layer.boxScrollingScope();
+    stream << " ";
+    stream << layer.contentsScrollingScope();
+
+    stream << " ";
+
     outputIdent(stream, depth);
 

trunk/Source/WebCore/rendering/RenderLayer.h

@@ -54 +54 @@
 #include "ScrollableArea.h"
 #include <memory>
+#include <wtf/Markable.h>
 #include <wtf/WeakPtr.h>
 
@@ -139 +140 @@
 };
 
+using ScrollingScope = uint64_t;
+
 DECLARE_ALLOCATOR_WITH_HEAP_IDENTIFIER(RenderLayer);
 class RenderLayer final : public ScrollableArea {
@@ -862 +865 @@
     void setHasCompositedScrollingAncestor(bool hasCompositedScrollingAncestor) { m_hasCompositedScrollingAncestor = hasCompositedScrollingAncestor; }
 
+    // Layers with the same ScrollingScope are scrolled by some common ancestor scroller. Used for async scrolling.
+    Optional<ScrollingScope> boxScrollingScope() const { return m_boxScrollingScope; }
+    Optional<ScrollingScope> contentsScrollingScope() const { return m_contentsScrollingScope; }
+
     bool paintsWithTransparency(OptionSet<PaintBehavior> paintBehavior) const
     {
@@ -1322 +1329 @@
     IntPoint m_cachedOverlayScrollbarOffset;
 
+    Markable<ScrollingScope, IntegralMarkableTraits<ScrollingScope, 0>> m_boxScrollingScope;
+    Markable<ScrollingScope, IntegralMarkableTraits<ScrollingScope, 0>> m_contentsScrollingScope;
+
     std::unique_ptr<RenderMarquee> m_marquee; // Used for <marquee>.
     

trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

@@ -3179 +3179 @@
 static bool isScrolledByOverflowScrollLayer(const RenderLayer& layer, const RenderLayer& overflowScrollLayer)
 {
-    bool scrolledByOverflowScroll = false;
-    traverseAncestorLayers(layer, [&](const RenderLayer& ancestorLayer, bool inContainingBlockChain, bool) {
-        if (&ancestorLayer == &overflowScrollLayer) {
-            scrolledByOverflowScroll = inContainingBlockChain;
-            return AncestorTraversal::Stop;
-        }
-        return AncestorTraversal::Continue;
-    });
-    return scrolledByOverflowScroll;
+    return layer.boxScrollingScope() == overflowScrollLayer.contentsScrollingScope();
 }