Changeset 213435 in webkit

Timestamp:

Mar 5, 2017, 11:14:12 AM (9 years ago)

Author:

Simon Fraser

Message:

Make some RenderLayer tree traversal in RenderLayerBacking more generic
​https://bugs.webkit.org/show_bug.cgi?id=169177

Reviewed by Zalan Bujtas.

The real goal of this patch is reduce the number of callers of
RenderLayerBacking::isPaintDestinationForDescendantLayers() to one. To achieve that,
have the setContentsVisible() logic (which is really just about the CSS 'visibility' property)
do its own tree traversal which just consults layer.hasVisibleContent(). So
make descendantLayerPaintsIntoAncestor() a generic traversal function which walks
descendant layers which may paint into the target layer. The "Visible" in the name
reflects the fact that it can bypass a subtree for a layer with !hasVisibleDescendant().

• rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::updateAfterDescendants):
(WebCore::traverseVisibleNonCompositedDescendantLayers):
(WebCore::RenderLayerBacking::isPaintDestinationForDescendantLayers):
(WebCore::RenderLayerBacking::hasVisibleNonCompositedDescendants):
(WebCore::descendantLayerPaintsIntoAncestor): Deleted.

• rendering/RenderLayerBacking.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• rendering/RenderLayerBacking.cpp (modified) (6 diffs)
• rendering/RenderLayerBacking.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2017-03-05  Simon Fraser  <simon.fraser@apple.com>
+
+        Make some RenderLayer tree traversal in RenderLayerBacking more generic
+        https://bugs.webkit.org/show_bug.cgi?id=169177
+
+        Reviewed by Zalan Bujtas.
+
+        The real goal of this patch is reduce the number of callers of
+        RenderLayerBacking::isPaintDestinationForDescendantLayers() to one. To achieve that,
+        have the setContentsVisible() logic (which is really just about the CSS 'visibility' property)
+        do its own tree traversal which just consults layer.hasVisibleContent(). So
+        make descendantLayerPaintsIntoAncestor() a generic traversal function which walks
+        descendant layers which may paint into the target layer. The "Visible" in the name
+        reflects the fact that it can bypass a subtree for a layer with !hasVisibleDescendant().
+
+        * rendering/RenderLayerBacking.cpp:
+        (WebCore::RenderLayerBacking::updateAfterDescendants):
+        (WebCore::traverseVisibleNonCompositedDescendantLayers):
+        (WebCore::RenderLayerBacking::isPaintDestinationForDescendantLayers):
+        (WebCore::RenderLayerBacking::hasVisibleNonCompositedDescendants):
+        (WebCore::descendantLayerPaintsIntoAncestor): Deleted.
+        * rendering/RenderLayerBacking.h:
+
 2017-03-04  Simon Fraser  <simon.fraser@apple.com>
 

trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

@@ -1105 +1105 @@
     updateDrawsContent(isSimpleContainer);
 
-    m_graphicsLayer->setContentsVisible(m_owningLayer.hasVisibleContent() || isPaintDestinationForDescendantLayers());
+    m_graphicsLayer->setContentsVisible(m_owningLayer.hasVisibleContent() || hasVisibleNonCompositedDescendants());
     if (m_scrollingLayer) {
         m_scrollingLayer->setContentsVisible(renderer().style().visibility() == VISIBLE);
@@ -1949 +1949 @@
 }
 
-static bool descendantLayerPaintsIntoAncestor(RenderLayer& parent)
+enum class LayerTraversal { Continue, Stop };
+
+static LayerTraversal traverseVisibleNonCompositedDescendantLayers(RenderLayer& parent, std::function<LayerTraversal (const RenderLayer&)> layerFunc)
 {
     // FIXME: We shouldn't be called with a stale z-order lists. See bug 85512.
@@ -1960 +1962 @@
     if (auto* normalFlowList = parent.normalFlowList()) {
         for (auto* childLayer : *normalFlowList) {
-            if (!compositedWithOwnBackingStore(*childLayer) && (childLayer->isVisuallyNonEmpty() || descendantLayerPaintsIntoAncestor(*childLayer)))
-                return true;
+            if (compositedWithOwnBackingStore(*childLayer))
+                continue;
+
+            if (layerFunc(*childLayer) == LayerTraversal::Stop)
+                return LayerTraversal::Stop;
+            
+            if (traverseVisibleNonCompositedDescendantLayers(*childLayer, layerFunc) == LayerTraversal::Stop)
+                return LayerTraversal::Stop;
         }
     }
@@ -1967 +1975 @@
     if (parent.isStackingContainer()) {
         if (!parent.hasVisibleDescendant())
-            return false;
+            return LayerTraversal::Continue;
 
         // Use the m_hasCompositingDescendant bit to optimize?
         if (auto* negZOrderList = parent.negZOrderList()) {
             for (auto* childLayer : *negZOrderList) {
-                if (!compositedWithOwnBackingStore(*childLayer) && (childLayer->isVisuallyNonEmpty() || descendantLayerPaintsIntoAncestor(*childLayer)))
-                    return true;
+                if (compositedWithOwnBackingStore(*childLayer))
+                    continue;
+
+                if (layerFunc(*childLayer) == LayerTraversal::Stop)
+                    return LayerTraversal::Stop;
+
+                if (traverseVisibleNonCompositedDescendantLayers(*childLayer, layerFunc) == LayerTraversal::Stop)
+                    return LayerTraversal::Stop;
             }
         }
@@ -1979 +1993 @@
         if (auto* posZOrderList = parent.posZOrderList()) {
             for (auto* childLayer : *posZOrderList) {
-                if (!compositedWithOwnBackingStore(*childLayer) && (childLayer->isVisuallyNonEmpty() || descendantLayerPaintsIntoAncestor(*childLayer)))
-                    return true;
+                if (compositedWithOwnBackingStore(*childLayer))
+                    continue;
+
+                if (layerFunc(*childLayer) == LayerTraversal::Stop)
+                    return LayerTraversal::Stop;
+
+                if (traverseVisibleNonCompositedDescendantLayers(*childLayer, layerFunc) == LayerTraversal::Stop)
+                    return LayerTraversal::Stop;
             }
         }
     }
 
-    return false;
+    return LayerTraversal::Continue;
 }
 
@@ -1991 +2011 @@
 bool RenderLayerBacking::isPaintDestinationForDescendantLayers() const
 {
-    return descendantLayerPaintsIntoAncestor(m_owningLayer);
+    bool hasPaintingDescendant = false;
+    traverseVisibleNonCompositedDescendantLayers(m_owningLayer, [&hasPaintingDescendant](const RenderLayer& layer) {
+        hasPaintingDescendant = layer.isVisuallyNonEmpty();
+        return hasPaintingDescendant ? LayerTraversal::Stop : LayerTraversal::Continue;
+    });
+
+    return hasPaintingDescendant;
+}
+
+bool RenderLayerBacking::hasVisibleNonCompositedDescendants() const
+{
+    bool hasVisibleDescendant = false;
+    traverseVisibleNonCompositedDescendantLayers(m_owningLayer, [&hasVisibleDescendant](const RenderLayer& layer) {
+        hasVisibleDescendant = layer.hasVisibleContent();
+        return hasVisibleDescendant ? LayerTraversal::Stop : LayerTraversal::Continue;
+    });
+
+    return hasVisibleDescendant;
 }
 

trunk/Source/WebCore/rendering/RenderLayerBacking.h

@@ -330 +330 @@
 
     bool isPaintDestinationForDescendantLayers() const;
+    bool hasVisibleNonCompositedDescendants() const;
 
     bool shouldClipCompositedBounds() const;