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 1117 matching lines @@
     for (const RenderLayer* curr = compositingContainer(); curr; curr = curr->compositingContainer()) {
         if (curr->compositingState() == PaintsIntoOwnBacking || curr->compositingState() == PaintsIntoGroupedBacking)
             return const_cast<RenderLayer*>(curr);
     }
 
     return 0;
 }
 
 RenderLayer* RenderLayer::ancestorCompositedScrollingLayer() const
 {
-    ASSERT(isAllowedToQueryCompositingState());
+    ASSERT(isInCompositingUpdate());

[Ian Vollick, 2014/03/20 19:26:48]

Changed the assert to enforce access only during comp-update.

 
     if (!renderer()->acceleratedCompositingForOverflowScrollEnabled())
         return 0;
 
+    if (m_ancestorDependentPropertyCache && m_ancestorDependentPropertyCache->containingBlock)
+        return m_ancestorDependentPropertyCache->ancestorCompositedScrollingLayer;

[Ian Vollick, 2014/03/20 19:26:48]

The old code made no use of the containing block. Use it here to avoid
recomputing the CB when the cache is fresh.

+
     RenderObject* containingBlock = renderer()->containingBlock();
     if (!containingBlock)
         return 0;
 
+    const_cast<RenderLayer*>(this)->m_ancestorDependentPropertyCache = adoptPtr(new AncestorDependentPropertyCache());

[abarth-chromium, 2014/03/20 20:04:54]

The pattern we usually use for this is a function called

ensureAncestorDependentPropertyCache()

That does this work.  You can mark m_ancestorDependentPropertyCache mutable to
remove the const_cast.  Then you can put the ASSERT(isInCompositingUpdate())
inside that function.

[Ian Vollick, 2014/03/20 21:32:21]

Done.

+    m_ancestorDependentPropertyCache->containingBlock = containingBlock;
+
+    RenderLayer* ancestorCompositedScrollingLayer = 0;
     for (RenderLayer* ancestorLayer = containingBlock->enclosingLayer(); ancestorLayer; ancestorLayer = ancestorLayer->parent()) {
-        if (ancestorLayer->needsCompositedScrolling())
-            return ancestorLayer;
+        if (ancestorLayer->needsCompositedScrolling()) {
+            ancestorCompositedScrollingLayer = ancestorLayer;
+            break;
+        }
     }
 
-    return 0;
+    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 499 matching lines @@
 
 void RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutRect& rect) const
 {
     LayoutPoint delta;
     convertToLayerCoords(ancestorLayer, delta);
     rect.move(-delta.x(), -delta.y());
 }
 
 RenderLayer* RenderLayer::scrollParent() const
 {
+    ASSERT(isInCompositingUpdate());

[Ian Vollick, 2014/03/20 19:26:48]

Again, enforce that we access scrollParent only during comp-update.

+
     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;
 
     // 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)
+        return m_ancestorDependentPropertyCache->scrollParent;

[abarth-chromium, 2014/03/20 20:04:54]

Isn't it possible for m_ancestorDependentPropertyCache to be created without
scrollParent being populated?  It seems like we need to check something more
here.

[Ian Vollick, 2014/03/20 21:32:21]

It is possible, yes. If we've computed a valid containingBlock, the scrollParent
should also be valid. I've added this check.

+
     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 (AncestorDependentPropertyCache* ancestorCache = ancestor->m_ancestorDependentPropertyCache.get()) {
+            if (ancestorCache->ancestorCompositedScrollingLayer == scrollParent) {
+                scrollParent = ancestorCache->scrollParent;
+                break;
+            }
+        }
     }
 
+    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
+{
+    if (gCompositingQueryMode == CompositingQueriesAreAllowed)
+        return true;

[abarth-chromium, 2014/03/20 20:04:54]

Doesn't this mean these functions could be called while assert disablers are on
the stack?  In that case, the cache could be stale, right?

[Ian Vollick, 2014/03/20 21:32:21]

Removed the ability to disable this. Since scrollParent() is accessed in the
wrong phase due to chicken and egg, I've also updated the code so as not to
memoize unless we're in the correct phase. I've also added ASSERTs to ensure
that if we even have a non-NULL cache, that we're in the comp-update phase.

+    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