Reduce compositing update in Silk's toggle_drawer by 20%

Source/core/rendering/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 403 matching lines @@
         // position of this layer's GraphicsLayer depends on the position of our compositing
         // ancestor's GraphicsLayer. That cannot be determined until all the descendant
         // RenderLayers of that ancestor have been processed via updateLayerPositions().
         //
         // The solution is to update compositing children of this layer here,
         // via updateCompositingChildrenGeometry().
         updateCompositedBounds();
         layerCompositor->updateCompositingDescendantGeometry(m_owningLayer->stackingNode(), m_owningLayer, flags & CompositingChildrenOnly);
 
         if (flags & IsUpdateRoot) {
-            updateGraphicsLayerGeometry();
+            updateGraphicsLayerGeometry(GraphicsLayerUpdater::ForceUpdate);
             layerCompositor->updateRootLayerPosition();
             RenderLayerStackingNode* stackingContainer = m_owningLayer->stackingNode()->enclosingStackingContainerNode();
             if (!layerCompositor->compositingLayersNeedRebuild() && stackingContainer && (stackingContainer != m_owningLayer->stackingNode()))
                 layerCompositor->updateCompositingDescendantGeometry(stackingContainer, stackingContainer->layer(), flags & CompositingChildrenOnly);
         }
     }
 
     if (flags & NeedsFullRepaint && !paintsIntoCompositedAncestor())
         setContentsNeedDisplay();
 }
@@ skipping 175 matching lines @@
     for (size_t i = 0; i < m_squashedLayers.size(); ++i) {
         m_squashedLayers[i].offsetFromRenderer = IntSize(-m_squashedLayers[i].offsetFromSquashingCLM.width() + totalSquashBounds.x(),
             -m_squashedLayers[i].offsetFromSquashingCLM.height() + totalSquashBounds.y());
 
         // FIXME: find a better design to avoid this redundant value - most likely it will make
         // sense to move the paint task info into RenderLayer's m_compositingProperties.
         m_squashedLayers[i].renderLayer->setOffsetFromSquashingLayerOrigin(m_squashedLayers[i].offsetFromRenderer);
     }
 }
 
-void CompositedLayerMapping::updateGraphicsLayerGeometry()
+GraphicsLayerUpdater::UpdateType CompositedLayerMapping::updateGraphicsLayerGeometry(GraphicsLayerUpdater::UpdateType updateType)
 {
     // If we haven't built z-order lists yet, wait until later.
     if (m_owningLayer->stackingNode()->isStackingContainer() && m_owningLayer->stackingNode()->zOrderListsDirty())
-        return;
+        return updateType;
+
+    if (!m_needToUpdateGeometry && updateType != GraphicsLayerUpdater::ForceUpdate)
+        return updateType;
+    m_needToUpdateGeometry = false;
+    if (m_needToUpdateGeometryOfAllDecendants)
+        updateType = GraphicsLayerUpdater::ForceUpdate;
 
     // Set transform property, if it is not animating. We have to do this here because the transform
     // is affected by the layer dimensions.
     if (!hasActiveAnimationsOnCompositor(*renderer(), CSSPropertyWebkitTransform))
         updateTransform(renderer()->style());
 
     // Set opacity, if it is not animating.
     if (!hasActiveAnimationsOnCompositor(*renderer(), CSSPropertyOpacity))
         updateOpacity(renderer()->style());
 
@@ skipping 141 matching lines @@
         m_backgroundLayer->setPosition(FloatPoint());
         if (backgroundSize != m_backgroundLayer->size()) {
             m_backgroundLayer->setSize(backgroundSize);
             m_backgroundLayer->setNeedsDisplay();
         }
         m_backgroundLayer->setOffsetFromRenderer(m_graphicsLayer->offsetFromRenderer());
     }
 
     if (m_owningLayer->reflectionInfo() && m_owningLayer->reflectionInfo()->reflectionLayer()->hasCompositedLayerMapping()) {
         CompositedLayerMappingPtr reflectionCompositedLayerMapping = m_owningLayer->reflectionInfo()->reflectionLayer()->compositedLayerMapping();
-        reflectionCompositedLayerMapping->updateGraphicsLayerGeometry();
+        reflectionCompositedLayerMapping->updateGraphicsLayerGeometry(GraphicsLayerUpdater::ForceUpdate);
 
         // The reflection layer has the bounds of m_owningLayer->reflectionLayer(),
         // but the reflected layer is the bounds of this layer, so we need to position it appropriately.
         FloatRect layerBounds = compositedBounds();
         FloatRect reflectionLayerBounds = reflectionCompositedLayerMapping->compositedBounds();
         reflectionCompositedLayerMapping->mainGraphicsLayer()->setReplicatedLayerPosition(FloatPoint(layerBounds.location() - reflectionLayerBounds.location()));
     }
 
     if (m_scrollingLayer) {
         ASSERT(m_scrollingContentsLayer);
@@ skipping 58 matching lines @@
     updateBackgroundColor(isSimpleContainer);
     updateDrawsContent(isSimpleContainer);
     updateContentsOpaque();
     updateAfterWidgetResize();
     updateRenderingContext();
     updateShouldFlattenTransform();
     updateChildrenTransform();
     registerScrollingLayers();
 
     updateCompositingReasons();
+
+    return updateType;
 }
 
 void CompositedLayerMapping::registerScrollingLayers()
 {
     // Register fixed position layers and their containers with the scrolling coordinator.
     ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(m_owningLayer);
     if (!scrollingCoordinator)
         return;
 
     compositor()->updateViewportConstraintStatus(m_owningLayer);
@@ skipping 967 matching lines @@
 void CompositedLayerMapping::setBlendMode(blink::WebBlendMode blendMode)
 {
     if (m_ancestorClippingLayer) {
         m_ancestorClippingLayer->setBlendMode(blendMode);
         m_graphicsLayer->setBlendMode(blink::WebBlendModeNormal);
     } else {
         m_graphicsLayer->setBlendMode(blendMode);
     }
 }
 
+void CompositedLayerMapping::setNeedsGeometryUpdate()
+{
+    m_needToUpdateGeometryOfAllDecendants = true;
+
+    for (RenderLayer* current = m_owningLayer; current; current = current->ancestorCompositingLayer()) {
+        // FIXME: We should be able to return early from this function once we
+        // find a CompositedLayerMapping that has m_needToUpdateGeometry set.
+        // However, we can't do that until we remove the incremental compositing
+        // updates because they can clear m_needToUpdateGeometry without walking
+        // the whole tree.
+        ASSERT(current->hasCompositedLayerMapping());
+        CompositedLayerMappingPtr mapping = current->compositedLayerMapping();
+        mapping->m_needToUpdateGeometry = true;
+    }
+}
+
+void CompositedLayerMapping::clearNeedsGeometryUpdate()
+{
+    m_needToUpdateGeometry = false;
+    m_needToUpdateGeometryOfAllDecendants = false;
+}
+
 struct SetContentsNeedsDisplayFunctor {
     void operator() (GraphicsLayer* layer) const
     {
         if (layer->drawsContent())
             layer->setNeedsDisplay();
     }
 };
 
 void CompositedLayerMapping::setContentsNeedDisplay()
 {
@@ skipping 295 matching lines @@
     } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
         name = "Scrolling Contents Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore