Merge two update type fields in RenderLayerCompositor

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 180 matching lines @@
     bool m_hasUnisolatedCompositedBlendingDescendant;
     bool m_testingOverlap;
 #ifndef NDEBUG
     int m_depth;
 #endif
 };
 
 RenderLayerCompositor::RenderLayerCompositor(RenderView& renderView)
     : m_renderView(renderView)
     , m_compositingReasonFinder(renderView)
+    , m_pendingUpdateType(CompositingUpdateNone)
     , m_hasAcceleratedCompositing(true)
     , m_showRepaintCounter(false)
     , m_needsToRecomputeCompositingRequirements(false)
     , m_needsToUpdateLayerTreeGeometry(false)
-    , m_pendingUpdateType(GraphicsLayerUpdater::DoNotForceUpdate)
-    , m_pendingPropertyUpdateType(CompositingPropertyUpdater::DoNotForceUpdate)
     , m_compositing(false)
     , m_compositingLayersNeedRebuild(false)
     , m_forceCompositingMode(false)
     , m_needsUpdateCompositingRequirementsState(false)
     , m_isTrackingRepaints(false)
     , m_rootLayerAttachment(RootLayerUnattached)
 {
 }
 
 RenderLayerCompositor::~RenderLayerCompositor()
@@ skipping 120 matching lines @@
     // 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();
     }
 }
 
 void RenderLayerCompositor::setNeedsCompositingUpdate(CompositingUpdateType updateType)
 {
+    ASSERT(updateType != CompositingUpdateNone);
     // FIXME: this code was historically part of updateCompositingLayers, and
     // for now is kept totally equivalent to the previous implementation. We
     // should carefully clean up the awkward early-exit semantics, balancing between
     // skipping unnecessary compositing updates and not incorrectly skipping
     // necessary updates.
 
     // 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_needsToRecomputeCompositingRequirements && !m_compositing)
         return;
 
+    m_pendingUpdateType = std::max(m_pendingUpdateType, updateType);
+
     switch (updateType) {
+    case CompositingUpdateNone:
+        ASSERT_NOT_REACHED();
+        break;
     case CompositingUpdateAfterStyleChange:
         m_needsToRecomputeCompositingRequirements = true;
         break;
     case CompositingUpdateAfterLayout:
         m_needsToRecomputeCompositingRequirements = true;
-        // FIXME: Ideally we'd be smarter about tracking dirtiness and wouldn't need a ForceUpdate here.
-        m_pendingUpdateType = GraphicsLayerUpdater::ForceUpdate;
-        // FIXME: Ideally we'd be smarter about tracking dirtiness and wouldn't need a ForceUpdate here.
-        m_pendingPropertyUpdateType = CompositingPropertyUpdater::ForceUpdate;
         break;
     case CompositingUpdateOnScroll:
         m_needsToRecomputeCompositingRequirements = true; // Overlap can change with scrolling, so need to check for hierarchy updates.
         m_needsToUpdateLayerTreeGeometry = true;
-        // FIXME: Ideally we'd be smarter about tracking dirtiness and wouldn't need a ForceUpdate here.
-        m_pendingUpdateType = GraphicsLayerUpdater::ForceUpdate;
-        // FIXME: Ideally we'd be smarter about tracking dirtiness and wouldn't need a ForceUpdate here.
-        m_pendingPropertyUpdateType = CompositingPropertyUpdater::ForceUpdate;
         break;
     case CompositingUpdateOnCompositedScroll:
         m_needsToUpdateLayerTreeGeometry = true;
-        // FIXME: Ideally we'd be smarter about tracking dirtiness and wouldn't need a ForceUpdate here.
-        m_pendingUpdateType = GraphicsLayerUpdater::ForceUpdate;
-        // FIXME: Ideally we'd be smarter about tracking dirtiness and wouldn't need a ForceUpdate here.
-        m_pendingPropertyUpdateType = CompositingPropertyUpdater::ForceUpdate;
         break;
     case CompositingUpdateAfterCanvasContextChange:
         m_needsToUpdateLayerTreeGeometry = true;
         break;
     }
 
     page()->animator().scheduleVisualUpdate();
 }
 
 static void clearAncestorDependentPropertyCacheRecursive(RenderLayer* layer)
@@ skipping 39 matching lines @@
             if (childCompositor && childCompositor->hasUnresolvedDirtyBits()) {
                 m_renderView.frameView()->scheduleAnimation();
                 return;
             }
         }
     }
 }
 
 bool RenderLayerCompositor::hasUnresolvedDirtyBits()
 {
-    return m_needsToRecomputeCompositingRequirements || m_compositingLayersNeedRebuild || m_needsToUpdateLayerTreeGeometry || m_needsUpdateCompositingRequirementsState || m_pendingUpdateType != GraphicsLayerUpdater::DoNotForceUpdate;
+    return m_needsToRecomputeCompositingRequirements || m_compositingLayersNeedRebuild || m_needsToUpdateLayerTreeGeometry || m_needsUpdateCompositingRequirementsState || m_pendingUpdateType > CompositingUpdateNone;
 }
 
 void RenderLayerCompositor::updateCompositingLayersInternal()
 {
     if (isMainFrame() && m_renderView.frameView())
         finishCompositingUpdateForFrameTree(&m_renderView.frameView()->frame());
 
     if (m_forceCompositingMode && !m_compositing)
         enableCompositingMode(true);
 
     if (!m_needsToRecomputeCompositingRequirements && !m_compositing)
         return;
 
+    CompositingUpdateType updateType = m_pendingUpdateType;
+
     bool needCompositingRequirementsUpdate = m_needsToRecomputeCompositingRequirements;
     bool needHierarchyAndGeometryUpdate = m_compositingLayersNeedRebuild;
     bool needGeometryUpdate = m_needsToUpdateLayerTreeGeometry;
     bool needsToUpdateScrollingCoordinator = scrollingCoordinator() ? scrollingCoordinator()->needsToUpdateAfterCompositingChange() : false;
 
     if (!needCompositingRequirementsUpdate && !needHierarchyAndGeometryUpdate && !needGeometryUpdate && !needsToUpdateScrollingCoordinator)
         return;
 
-    GraphicsLayerUpdater::UpdateType updateType = m_pendingUpdateType;
+    m_pendingUpdateType = CompositingUpdateNone;
+
+    GraphicsLayerUpdater::UpdateType graphicsLayerUpdateType = GraphicsLayerUpdater::DoNotForceUpdate;
+    CompositingPropertyUpdater::UpdateType compositingPropertyUpdateType = CompositingPropertyUpdater::DoNotForceUpdate;
+
+    // FIXME: Teach non-style compositing updates how to do partial tree walks.
+    if (updateType >= CompositingUpdateAfterLayout) {
+        graphicsLayerUpdateType = GraphicsLayerUpdater::ForceUpdate;
+        compositingPropertyUpdateType = CompositingPropertyUpdater::ForceUpdate;
+    }
 
     // Only clear the flags if we're updating the entire hierarchy.
     m_compositingLayersNeedRebuild = false;
     m_needsToUpdateLayerTreeGeometry = false;
     m_needsToRecomputeCompositingRequirements = false;
-    m_pendingUpdateType = GraphicsLayerUpdater::DoNotForceUpdate;
 
     RenderLayer* updateRoot = rootRenderLayer();
 
     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, 0, true);
         bool layersChanged = false;
         bool saw3DTransform = false;
 
         {
             TRACE_EVENT0("blink_rendering", "CompositingPropertyUpdater::updateAncestorDependentProperties");
-            CompositingPropertyUpdater(updateRoot).updateAncestorDependentProperties(updateRoot, m_pendingPropertyUpdateType, 0);
-            m_pendingPropertyUpdateType = CompositingPropertyUpdater::DoNotForceUpdate;
+            CompositingPropertyUpdater(updateRoot).updateAncestorDependentProperties(updateRoot, compositingPropertyUpdateType, 0);
 #if !ASSERT_DISABLED
             CompositingPropertyUpdater::assertNeedsToUpdateAncestorDependantPropertiesBitsCleared(updateRoot);
 #endif
         }
 
         {
             TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::computeCompositingRequirements");
             OverlapMap overlapTestRequestMap;
 
             // FIXME: Passing these unclippedDescendants down and keeping track
@@ skipping 18 matching lines @@
                     (*it)->updateHasVisibleNonLayerContent();
             }
         }
 
         if (layersChanged)
             needHierarchyAndGeometryUpdate = true;
     }
 
     if (needGeometryUpdate || needHierarchyAndGeometryUpdate) {
         TRACE_EVENT0("blink_rendering", "GraphicsLayerUpdater::updateRecursive");
-        GraphicsLayerUpdater().update(*updateRoot, updateType);
+        GraphicsLayerUpdater().update(*updateRoot, graphicsLayerUpdateType);
 #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.
         GraphicsLayerVector childList;
         {
@@ skipping 1611 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore