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());
+    if (m_ancestorDependentPropertyCache)
+        return;
+    m_ancestorDependentPropertyCache = adoptPtr(new AncestorDependentPropertyCache());
+}
+
 RenderLayer* RenderLayer::ancestorCompositedScrollingLayer() const
 {
-    ASSERT(isAllowedToQueryCompositingState());
-
     if (!renderer()->acceleratedCompositingForOverflowScrollEnabled())
         return 0;
 
+    ASSERT(isInCompositingUpdate() || !m_ancestorDependentPropertyCache);
+
+    if (m_ancestorDependentPropertyCache && !m_ancestorDependentPropertyCache->ancestorCompositedScrollingLayerDirty())
+        return m_ancestorDependentPropertyCache->ancestorCompositedScrollingLayer();
+
     RenderObject* containingBlock = renderer()->containingBlock();
     if (!containingBlock)
         return 0;
 
+    if (isInCompositingUpdate())
+        ensureAncestorDependentPropertyCache();
+
+    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;
+    if (m_ancestorDependentPropertyCache)
+        m_ancestorDependentPropertyCache->setAncestorCompositedScrollingLayer(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->scrollParentDirty())
+        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->ancestorCompositedScrollingLayerDirty() && ancestorCache->ancestorCompositedScrollingLayer() == scrollParent) {
+                scrollParent = ancestorCache->scrollParent();
+                break;
+            }
+        }
     }
 
+    if (m_ancestorDependentPropertyCache)
+        m_ancestorDependentPropertyCache->setScrollParent(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()
+    : m_ancestorCompositedScrollingLayer(0)
+    , m_scrollParent(0)
+    , m_ancestorCompositedScrollingLayerDirty(true)
+    , m_scrollParentDirty(true) { }
+
+RenderLayer* RenderLayer::AncestorDependentPropertyCache::scrollParent() const
+{
+    ASSERT(!m_scrollParentDirty);
+    return m_scrollParent;
+}
+
+void RenderLayer::AncestorDependentPropertyCache::setScrollParent(RenderLayer* scrollParent)
+{
+    m_scrollParent = scrollParent;
+    m_scrollParentDirty = false;
+}
+
+RenderLayer* RenderLayer::AncestorDependentPropertyCache::ancestorCompositedScrollingLayer() const
+{
+    ASSERT(!m_ancestorCompositedScrollingLayerDirty);
+    return m_ancestorCompositedScrollingLayer;
+}
+
+void RenderLayer::AncestorDependentPropertyCache::setAncestorCompositedScrollingLayer(RenderLayer* layer)
+{
+    m_ancestorCompositedScrollingLayer = layer;
+    m_ancestorCompositedScrollingLayerDirty = false;
+}
+
 } // 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