Avoid tree walks when computing RenderLayer::scrollParent

Source/core/rendering/RenderLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 1115 matching lines @@
         return const_cast<RenderLayer*>(this);
 
     for (const RenderLayer* curr = compositingContainer(); curr; curr = curr->compositingContainer()) {
         if (curr->compositingState() == PaintsIntoOwnBacking || curr->compositingState() == PaintsIntoGroupedBacking)
             return const_cast<RenderLayer*>(curr);
     }
 
     return 0;
 }
 
+void RenderLayer::clearAncestorDependentPropertyCache()
+{
+    ASSERT(isInCompositingUpdate());
+    m_ancestorDependentPropertyCache.clear();
+}
+
+void RenderLayer::ensureAncestorDependentPropertyCache() const
+{
+    ASSERT(isInCompositingUpdate());
+    m_ancestorDependentPropertyCache = adoptPtr(new AncestorDependentPropertyCache());

[abarth-chromium, 2014/03/20 21:36:45]

Should we just return if the cache already exists?  In this version, we'll blow
it away if it already exists.

[Ian Vollick, 2014/03/20 21:57:00]

Done.

+}
+
 RenderLayer* RenderLayer::ancestorCompositedScrollingLayer() const
 {
-    ASSERT(isAllowedToQueryCompositingState());
-
     if (!renderer()->acceleratedCompositingForOverflowScrollEnabled())
         return 0;
 
+    ASSERT(isInCompositingUpdate() || !m_ancestorDependentPropertyCache);
+
+    if (m_ancestorDependentPropertyCache && m_ancestorDependentPropertyCache->containingBlock)
+        return m_ancestorDependentPropertyCache->ancestorCompositedScrollingLayer;
+
     RenderObject* containingBlock = renderer()->containingBlock();
     if (!containingBlock)
         return 0;
 
-    for (RenderLayer* ancestorLayer = containingBlock->enclosingLayer(); ancestorLayer; ancestorLayer = ancestorLayer->parent()) {
-        if (ancestorLayer->needsCompositedScrolling())
-            return ancestorLayer;
+    if (isInCompositingUpdate()) {
+        ensureAncestorDependentPropertyCache();
+        m_ancestorDependentPropertyCache->containingBlock = containingBlock;
     }
 
-    return 0;
+    RenderLayer* ancestorCompositedScrollingLayer = 0;
+    for (RenderLayer* ancestorLayer = containingBlock->enclosingLayer(); ancestorLayer; ancestorLayer = ancestorLayer->parent()) {
+        if (ancestorLayer->needsCompositedScrolling()) {
+            ancestorCompositedScrollingLayer = ancestorLayer;
+            break;
+        }
+    }
+
+    if (m_ancestorDependentPropertyCache)
+        m_ancestorDependentPropertyCache->ancestorCompositedScrollingLayer = ancestorCompositedScrollingLayer;
+    return ancestorCompositedScrollingLayer;
 }
 
 RenderLayer* RenderLayer::ancestorScrollingLayer() const
 {
     RenderObject* containingBlock = renderer()->containingBlock();
     if (!containingBlock)
         return 0;
 
     for (RenderLayer* ancestorLayer = containingBlock->enclosingLayer(); ancestorLayer; ancestorLayer = ancestorLayer->parent()) {
         if (ancestorLayer->scrollsOverflow())
@@ skipping 507 matching lines @@
 RenderLayer* RenderLayer::scrollParent() const
 {
     if (!renderer()->compositorDrivenAcceleratedScrollingEnabled())
         return 0;
 
     // Normal flow elements will be parented under the main scrolling layer, so
     // we don't need a scroll parent/child relationship to get them to scroll.
     if (stackingNode()->isNormalFlowOnly())
         return 0;
 
+    // We should never have an ancestor dependent property cache outside of the
+    // compositing update phase.
+    ASSERT(isInCompositingUpdate() || !m_ancestorDependentPropertyCache);
+
     // A layer scrolls with its containing block. So to find the overflow scrolling layer
     // that we scroll with respect to, we must ascend the layer tree until we reach the
     // first overflow scrolling div at or above our containing block. I will refer to this
     // layer as our 'scrolling ancestor'.
     //
     // Now, if we reside in a normal flow list, then we will naturally scroll with our scrolling
     // ancestor, and we need not be composited. If, on the other hand, we reside in a z-order
     // list, and on our walk upwards to our scrolling ancestor we find no layer that is a stacking
     // context, then we know that in the stacking tree, we will not be in the subtree rooted at
     // our scrolling ancestor, and we will therefore not scroll with it. In this case, we must
     // be a composited layer since the compositor will need to take special measures to ensure
     // that we scroll with our scrolling ancestor and it cannot do this if we do not promote.
+    if (m_ancestorDependentPropertyCache && m_ancestorDependentPropertyCache->containingBlock)

[abarth-chromium, 2014/03/20 21:36:45]

Why is checking for containingBlock correct here?  containingBlock could be
populated in RenderLayer::ancestorCompositedScrollingLayer, which doesn't set
scrollParent...

[Ian Vollick, 2014/03/20 21:57:00]

Oof. It isn't! It was only correct if you call scrollParent before
ancestorCompositedScrollLayer (if you did that, scrollParent would invoke
ancestorCompositedScrollLayer, indirectly creating the cache, and the rest of
the scrollParent function would ensure that the cached scrollParent was corret).
If you called ancestorCompositedScrollLayer first, then this is busted.

I was using containingBlock essentially as a dirty bit, but this is cryptic and
misleading. I've switched this to two, clearly named dirty bits.

Hopefully this time the dirty bit checking is correct. Thanks for catching this.

+        return m_ancestorDependentPropertyCache->scrollParent;
+
     RenderLayer* scrollParent = ancestorCompositedScrollingLayer();
-
     if (!scrollParent || scrollParent->stackingNode()->isStackingContainer())
         return 0;
 
     // If we hit a stacking context on our way up to the ancestor scrolling layer, it will already
     // be composited due to an overflow scrolling parent, so we don't need to.
     for (RenderLayer* ancestor = parent(); ancestor && ancestor != scrollParent; ancestor = ancestor->parent()) {
         if (ancestor->stackingNode()->isStackingContainer())
             return 0;
+        if (!isInCompositingUpdate())
+            continue;
+        if (AncestorDependentPropertyCache* ancestorCache = ancestor->m_ancestorDependentPropertyCache.get()) {
+            if (ancestorCache->ancestorCompositedScrollingLayer == scrollParent) {
+                scrollParent = ancestorCache->scrollParent;
+                break;
+            }
+        }
     }
 
+    if (m_ancestorDependentPropertyCache)
+        m_ancestorDependentPropertyCache->scrollParent = scrollParent;
+
     return scrollParent;
 }
 
 RenderLayer* RenderLayer::clipParent() const
 {
     if (compositingReasons() & CompositingReasonOutOfFlowClipping && !compositor()->clippedByAncestor(this)) {
         if (RenderObject* containingBlock = renderer()->containingBlock())
             return containingBlock->enclosingLayer()->enclosingCompositingLayer();
     }
     return 0;
@@ skipping 1799 matching lines @@
     return PaintsIntoOwnBacking;
 }
 
 bool RenderLayer::isAllowedToQueryCompositingState() const
 {
     if (gCompositingQueryMode == CompositingQueriesAreAllowed)
         return true;
     return renderer()->document().lifecycle().state() >= DocumentLifecycle::InCompositingUpdate;
 }
 
+bool RenderLayer::isInCompositingUpdate() const
+{
+    return renderer()->document().lifecycle().state() == DocumentLifecycle::InCompositingUpdate;
+}
+
 CompositedLayerMappingPtr RenderLayer::compositedLayerMapping() const
 {
     ASSERT(isAllowedToQueryCompositingState());
     return m_compositedLayerMapping.get();
 }
 
 CompositedLayerMappingPtr RenderLayer::ensureCompositedLayerMapping()
 {
     if (!m_compositedLayerMapping) {
         m_compositedLayerMapping = adoptPtr(new CompositedLayerMapping(*this));
@@ skipping 519 matching lines @@
             rects.set(this, rect);
         }
     }
 }
 
 DisableCompositingQueryAsserts::DisableCompositingQueryAsserts()
     : m_disabler(gCompositingQueryMode, CompositingQueriesAreAllowed) { }
 
 COMPILE_ASSERT(1 << RenderLayer::ViewportConstrainedNotCompositedReasonBits >= RenderLayer::NumNotCompositedReasons, too_many_viewport_constrained_not_compositing_reasons);
 
+RenderLayer::AncestorDependentPropertyCache::AncestorDependentPropertyCache()
+    : containingBlock(0)
+    , ancestorCompositedScrollingLayer(0)
+    , scrollParent(0) { }
+
 } // namespace WebCore
 
 #ifndef NDEBUG
 void showLayerTree(const WebCore::RenderLayer* layer)
 {
     if (!layer)
         return;
 
     if (WebCore::LocalFrame* frame = layer->renderer()->frame()) {
         WTF::String output = externalRepresentation(frame, WebCore::RenderAsTextShowAllLayers | WebCore::RenderAsTextShowLayerNesting | WebCore::RenderAsTextShowCompositedLayers | WebCore::RenderAsTextShowAddresses | WebCore::RenderAsTextShowIDAndClass | WebCore::RenderAsTextDontUpdateLayout | WebCore::RenderAsTextShowLayoutState);
         fprintf(stderr, "%s\n", output.utf8().data());
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif