Defer the real work in updateCompositingLayers until it's really needed.

Source/core/rendering/RenderLayerCompositor.cpp

 /*
  * Copyright (C) 2009, 2010 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 206 matching lines @@
     return false;
 #endif
 }
 
 RenderLayerCompositor::RenderLayerCompositor(RenderView* renderView)
     : m_renderView(renderView)
     , m_hasAcceleratedCompositing(true)
     , m_compositingTriggers(static_cast<ChromeClient::CompositingTriggerFlags>(ChromeClient::AllTriggers))
     , m_compositedLayerCount(0)
     , m_showRepaintCounter(false)
-    , m_reevaluateCompositingAfterLayout(false)
+    , m_needsToRecomputeCompositingRequirements(false)
+    , m_needsToUpdateLayerTreeGeometry(false)
     , m_compositing(false)
     , m_compositingLayersNeedRebuild(false)
     , m_forceCompositingMode(false)
     , m_inPostLayoutUpdate(false)
     , m_needsUpdateCompositingRequirementsState(false)
     , m_isTrackingRepaints(false)
     , m_rootLayerAttachment(RootLayerUnattached)
 #if !LOG_DISABLED
     , m_rootLayerUpdateCount(0)
     , m_obligateCompositedLayerCount(0)
@@ skipping 125 matching lines @@
         fullscreenElement = FullscreenElementStack::currentFullScreenElementFrom(document);
     }
     if (!fullscreenElement || !isHTMLVideoElement(fullscreenElement))
         return 0;
     RenderObject* renderer = fullscreenElement->renderer();
     if (!renderer)
         return 0;
     return toRenderVideo(renderer);
 }
 
+void RenderLayerCompositor::finishCompositingUpdateForFrameTree(Frame* frame)
+{
+    for (Frame* child = frame->tree()->firstChild(); child; child = child->tree()->nextSibling())
+        finishCompositingUpdateForFrameTree(child);
+
+    // Update compositing for current frame after all descedant frames are updated.
+    if (frame && frame->contentRenderer()) {
+        RenderLayerCompositor* frameCompositor = frame->contentRenderer()->compositor();
+        if (frameCompositor && !frameCompositor->isMainFrame())
+            frame->contentRenderer()->compositor()->updateCompositingLayers(CompositingUpdateFinishAllDeferredWork);
+    }
+}
+
 void RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType updateType, RenderLayer* updateRoot)
 {
     // Avoid updating the layers with old values. Compositing layers will be updated after the layout is finished.
     if (m_renderView->needsLayout())
         return;
 
     if (m_forceCompositingMode && !m_compositing)
         enableCompositingMode(true);
 
-    if (!m_reevaluateCompositingAfterLayout && !m_compositing)
+    if (!m_needsToRecomputeCompositingRequirements && !m_compositing)
         return;
 
     AnimationUpdateBlock animationUpdateBlock(m_renderView->frameView()->frame().animation());
 
     TemporaryChange<bool> postLayoutChange(m_inPostLayoutUpdate, true);
 
-    bool checkForHierarchyUpdate = m_reevaluateCompositingAfterLayout;
+    bool needCompositingRequirementsUpdate = false;
+    bool needHierarchyAndGeometryUpdate = false;
     bool needGeometryUpdate = false;
 
+    // CompositingUpdateFinishAllDeferredWork is the only updateType that will actually do any work in this
+    // function. All other updateTypes will simply mark that something needed updating, and defer the actual
+    // update. This way we only need to compute all compositing state once for every frame drawn (if needed).
     switch (updateType) {
     case CompositingUpdateAfterStyleChange:
     case CompositingUpdateAfterLayout:
-        checkForHierarchyUpdate = true;
+        m_needsToRecomputeCompositingRequirements = true;
         break;
     case CompositingUpdateOnScroll:
-        checkForHierarchyUpdate = true; // Overlap can change with scrolling, so need to check for hierarchy updates.
-        needGeometryUpdate = true;
+        m_needsToRecomputeCompositingRequirements = true; // Overlap can change with scrolling, so need to check for hierarchy updates.
+        m_needsToUpdateLayerTreeGeometry = true;
         break;
     case CompositingUpdateOnCompositedScroll:
-        needGeometryUpdate = true;
+        m_needsToUpdateLayerTreeGeometry = true;
+        break;
+    case CompositingUpdateFinishAllDeferredWork:
+        needCompositingRequirementsUpdate = m_needsToRecomputeCompositingRequirements;
+        needHierarchyAndGeometryUpdate = m_compositingLayersNeedRebuild;
+        needGeometryUpdate = m_needsToUpdateLayerTreeGeometry;
         break;
     }
 
-    if (!checkForHierarchyUpdate && !needGeometryUpdate)
+    if (!needCompositingRequirementsUpdate && !needHierarchyAndGeometryUpdate && !needGeometryUpdate)
         return;
 
-    bool needHierarchyUpdate = m_compositingLayersNeedRebuild;
+    ASSERT(updateType == CompositingUpdateFinishAllDeferredWork);
+
+    if (isMainFrame() && m_renderView->frameView())
+        finishCompositingUpdateForFrameTree(&m_renderView->frameView()->frame());

[shawnsingh, 2013/10/17 03:29:56]

I debugged some more and determined that this needs to happen earlier in this
function, before a few of the early exits.  Otherwise the parent compositor may
never realize that it needed updating due to a descendant iframe compositor.

+
     bool isFullUpdate = !updateRoot;
 
-    // Only clear the flag if we're updating the entire hierarchy.
+    // Only clear the flags if we're updating the entire hierarchy.
     m_compositingLayersNeedRebuild = false;
+    m_needsToUpdateLayerTreeGeometry = false;
     updateRoot = rootRenderLayer();
 
-    if (isFullUpdate && updateType == CompositingUpdateAfterLayout)
-        m_reevaluateCompositingAfterLayout = false;
+    if (isFullUpdate)
+        m_needsToRecomputeCompositingRequirements = false;
 
 #if !LOG_DISABLED
     double startTime = 0;
     if (compositingLogEnabled()) {
         ++m_rootLayerUpdateCount;
         startTime = currentTime();
     }
 #endif
 
-    if (checkForHierarchyUpdate) {
+    if (needCompositingRequirementsUpdate) {
         // Go through the layers in presentation order, so that we can compute which RenderLayers need compositing layers.
         // FIXME: we could maybe do this and the hierarchy udpate in one pass, but the parenting logic would be more complex.
         CompositingRecursionData recursionData(updateRoot, true);
         bool layersChanged = false;
         bool saw3DTransform = false;
         {
             TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::computeCompositingRequirements");
             OverlapMap overlapTestRequestMap;
 
             // FIXME: Passing these unclippedDescendants down and keeping track
             // of them dynamically, we are requiring a full tree walk. This
             // should be removed as soon as proper overlap testing based on
             // scrolling and animation bounds is implemented (crbug.com/252472).
             Vector<RenderLayer*> unclippedDescendants;
             computeCompositingRequirements(0, updateRoot, &overlapTestRequestMap, recursionData, layersChanged, saw3DTransform, unclippedDescendants);
         }
-        needHierarchyUpdate |= layersChanged;
+        needHierarchyAndGeometryUpdate |= layersChanged;
     }
 
 #if !LOG_DISABLED
-    if (compositingLogEnabled() && isFullUpdate && (needHierarchyUpdate || needGeometryUpdate)) {
+    if (compositingLogEnabled() && isFullUpdate && (needHierarchyAndGeometryUpdate || needGeometryUpdate)) {
         m_obligateCompositedLayerCount = 0;
         m_secondaryCompositedLayerCount = 0;
         m_obligatoryBackingStoreBytes = 0;
         m_secondaryBackingStoreBytes = 0;
 
         Frame& frame = m_renderView->frameView()->frame();
         LOG(Compositing, "\nUpdate %d of %s.\n", m_rootLayerUpdateCount, isMainFrame() ? "main frame" : frame.tree()->uniqueName().string().utf8().data());
     }
 #endif
 
-    if (needHierarchyUpdate) {
+    if (needHierarchyAndGeometryUpdate) {
         // Update the hierarchy of the compositing layers.
         Vector<GraphicsLayer*> childList;
         {
             TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::rebuildCompositingLayerTree");
             rebuildCompositingLayerTree(updateRoot, childList, 0);
         }
 
         // Host the document layer in the RenderView's root layer.
         if (isFullUpdate) {
             if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled() && isMainFrame()) {
@@ skipping 13 matching lines @@
             else
                 m_rootContentLayer->setChildren(childList);
         }
     } else if (needGeometryUpdate) {
         // We just need to do a geometry update. This is only used for position:fixed scrolling;
         // most of the time, geometry is updated via RenderLayer::styleChanged().
         updateLayerTreeGeometry(updateRoot, 0);
     }
 
 #if !LOG_DISABLED
-    if (compositingLogEnabled() && isFullUpdate && (needHierarchyUpdate || needGeometryUpdate)) {
+    if (compositingLogEnabled() && isFullUpdate && (needHierarchyAndGeometryUpdate || needGeometryUpdate)) {
         double endTime = currentTime();
         LOG(Compositing, "Total layers   primary   secondary   obligatory backing (KB)   secondary backing(KB)   total backing (KB)  update time (ms)\n");
 
         LOG(Compositing, "%8d %11d %9d %20.2f %22.2f %22.2f %18.2f\n",
             m_obligateCompositedLayerCount + m_secondaryCompositedLayerCount, m_obligateCompositedLayerCount,
             m_secondaryCompositedLayerCount, m_obligatoryBackingStoreBytes / 1024, m_secondaryBackingStoreBytes / 1024, (m_obligatoryBackingStoreBytes + m_secondaryBackingStoreBytes) / 1024, 1000.0 * (endTime - startTime));
     }
 #endif
     ASSERT(updateRoot || !m_compositingLayersNeedRebuild);
 
@@ skipping 622 matching lines @@
 
         if (!layer->parent())
             updateRootLayerPosition();
 
 #if !LOG_DISABLED
         logLayerInfo(layer, depth);
 #else
         UNUSED_PARAM(depth);
 #endif
         if (currentCompositedLayerMapping->hasUnpositionedOverflowControlsLayers())
-            layer->positionNewlyCreatedOverflowControls();
+            layer->positionOverflowControls();
 
         pixelsWithoutPromotingAllTransitions += layer->size().height() * layer->size().width();
     } else {
         if ((layer->renderer()->style()->transitionForProperty(CSSPropertyOpacity) ||
              layer->renderer()->style()->transitionForProperty(CSSPropertyWebkitTransform)) &&
             m_renderView->viewRect().intersects(layer->absoluteBoundingBox()))
             pixelsAddedByPromotingAllTransitions += layer->size().height() * layer->size().width();
     }
 
     // If this layer has a compositedLayerMapping, then that is where we place subsequent children GraphicsLayers.
@@ skipping 169 matching lines @@
 
 bool RenderLayerCompositor::scrollingLayerDidChange(RenderLayer* layer)
 {
     if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
         return scrollingCoordinator->scrollableAreaScrollLayerDidChange(layer->scrollableArea());
     return false;
 }
 
 String RenderLayerCompositor::layerTreeAsText(LayerTreeFlags flags)
 {
-    updateCompositingLayers(CompositingUpdateAfterLayout);
+    // Before dumping the layer tree, finish any pending compositing update.
+    updateCompositingLayers(CompositingUpdateFinishAllDeferredWork);
 
     if (!m_rootContentLayer)
         return String();
 
     // We skip dumping the scroll and clip layers to keep layerTreeAsText output
     // similar between platforms (unless we explicitly request dumping from the
     // root.
     GraphicsLayer* rootLayer = m_rootContentLayer.get();
     if (flags & LayerTreeIncludesRootLayer)
         rootLayer = rootGraphicsLayer();
@@ skipping 579 matching lines @@
 
 bool RenderLayerCompositor::requiresCompositingForPlugin(RenderObject* renderer) const
 {
     if (!(m_compositingTriggers & ChromeClient::PluginTrigger))
         return false;
 
     bool composite = renderer->isEmbeddedObject() && toRenderEmbeddedObject(renderer)->allowsAcceleratedCompositing();
     if (!composite)
         return false;
 
-    m_reevaluateCompositingAfterLayout = true;
+    // FIXME: this seems bogus. If we don't know the layout position/size of the plugin yet, would't that be handled elsewhere?
+    m_needsToRecomputeCompositingRequirements = true;
 
     RenderWidget* pluginRenderer = toRenderWidget(renderer);
     // If we can't reliably know the size of the plugin yet, don't change compositing state.
     if (pluginRenderer->needsLayout())
         return pluginRenderer->hasLayer() && pluginRenderer->layer()->isComposited();
 
     // Don't go into compositing mode if height or width are zero, or size is 1x1.
     IntRect contentBox = pixelSnappedIntRect(pluginRenderer->contentBoxRect());
     return contentBox.height() * contentBox.width() > 1;
 }
 
 bool RenderLayerCompositor::requiresCompositingForFrame(RenderObject* renderer) const
 {
     if (!renderer->isRenderPart())
         return false;
 
     RenderPart* frameRenderer = toRenderPart(renderer);
 
     if (!frameRenderer->requiresAcceleratedCompositing())
         return false;
 
-    m_reevaluateCompositingAfterLayout = true;
+    // FIXME: this seems bogus. If we don't know the layout position/size of the frame yet, wouldn't that be handled elsehwere?
+    m_needsToRecomputeCompositingRequirements = true;
 
     RenderLayerCompositor* innerCompositor = frameContentsCompositor(frameRenderer);
     if (!innerCompositor)
         return false;
 
     // If we can't reliably know the size of the iframe yet, don't change compositing state.
     if (renderer->needsLayout())
         return frameRenderer->hasLayer() && frameRenderer->layer()->isComposited();
 
     // Don't go into compositing mode if height or width are zero.
@@ skipping 121 matching lines @@
         if (!settings->acceleratedCompositingForFixedPositionEnabled())
             return false;
     }
 
     if (isSticky)
         return true;
 
     RenderObject* container = renderer->container();
     // If the renderer is not hooked up yet then we have to wait until it is.
     if (!container) {
-        m_reevaluateCompositingAfterLayout = true;
+        m_needsToRecomputeCompositingRequirements = true;
         return false;
     }
 
     // Don't promote fixed position elements that are descendants of a non-view container, e.g. transformed elements.
     // They will stay fixed wrt the container rather than the enclosing frame.
     if (container != m_renderView) {
         if (viewportConstrainedNotCompositedReason)
             *viewportConstrainedNotCompositedReason = RenderLayer::NotCompositedForNonViewContainer;
         return false;
     }
@@ skipping 19 matching lines @@
     }
 
     if (!hasScrollableAncestor) {
         if (viewportConstrainedNotCompositedReason)
             *viewportConstrainedNotCompositedReason = RenderLayer::NotCompositedForUnscrollableAncestors;
         return false;
     }
 
     // Subsequent tests depend on layout. If we can't tell now, just keep things the way they are until layout is done.
     if (!m_inPostLayoutUpdate) {
-        m_reevaluateCompositingAfterLayout = true;
+        m_needsToRecomputeCompositingRequirements = true;
         return layer->isComposited();
     }
 
     bool paintsContent = layer->isVisuallyNonEmpty() || layer->hasVisibleDescendant();
     if (!paintsContent) {
         if (viewportConstrainedNotCompositedReason)
             *viewportConstrainedNotCompositedReason = RenderLayer::NotCompositedForNoVisibleContent;
         return false;
     }
 
     // Fixed position elements that are invisible in the current view don't get their own layer.
     if (FrameView* frameView = m_renderView->frameView()) {
         LayoutRect viewBounds = frameView->viewportConstrainedVisibleContentRect();
         LayoutRect layerBounds = layer->calculateLayerBounds(rootRenderLayer(), 0, RenderLayer::DefaultCalculateLayerBoundsFlags
             | RenderLayer::ExcludeHiddenDescendants | RenderLayer::DontConstrainForMask | RenderLayer::IncludeCompositedDescendants);
         if (!viewBounds.intersects(enclosingIntRect(layerBounds))) {
             if (viewportConstrainedNotCompositedReason) {
                 *viewportConstrainedNotCompositedReason = RenderLayer::NotCompositedForBoundsOutOfView;
-                m_reevaluateCompositingAfterLayout = true;
+                m_needsToRecomputeCompositingRequirements = true;
             }
             return false;
         }
     }
 
     return true;
 }
 
 bool RenderLayerCompositor::requiresCompositingForOverflowScrolling(const RenderLayer* layer) const
 {
@@ skipping 106 matching lines @@
 }
 
 void RenderLayerCompositor::resetTrackedRepaintRects()
 {
     if (GraphicsLayer* rootLayer = rootGraphicsLayer())
         resetTrackedRepaintRectsRecursive(rootLayer);
 }
 
 void RenderLayerCompositor::setTracksRepaints(bool tracksRepaints)
 {
+    updateCompositingLayers(CompositingUpdateFinishAllDeferredWork);
     m_isTrackingRepaints = tracksRepaints;
 }
 
 bool RenderLayerCompositor::isTrackingRepaints() const
 {
     return m_isTrackingRepaints;
 }
 
 void RenderLayerCompositor::didCommitChangesForLayer(const GraphicsLayer*) const
 {
@@ skipping 501 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "Frame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore