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 207 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 134 matching lines @@
 
 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 checkForHierarchyUpdate = false;
     bool needGeometryUpdate = false;
 
+    // CompositingUpdateOnBeginDrawingFrame 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).

[Ian Vollick, 2013/10/08 18:32:21]

I love this. :)

     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 CompositingUpdateOnBeginDrawingFrame:
+        checkForHierarchyUpdate = m_needsToRecomputeCompositingRequirements;
+        needGeometryUpdate = m_needsToUpdateLayerTreeGeometry;
         break;
     }
 
+    // FIXME: why isn't needHierarchyUpdate part of this?

[Ian Vollick, 2013/10/08 18:32:21]

Whoa. No good reason I can see. If we need to rebuild the composited layer tree,
we'd better not bail, right?

     if (!checkForHierarchyUpdate && !needGeometryUpdate)
         return;
 
     bool needHierarchyUpdate = m_compositingLayersNeedRebuild;
     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;
+    // FIXME, I think we can remove this if-condition?

[Ian Vollick, 2013/10/08 18:32:21]

I don't think so. If the update root is non-NULL, then I think there be layers
in the tree we don't visit when computing compositing requirements (and will
therefore have stale state).

+    if (isFullUpdate)
+        m_needsToRecomputeCompositingRequirements = false;
 
 #if !LOG_DISABLED
     double startTime = 0;
     if (compositingLogEnabled()) {
         ++m_rootLayerUpdateCount;
         startTime = currentTime();
     }
 #endif
 
     if (checkForHierarchyUpdate) {
@@ skipping 1496 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?

[Ian Vollick, 2013/10/08 18:32:21]

Totally fishy. Doesn't this mean that if we have a potentially composited
plugin, we'll _always_ need to recompute compositing requirements?

If, as you suggested offline, the original intent of this code had been to
indicate that we need to defer our determination here until post-layer, could we
remove this and the similar deferrals below (since they'll all happen
post-layout)?

[Vangelis Kokkevis, 2013/10/08 23:22:33]

I think the reason this code existed is that there was a special condition to
not switch to compositing mode for zero-sized plugins. Back in the day sites
were using Flash for audio and WebKit didn't want to incur the cost of switching
over to accelerated compositing for it. Maybe we could special-case it for
non-FCM or remove it altogether.

+    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()->compositedLayerMapping();
 
     // 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?

[Ian Vollick, 2013/10/08 18:32:21]

Ditto.

+    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()->compositedLayerMapping();
 
     // Don't go into compositing mode if height or width are zero.
@@ skipping 116 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->compositedLayerMapping();
     }
 
     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 623 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "Frame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore