Revert "Re-land deferred compositing updates with fixed assumptions"

Source/core/rendering/RenderLayerCompositor.cpp

Index: Source/core/rendering/RenderLayerCompositor.cpp
diff --git a/Source/core/rendering/RenderLayerCompositor.cpp b/Source/core/rendering/RenderLayerCompositor.cpp
index 4e7a8a6ba8581ea398baaef1111e5d5a32813a88..216ca20991740dc62aa337ec2abf5d0f1f845780 100644
--- a/Source/core/rendering/RenderLayerCompositor.cpp
+++ b/Source/core/rendering/RenderLayerCompositor.cpp
@@ -229,8 +229,7 @@ RenderLayerCompositor::RenderLayerCompositor(RenderView* renderView)
     , m_compositingTriggers(static_cast<ChromeClient::CompositingTriggerFlags>(ChromeClient::AllTriggers))
     , m_compositedLayerCount(0)
     , m_showRepaintCounter(false)
-    , m_needsToRecomputeCompositingRequirements(false)
-    , m_needsToUpdateLayerTreeGeometry(false)
+    , m_reevaluateCompositingAfterLayout(false)
     , m_compositing(false)
     , m_compositingLayersNeedRebuild(false)
     , m_forceCompositingMode(false)
@@ -372,80 +371,51 @@ static RenderVideo* findFullscreenVideoRenderer(Document* document)
     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 descendant 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 (updateType == CompositingUpdateFinishAllDeferredWork && isMainFrame() && m_renderView->frameView())
-        finishCompositingUpdateForFrameTree(&m_renderView->frameView()->frame());
-
     if (m_forceCompositingMode && !m_compositing)
         enableCompositingMode(true);
 
-    if (!m_needsToRecomputeCompositingRequirements && !m_compositing)
+    if (!m_reevaluateCompositingAfterLayout && !m_compositing)
         return;
 
     AnimationUpdateBlock animationUpdateBlock(m_renderView->frameView()->frame().animation());
 
     TemporaryChange<bool> postLayoutChange(m_inPostLayoutUpdate, true);
 
-    bool needCompositingRequirementsUpdate = false;
-    bool needHierarchyAndGeometryUpdate = false;
+    bool checkForHierarchyUpdate = m_reevaluateCompositingAfterLayout;
     bool needGeometryUpdate = false;
-    bool needsToUpdateScrollingCoordinator = 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:
-        m_needsToRecomputeCompositingRequirements = true;
+        checkForHierarchyUpdate = true;
         break;
     case CompositingUpdateOnScroll:
-        m_needsToRecomputeCompositingRequirements = true; // Overlap can change with scrolling, so need to check for hierarchy updates.
-        m_needsToUpdateLayerTreeGeometry = true;
+        checkForHierarchyUpdate = true; // Overlap can change with scrolling, so need to check for hierarchy updates.
+        needGeometryUpdate = true;
         break;
     case CompositingUpdateOnCompositedScroll:
-        m_needsToUpdateLayerTreeGeometry = true;
-        break;
-    case CompositingUpdateFinishAllDeferredWork:
-        needCompositingRequirementsUpdate = m_needsToRecomputeCompositingRequirements;
-        needHierarchyAndGeometryUpdate = m_compositingLayersNeedRebuild;
-        needGeometryUpdate = m_needsToUpdateLayerTreeGeometry;
-        needsToUpdateScrollingCoordinator = scrollingCoordinator() ? scrollingCoordinator()->needsToUpdateAfterCompositingChange() : false;
+        needGeometryUpdate = true;
         break;
     }
 
-    if (!needCompositingRequirementsUpdate && !needHierarchyAndGeometryUpdate && !needGeometryUpdate && !needsToUpdateScrollingCoordinator)
+    if (!checkForHierarchyUpdate && !needGeometryUpdate)
         return;
 
-    ASSERT(updateType == CompositingUpdateFinishAllDeferredWork);
-
+    bool needHierarchyUpdate = m_compositingLayersNeedRebuild;
     bool isFullUpdate = !updateRoot;
 
-    // Only clear the flags if we're updating the entire hierarchy.
+    // Only clear the flag if we're updating the entire hierarchy.
     m_compositingLayersNeedRebuild = false;
-    m_needsToUpdateLayerTreeGeometry = false;
     updateRoot = rootRenderLayer();
 
-    if (isFullUpdate)
-        m_needsToRecomputeCompositingRequirements = false;
+    if (isFullUpdate && updateType == CompositingUpdateAfterLayout)
+        m_reevaluateCompositingAfterLayout = false;
 
 #if !LOG_DISABLED
     double startTime = 0;
@@ -455,7 +425,7 @@ void RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType update
     }
 #endif
 
-    if (needCompositingRequirementsUpdate) {
+    if (checkForHierarchyUpdate) {
         // 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);
@@ -478,11 +448,11 @@ void RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType update
                     (*it)->updateHasVisibleNonLayerContent();
             }
         }
-        needHierarchyAndGeometryUpdate |= layersChanged;
+        needHierarchyUpdate |= layersChanged;
     }
 
 #if !LOG_DISABLED
-    if (compositingLogEnabled() && isFullUpdate && (needHierarchyAndGeometryUpdate || needGeometryUpdate)) {
+    if (compositingLogEnabled() && isFullUpdate && (needHierarchyUpdate || needGeometryUpdate)) {
         m_obligateCompositedLayerCount = 0;
         m_secondaryCompositedLayerCount = 0;
         m_obligatoryBackingStoreBytes = 0;
@@ -493,7 +463,7 @@ void RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType update
     }
 #endif
 
-    if (needHierarchyAndGeometryUpdate) {
+    if (needHierarchyUpdate) {
         // Update the hierarchy of the compositing layers.
         Vector<GraphicsLayer*> childList;
         {
@@ -527,7 +497,7 @@ void RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType update
     }
 
 #if !LOG_DISABLED
-    if (compositingLogEnabled() && isFullUpdate && (needHierarchyAndGeometryUpdate || needGeometryUpdate)) {
+    if (compositingLogEnabled() && isFullUpdate && (needHierarchyUpdate || needGeometryUpdate)) {
         double endTime = currentTime();
         LOG(Compositing, "Total layers   primary   secondary   obligatory backing (KB)   secondary backing(KB)   total backing (KB)  update time (ms)\n");
 
@@ -541,14 +511,8 @@ void RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType update
     if (!hasAcceleratedCompositing())
         enableCompositingMode(false);
 
-    // The scrolling coordinator may realize that it needs updating while compositing was being updated in this function.
-    needsToUpdateScrollingCoordinator |= scrollingCoordinator() ? scrollingCoordinator()->needsToUpdateAfterCompositingChange() : false;
-    if (needsToUpdateScrollingCoordinator && isMainFrame() && scrollingCoordinator() && inCompositingMode())
-        scrollingCoordinator()->updateAfterCompositingChange();
-
     // Inform the inspector that the layer tree has changed.
-    if (isMainFrame())
-        InspectorInstrumentation::layerTreeDidChange(page());
+    InspectorInstrumentation::layerTreeDidChange(page());
 }
 
 void RenderLayerCompositor::layerBecameNonComposited(const RenderLayer* renderLayer)
@@ -1139,7 +1103,7 @@ void RenderLayerCompositor::rebuildCompositingLayerTree(RenderLayer* layer, Vect
         UNUSED_PARAM(depth);
 #endif
         if (currentCompositedLayerMapping->hasUnpositionedOverflowControlsLayers())
-            layer->scrollableArea()->positionOverflowControls();
+            layer->scrollableArea()->positionNewlyCreatedOverflowControls();
 
         pixelsWithoutPromotingAllTransitions += layer->size().height() * layer->size().width();
     } else {
@@ -1312,8 +1276,7 @@ bool RenderLayerCompositor::scrollingLayerDidChange(RenderLayer* layer)
 
 String RenderLayerCompositor::layerTreeAsText(LayerTreeFlags flags)
 {
-    // Before dumping the layer tree, finish any pending compositing update.
-    updateCompositingLayers(CompositingUpdateFinishAllDeferredWork);
+    updateCompositingLayers(CompositingUpdateAfterLayout);
 
     if (!m_rootContentLayer)
         return String();
@@ -1851,8 +1814,7 @@ bool RenderLayerCompositor::requiresCompositingForPlugin(RenderObject* renderer)
     if (!composite)
         return false;
 
-    // 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;
+    m_reevaluateCompositingAfterLayout = true;
 
     RenderWidget* pluginRenderer = toRenderWidget(renderer);
     // If we can't reliably know the size of the plugin yet, don't change compositing state.
@@ -1874,8 +1836,7 @@ bool RenderLayerCompositor::requiresCompositingForFrame(RenderObject* renderer)
     if (!frameRenderer->requiresAcceleratedCompositing())
         return false;
 
-    // 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;
+    m_reevaluateCompositingAfterLayout = true;
 
     RenderLayerCompositor* innerCompositor = frameContentsCompositor(frameRenderer);
     if (!innerCompositor)
@@ -2012,7 +1973,7 @@ bool RenderLayerCompositor::requiresCompositingForPosition(RenderObject* rendere
     RenderObject* container = renderer->container();
     // If the renderer is not hooked up yet then we have to wait until it is.
     if (!container) {
-        m_needsToRecomputeCompositingRequirements = true;
+        m_reevaluateCompositingAfterLayout = true;
         return false;
     }
 
@@ -2052,7 +2013,7 @@ bool RenderLayerCompositor::requiresCompositingForPosition(RenderObject* rendere
 
     // 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_needsToRecomputeCompositingRequirements = true;
+        m_reevaluateCompositingAfterLayout = true;
         return layer->compositedLayerMapping();
     }
 
@@ -2075,7 +2036,7 @@ bool RenderLayerCompositor::requiresCompositingForPosition(RenderObject* rendere
         if (!viewBounds.intersects(enclosingIntRect(layerBounds))) {
             if (viewportConstrainedNotCompositedReason) {
                 *viewportConstrainedNotCompositedReason = RenderLayer::NotCompositedForBoundsOutOfView;
-                m_needsToRecomputeCompositingRequirements = true;
+                m_reevaluateCompositingAfterLayout = true;
             }
             return false;
         }
@@ -2193,7 +2154,6 @@ void RenderLayerCompositor::resetTrackedRepaintRects()
 
 void RenderLayerCompositor::setTracksRepaints(bool tracksRepaints)
 {
-    updateCompositingLayers(CompositingUpdateFinishAllDeferredWork);
     m_isTrackingRepaints = tracksRepaints;
 }