Reduce compositing update in Silk's toggle_drawer by 20%

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 692 matching lines @@
     }
 }
 
 void RenderLayer::setHasVisibleContent()
 {
     if (m_hasVisibleContent && !m_visibleContentStatusDirty) {
         ASSERT(!parent() || parent()->hasVisibleDescendant());
         return;
     }
 
+    m_hasVisibleContent = true;
     m_visibleContentStatusDirty = false;
-    m_hasVisibleContent = true;
+
+    {
+        DisableCompositingQueryAsserts disabler;

[ojan, 2014/03/05 18:29:51]

Are there tests that you know hit this? It'd be nice to have a comment pointing
to one for the person who tries to fix this.

Also, should there be a FIXME here since you say this can be removed once we
untangle the recursive tree walk inside updateGraphicsLayerGeometry.?

[abarth-chromium, 2014/03/05 23:12:19]

I haven't tried, but I'm sure it's hit by many tests.
Will do.

+        if (RenderLayer* compositingLayer = enclosingCompositingLayer())
+            compositingLayer->compositedLayerMapping()->setNeedsGeometryUpdate();
+    }
+
     repainter().computeRepaintRects(renderer()->containerForRepaint());
     if (!m_stackingNode->isNormalFlowOnly()) {
         // We don't collect invisible layers in z-order lists if we are not in compositing mode.
         // As we became visible, we need to dirty our stacking containers ancestors to be properly
         // collected. FIXME: When compositing, we could skip this dirtying phase.
         for (RenderLayerStackingNode* sc = m_stackingNode->ancestorStackingContainerNode(); sc; sc = sc->ancestorStackingContainerNode()) {
             sc->dirtyZOrderLists();
             if (sc->layer()->hasVisibleContent())
                 break;
         }
@@ skipping 143 matching lines @@
                         r = r->parent();
                         if (r == renderer())
                             r = 0;
                     } while (r && !r->nextSibling());
                     if (r)
                         r = r->nextSibling();
                 }
             }
         }
         m_visibleContentStatusDirty = false;
+
+        DisableCompositingQueryAsserts disabler;
+        if (RenderLayer* compositingLayer = enclosingCompositingLayer())
+            compositingLayer->compositedLayerMapping()->setNeedsGeometryUpdate();

[ojan, 2014/03/05 18:29:51]

Technically, you only need to do this if m_hasVisibleContent changed values,
right?

[abarth-chromium, 2014/03/05 23:12:19]

That's right.  I'll add that branch.

     }
 }
 
 void RenderLayer::dirty3DTransformedDescendantStatus()
 {
     RenderLayerStackingNode* stackingNode = m_stackingNode->ancestorStackingContainerNode();
     if (!stackingNode)
         return;
 
     stackingNode->layer()->m_3DTransformedDescendantStatusDirty = true;
@@ skipping 2612 matching lines @@
 CompositedLayerMappingPtr RenderLayer::compositedLayerMapping() const
 {
     ASSERT(isAllowedToQueryCompositingState());
     return m_compositedLayerMapping.get();
 }
 
 CompositedLayerMappingPtr RenderLayer::ensureCompositedLayerMapping()
 {
     if (!m_compositedLayerMapping) {
         m_compositedLayerMapping = adoptPtr(new CompositedLayerMapping(this));
+        m_compositedLayerMapping->setNeedsGeometryUpdate();
 
         updateOrRemoveFilterEffectRenderer();
 
         if (RuntimeEnabledFeatures::cssCompositingEnabled())
             compositedLayerMapping()->setBlendMode(m_blendInfo.blendMode());
     }
     return m_compositedLayerMapping.get();
 }
 
 void RenderLayer::clearCompositedLayerMapping(bool layerBeingDestroyed)
 {
+    if (!layerBeingDestroyed)
+        m_compositedLayerMapping->setNeedsGeometryUpdate();
+
     m_compositedLayerMapping.clear();
 
     if (!layerBeingDestroyed)
         updateOrRemoveFilterEffectRenderer();
 }
 
 bool RenderLayer::hasCompositedMask() const
 {
     return m_compositedLayerMapping && m_compositedLayerMapping->hasMaskLayer();
 }
@@ skipping 335 matching lines @@
         DisableCompositingQueryAsserts disabler;
         if (paintsWithFilters())
             didPaintWithFilters = true;
         updateFilters(oldStyle, renderer()->style());
     }
 
     // FIXME: Remove incremental compositing updates after fixing the chicken/egg issues
     // https://code.google.com/p/chromium/issues/detail?id=343756
     DisableCompositingQueryAsserts disabler;
 
+    if (RenderLayer* compositingLayer = enclosingCompositingLayer())
+        compositingLayer->compositedLayerMapping()->setNeedsGeometryUpdate();
+
     const RenderStyle* newStyle = renderer()->style();
 
     compositor()->updateLayerCompositingState(this, RenderLayerCompositor::UseChickenEggHacks);
     // FIXME: this compositing logic should be pushed into the compositing code, not here.
     if (needsCompositingLayersRebuiltForClip(oldStyle, newStyle)
         || needsCompositingLayersRebuiltForOverflow(oldStyle, newStyle)
         || needsCompositingLayersRebuiltForFilters(oldStyle, newStyle, didPaintWithFilters)
         || needsCompositingLayersRebuiltForBlending(oldStyle, newStyle)) {
         compositor()->setCompositingLayersNeedRebuild();
     }
@@ skipping 148 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif