Delete RenderLayerCompositor::m_compositingLayersNeedRebuild

Source/core/rendering/compositing/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 70 matching lines @@
     DocumentLifecycle::DeprecatedTransition m_deprecatedTransition;
     DocumentLifecycle::State m_originalState;
 };
 
 RenderLayerCompositor::RenderLayerCompositor(RenderView& renderView)
     : m_renderView(renderView)
     , m_compositingReasonFinder(renderView)
     , m_pendingUpdateType(CompositingUpdateNone)
     , m_hasAcceleratedCompositing(true)
     , m_compositing(false)
-    , m_compositingLayersNeedRebuild(false)
     , m_rootShouldAlwaysCompositeDirty(true)
     , m_needsUpdateFixedBackground(false)
     , m_isTrackingRepaints(false)
     , m_rootLayerAttachment(RootLayerUnattached)
 {
     updateAcceleratedCompositingSettings();
 }
 
 RenderLayerCompositor::~RenderLayerCompositor()
 {
@@ skipping 43 matching lines @@
     if (!m_rootShouldAlwaysCompositeDirty)
         return;
 
     m_rootShouldAlwaysCompositeDirty = false;
     if (m_compositing)
         return;
 
     if (rootShouldAlwaysComposite()) {
         // FIXME: Is this needed? It was added in https://bugs.webkit.org/show_bug.cgi?id=26651.
         // No tests fail if it's deleted.
-        setCompositingLayersNeedRebuild();
+        setNeedsCompositingUpdate(CompositingUpdateRebuildTree);
         setCompositingModeEnabled(true);
     }
 }
 
-bool RenderLayerCompositor::compositingLayersNeedRebuild()
-{
-    // enableCompositingModeIfNeeded can set the m_compositingLayersNeedRebuild bit.
-    ASSERT(!m_rootShouldAlwaysCompositeDirty);
-    return m_compositingLayersNeedRebuild;
-}
-
 bool RenderLayerCompositor::rootShouldAlwaysComposite() const
 {
     if (!m_hasAcceleratedCompositing)
         return false;
     return m_renderView.frame()->isMainFrame() || m_compositingReasonFinder.requiresCompositingForScrollableFrame();
 }
 
 void RenderLayerCompositor::updateAcceleratedCompositingSettings()
 {
     m_compositingReasonFinder.updateTriggers();
 
     bool hasAcceleratedCompositing = m_renderView.document().settings()->acceleratedCompositingEnabled();
 
     // FIXME: Is this needed? It was added in https://bugs.webkit.org/show_bug.cgi?id=26651.
     // No tests fail if it's deleted.
     if (hasAcceleratedCompositing != m_hasAcceleratedCompositing)
-        setCompositingLayersNeedRebuild();
+        setNeedsCompositingUpdate(CompositingUpdateRebuildTree);
 
     m_hasAcceleratedCompositing = hasAcceleratedCompositing;
     m_rootShouldAlwaysCompositeDirty = true;
 }
 
 bool RenderLayerCompositor::layerSquashingEnabled() const
 {
     if (!RuntimeEnabledFeatures::layerSquashingEnabled())
         return false;
     if (Settings* settings = m_renderView.document().settings())
         return settings->layerSquashingEnabled();
     return true;
 }
 
 bool RenderLayerCompositor::acceleratedCompositingForOverflowScrollEnabled() const
 {
     return m_compositingReasonFinder.hasOverflowScrollTrigger();
 }
 
-void RenderLayerCompositor::setCompositingLayersNeedRebuild()
-{
-    // FIXME: crbug.com/332248 ideally this could be merged with setNeedsCompositingUpdate().
-    m_compositingLayersNeedRebuild = true;
-    page()->animator().scheduleVisualUpdate();
-    lifecycle().ensureStateAtMost(DocumentLifecycle::LayoutClean);
-}
-
 static RenderVideo* findFullscreenVideoRenderer(Document& document)
 {
     Element* fullscreenElement = FullscreenElementStack::fullscreenElementFrom(document);
     while (fullscreenElement && fullscreenElement->isFrameOwnerElement()) {
         Document* contentDocument = toHTMLFrameOwnerElement(fullscreenElement)->contentDocument();
         if (!contentDocument)
             return 0;
         fullscreenElement = FullscreenElementStack::fullscreenElementFrom(*contentDocument);
     }
     if (!isHTMLVideoElement(fullscreenElement))
@@ skipping 51 matching lines @@
     // track which RenderLayers moved during layout and only dirty those
     // specific RenderLayers.
     rootRenderLayer()->setNeedsToUpdateAncestorDependentProperties();
     setNeedsCompositingUpdate(CompositingUpdateAfterCompositingInputChange);
 }
 
 #if ASSERT_ENABLED
 
 void RenderLayerCompositor::assertNoUnresolvedDirtyBits()
 {
-    ASSERT(!compositingLayersNeedRebuild());
     ASSERT(m_pendingUpdateType == CompositingUpdateNone);
     ASSERT(!m_rootShouldAlwaysCompositeDirty);
 }
 
 #endif
 
 void RenderLayerCompositor::applyOverlayFullscreenVideoAdjustment()
 {
     if (!m_rootContentLayer)
         return;
@@ skipping 26 matching lines @@
 }
 
 void RenderLayerCompositor::updateIfNeeded()
 {
     {
         // FIXME: Notice that we call this function before checking the dirty bits below.
         // We'll need to remove DeprecatedDirtyCompositingDuringCompositingUpdate
         // before moving this function after checking the dirty bits.
         DeprecatedDirtyCompositingDuringCompositingUpdate marker(lifecycle());
 
-        // FIXME: enableCompositingModeIfNeeded can call setCompositingLayersNeedRebuild,
+        // FIXME: enableCompositingModeIfNeeded can trigger a CompositingUpdateRebuildTree,
         // which asserts that it's not InCompositingUpdate.
         enableCompositingModeIfNeeded();
     }
 
     CompositingUpdateType updateType = m_pendingUpdateType;
-    bool needHierarchyAndGeometryUpdate = compositingLayersNeedRebuild();
-
     m_pendingUpdateType = CompositingUpdateNone;
-    m_compositingLayersNeedRebuild = false;
 
     if (!hasAcceleratedCompositing())
         return;
 
     bool needsToUpdateScrollingCoordinator = scrollingCoordinator() && scrollingCoordinator()->needsToUpdateAfterCompositingChange();
-    if (updateType == CompositingUpdateNone && !needHierarchyAndGeometryUpdate && !needsToUpdateScrollingCoordinator)
+    if (updateType == CompositingUpdateNone && !needsToUpdateScrollingCoordinator)
         return;
 
-    GraphicsLayerUpdater::UpdateType graphicsLayerUpdateType = GraphicsLayerUpdater::DoNotForceUpdate;
-    CompositingPropertyUpdater::UpdateType compositingPropertyUpdateType = CompositingPropertyUpdater::DoNotForceUpdate;
-
     RenderLayer* updateRoot = rootRenderLayer();
 
     Vector<RenderLayer*> layersNeedingRepaint;
 
     if (updateType >= CompositingUpdateAfterCompositingInputChange) {
         bool layersChanged = false;
         {
             TRACE_EVENT0("blink_rendering", "CompositingPropertyUpdater::updateAncestorDependentProperties");
-            CompositingPropertyUpdater(updateRoot).updateAncestorDependentProperties(updateRoot, compositingPropertyUpdateType);
+            CompositingPropertyUpdater(updateRoot).updateAncestorDependentProperties(updateRoot);
 #if ASSERT_ENABLED
             CompositingPropertyUpdater::assertNeedsToUpdateAncestorDependantPropertiesBitsCleared(updateRoot);
 #endif
         }
 
         CompositingRequirementsUpdater(m_renderView, m_compositingReasonFinder).update(updateRoot);
 
         {
             TRACE_EVENT0("blink_rendering", "CompositingLayerAssigner::assign");
             CompositingLayerAssigner(this).assign(updateRoot, layersChanged, layersNeedingRepaint);
         }
 
         {
             TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::updateAfterCompositingChange");
             if (const FrameView::ScrollableAreaSet* scrollableAreas = m_renderView.frameView()->scrollableAreas()) {
                 for (FrameView::ScrollableAreaSet::iterator it = scrollableAreas->begin(); it != scrollableAreas->end(); ++it)
                     (*it)->updateAfterCompositingChange();
             }
         }
 
         if (layersChanged)
-            needHierarchyAndGeometryUpdate = true;
+            updateType = std::max(updateType, CompositingUpdateRebuildTree);
     }
 
-    if (updateType != CompositingUpdateNone || needHierarchyAndGeometryUpdate) {
+    if (updateType != CompositingUpdateNone) {
         TRACE_EVENT0("blink_rendering", "GraphicsLayerUpdater::updateRecursive");
         GraphicsLayerUpdater updater;
-        updater.update(*updateRoot, graphicsLayerUpdateType);
+        updater.update(*updateRoot);
 
         if (updater.needsRebuildTree())
-            needHierarchyAndGeometryUpdate = true;
+            updateType = std::max(updateType, CompositingUpdateRebuildTree);
 
 #if !ASSERT_DISABLED
         // FIXME: Move this check to the end of the compositing update.
         GraphicsLayerUpdater::assertNeedsToUpdateGraphicsLayerBitsCleared(*updateRoot);
 #endif
     }
 
-    if (needHierarchyAndGeometryUpdate) {
-        // Update the hierarchy of the compositing layers.
+    if (updateType >= CompositingUpdateRebuildTree) {
         GraphicsLayerVector childList;
         {
             TRACE_EVENT0("blink_rendering", "GraphicsLayerUpdater::rebuildTree");
             GraphicsLayerUpdater().rebuildTree(*updateRoot, childList);
         }
 
         if (childList.isEmpty())
             destroyRootLayer();
         else
             m_rootContentLayer->setChildren(childList);
 
         if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled())
             applyOverlayFullscreenVideoAdjustment();
     }
 
     if (m_needsUpdateFixedBackground) {
         rootFixedBackgroundsChanged();
         m_needsUpdateFixedBackground = false;
     }
 
-    ASSERT(updateRoot || !compositingLayersNeedRebuild());
-
     // The scrolling coordinator may realize that it needs updating while compositing was being updated in this function.
     needsToUpdateScrollingCoordinator |= scrollingCoordinator() && scrollingCoordinator()->needsToUpdateAfterCompositingChange();
     if (needsToUpdateScrollingCoordinator && m_renderView.frame()->isMainFrame() && scrollingCoordinator() && inCompositingMode())
         scrollingCoordinator()->updateAfterCompositingChange();
 
     for (unsigned i = 0; i < layersNeedingRepaint.size(); i++) {
         RenderLayer* layer = layersNeedingRepaint[i];
         layer->repainter().computeRepaintRectsIncludingDescendants();
 
         repaintOnCompositingChange(layer);
@@ skipping 104 matching lines @@
     if (compositedLayerUpdate != NoCompositingStateChange)
         allocateOrClearCompositedLayerMapping(layer, compositedLayerUpdate);
 }
 
 void RenderLayerCompositor::updateLayerCompositingState(RenderLayer* layer, UpdateLayerCompositingStateOptions options)
 {
     updateDirectCompositingReasons(layer);
     CompositingStateTransitionType compositedLayerUpdate = CompositingLayerAssigner(this).computeCompositedLayerUpdate(layer);
 
     if (compositedLayerUpdate != NoCompositingStateChange)
-        setCompositingLayersNeedRebuild();
+        setNeedsCompositingUpdate(CompositingUpdateRebuildTree);
 
     if (options == UseChickenEggHacks)
         applyUpdateLayerCompositingStateChickenEggHacks(layer, compositedLayerUpdate);
 }
 
 void RenderLayerCompositor::repaintOnCompositingChange(RenderLayer* layer)
 {
     // If the renderer is not attached yet, no need to repaint.
     if (layer->renderer() != &m_renderView && !layer->renderer()->parent())
         return;
@@ skipping 11 matching lines @@
 
     LayoutPoint offset;
     layer->convertToLayerCoords(compositedAncestor, offset);
     LayoutRect repaintRect = rect;
     repaintRect.moveBy(offset);
     compositedAncestor->repainter().setBackingNeedsRepaintInRect(repaintRect);
 }
 
 void RenderLayerCompositor::layerWasAdded(RenderLayer* /*parent*/, RenderLayer* /*child*/)
 {
-    setCompositingLayersNeedRebuild();
+    setNeedsCompositingUpdate(CompositingUpdateRebuildTree);
 }
 
 void RenderLayerCompositor::layerWillBeRemoved(RenderLayer* parent, RenderLayer* child)
 {
     if (!child->hasCompositedLayerMapping() || parent->renderer()->documentBeingDestroyed())
         return;
 
     {
         // FIXME: This is called from within RenderLayer::removeChild, which is called from RenderObject::RemoveChild.
         // There's no guarantee that compositor state is up to date.
         DisableCompositingQueryAsserts disabler;
         repaintInCompositedAncestor(child, child->compositedLayerMapping()->compositedBounds());
     }
 
-    setCompositingLayersNeedRebuild();
+    setNeedsCompositingUpdate(CompositingUpdateRebuildTree);
 }
 
 void RenderLayerCompositor::frameViewDidChangeLocation(const IntPoint& contentsOffset)
 {
     if (m_overflowControlsHostLayer)
         m_overflowControlsHostLayer->setPosition(contentsOffset);
 }
 
 void RenderLayerCompositor::frameViewDidChangeSize()
 {
@@ skipping 727 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore