Make compositingState explicit

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 33ca9d65253962b662d4e8bf37ae23626ddf0cff..6359d0fde7a1e4e33f1182610885621de2d2fe76 100644
--- a/Source/core/rendering/RenderLayerCompositor.cpp
+++ b/Source/core/rendering/RenderLayerCompositor.cpp
@@ -180,8 +180,8 @@ private:
     RenderGeometryMap m_geometryMap;
 };
 
-struct CompositingState {
-    CompositingState(RenderLayer* compAncestor, bool testOverlap)
+struct CompositingRecursionData {

[Julien - ping for review, 2013/10/03 20:08:36]

This renamed feels like it's piggy backing on an already huge patch, it would be
nice to move it to its own (trivial) change.

[shawnsingh, 2013/10/07 11:45:04]

Done, landed this separately already, since it was needed for this patch.

+    CompositingRecursionData(RenderLayer* compAncestor, bool testOverlap)
         : m_compositingAncestor(compAncestor)
         , m_subtreeIsCompositing(false)
         , m_testingOverlap(testOverlap)
@@ -191,7 +191,7 @@ struct CompositingState {
     {
     }
 
-    CompositingState(const CompositingState& other)
+    CompositingRecursionData(const CompositingRecursionData& other)
         : m_compositingAncestor(other.m_compositingAncestor)
         , m_subtreeIsCompositing(other.m_subtreeIsCompositing)
         , m_testingOverlap(other.m_testingOverlap)
@@ -324,7 +324,7 @@ void RenderLayerCompositor::didChangeVisibleRect()
 
 bool RenderLayerCompositor::hasAnyAdditionalCompositedLayers(const RenderLayer* rootLayer) const
 {
-    return m_compositedLayerCount > (rootLayer->isComposited() ? 1 : 0);
+    return m_compositedLayerCount > (rootLayer->backing() ? 1 : 0);
 }
 
 void RenderLayerCompositor::updateCompositingRequirementsState()
@@ -428,7 +428,7 @@ void RenderLayerCompositor::updateCompositingLayers(CompositingUpdateType update
     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.
-        CompositingState compState(updateRoot, true);
+        CompositingRecursionData compState(updateRoot, true);
         bool layersChanged = false;
         bool saw3DTransform = false;
         {
@@ -643,6 +643,7 @@ bool RenderLayerCompositor::updateBacking(RenderLayer* layer, CompositingChangeR
 
 bool RenderLayerCompositor::updateLayerCompositingState(RenderLayer* layer, CompositingChangeRepaint shouldRepaint)
 {
+    CompositingState stateBeforeUpdating = layer->compositingState();
     bool layerChanged = updateBacking(layer, shouldRepaint);
 
     // See if we need content or clipping layers. Methods called here should assume
@@ -650,7 +651,13 @@ bool RenderLayerCompositor::updateLayerCompositingState(RenderLayer* layer, Comp
     if (layer->backing() && layer->backing()->updateGraphicsLayerConfiguration())
         layerChanged = true;
 
-    return layerChanged;
+    // While this code is gradually evolving, this sanity check will help.
+    CompositingState stateAfterUpdating = layer->compositingState();
+    bool compositingStateChanged = (stateBeforeUpdating != stateAfterUpdating);
+    ASSERT(layerChanged == compositingStateChanged);
+
+    // Return true for either condition to avoid bugs in production code.
+    return layerChanged || compositingStateChanged;
 }
 
 void RenderLayerCompositor::repaintOnCompositingChange(RenderLayer* layer)
@@ -671,7 +678,7 @@ void RenderLayerCompositor::repaintInCompositedAncestor(RenderLayer* layer, cons
 {
     RenderLayer* compositedAncestor = layer->enclosingCompositingLayerForRepaint(false /*exclude self*/);
     if (compositedAncestor) {
-        ASSERT(compositedAncestor->backing());
+        ASSERT(compositedAncestor->compositingState() == PaintsIntoOwnBacking);
 
         LayoutPoint offset;
         layer->convertToLayerCoords(compositedAncestor, offset);
@@ -706,7 +713,7 @@ void RenderLayerCompositor::layerWasAdded(RenderLayer* /*parent*/, RenderLayer*
 
 void RenderLayerCompositor::layerWillBeRemoved(RenderLayer* parent, RenderLayer* child)
 {
-    if (!child->isComposited() || parent->renderer()->documentBeingDestroyed())
+    if (!child->backing() || parent->renderer()->documentBeingDestroyed())
         return;
 
     removeViewportConstrainedLayer(child);
@@ -806,7 +813,7 @@ void RenderLayerCompositor::addToOverlapMapRecursive(OverlapMap& overlapMap, Ren
 //      must be compositing so that its contents render over that child.
 //      This implies that its positive z-index children must also be compositing.
 //
-void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer* layer, OverlapMap* overlapMap, CompositingState& compositingState, bool& layersChanged, bool& descendantHas3DTransform, Vector<RenderLayer*>& unclippedDescendants)
+void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer* layer, OverlapMap* overlapMap, CompositingRecursionData& currentRecursionState, bool& layersChanged, bool& descendantHas3DTransform, Vector<RenderLayer*>& unclippedDescendants)
 {
     layer->updateLayerListsIfNeeded();
 
@@ -826,7 +833,7 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestor
     // RenderLayer children and whose children can't use its backing to render
     // into. These children (the controls) always need to be promoted into their
     // own layers to draw on top of the accelerated video.
-    if (compositingState.m_compositingAncestor && compositingState.m_compositingAncestor->renderer()->isVideo())
+    if (currentRecursionState.m_compositingAncestor && currentRecursionState.m_compositingAncestor->renderer()->isVideo())
         directReasons |= CompositingReasonLayerForVideoOverlay;
 
     if (canBeComposited(layer)) {
@@ -837,7 +844,7 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestor
     // Next, accumulate reasons related to overlap.
     // If overlap testing is used, this reason will be overridden. If overlap testing is not
     // used, we must assume we overlap if there is anything composited behind us in paint-order.
-    CompositingReasons overlapCompositingReason = compositingState.m_subtreeIsCompositing ? CompositingReasonAssumedOverlap : CompositingReasonNone;
+    CompositingReasons overlapCompositingReason = currentRecursionState.m_subtreeIsCompositing ? CompositingReasonAssumedOverlap : CompositingReasonNone;
 
     if (rootRenderLayer()->compositorDrivenAcceleratedScrollingEnabled()) {
         Vector<size_t> unclippedDescendantsToRemove;
@@ -867,7 +874,7 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestor
     bool haveComputedBounds = false;
     IntRect absBounds;
     // If we know for sure the layer is going to be composited, don't bother looking it up in the overlap map.
-    if (overlapMap && !overlapMap->isEmpty() && compositingState.m_testingOverlap && !requiresCompositing(directReasons)) {
+    if (overlapMap && !overlapMap->isEmpty() && currentRecursionState.m_testingOverlap && !requiresCompositing(directReasons)) {
         // If we're testing for overlap, we only need to composite if we overlap something that is already composited.
         absBounds = enclosingIntRect(overlapMap->geometryMap().absoluteRect(layer->overlapBounds()));
 
@@ -883,15 +890,15 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestor
     // The children of this layer don't need to composite, unless there is
     // a compositing layer among them, so start by inheriting the compositing
     // ancestor with m_subtreeIsCompositing set to false.
-    CompositingState childState(compositingState);
-    childState.m_subtreeIsCompositing = false;
+    CompositingRecursionData childRecursionState(currentRecursionState);
+    childRecursionState.m_subtreeIsCompositing = false;
 
     bool willBeComposited = canBeComposited(layer) && requiresCompositing(reasonsToComposite);
     if (willBeComposited) {
         // Tell the parent it has compositing descendants.
-        compositingState.m_subtreeIsCompositing = true;
+        currentRecursionState.m_subtreeIsCompositing = true;
         // This layer now acts as the ancestor for kids.
-        childState.m_compositingAncestor = layer;
+        childRecursionState.m_compositingAncestor = layer;
 
         // Here we know that all children and the layer's own contents can blindly paint into
         // this layer's backing, until a descendant is composited. So, we don't need to check
@@ -900,7 +907,7 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestor
             overlapMap->beginNewOverlapTestingContext();
         // This layer is going to be composited, so children can safely ignore the fact that there's an
         // animation running behind this layer, meaning they can rely on the overlap map testing again.
-        childState.m_testingOverlap = true;
+        childRecursionState.m_testingOverlap = true;
     }
 
 #if !ASSERT_DISABLED
@@ -915,16 +922,16 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestor
             size_t listSize = negZOrderList->size();
             for (size_t i = 0; i < listSize; ++i) {
                 RenderLayer* curLayer = negZOrderList->at(i);
-                computeCompositingRequirements(layer, curLayer, overlapMap, childState, layersChanged, anyDescendantHas3DTransform, unclippedDescendants);
+                computeCompositingRequirements(layer, curLayer, overlapMap, childRecursionState, layersChanged, anyDescendantHas3DTransform, unclippedDescendants);
 
                 // If we have to make a layer for this child, make one now so we can have a contents layer
                 // (since we need to ensure that the -ve z-order child renders underneath our contents).
-                if (childState.m_subtreeIsCompositing) {
+                if (childRecursionState.m_subtreeIsCompositing) {
                     reasonsToComposite |= CompositingReasonNegativeZIndexChildren;
 
                     if (!willBeComposited) {
                         // make layer compositing
-                        childState.m_compositingAncestor = layer;
+                        childRecursionState.m_compositingAncestor = layer;
                         overlapMap->beginNewOverlapTestingContext();
                         willBeComposited = true;
                         willHaveForegroundLayer = true;
@@ -957,14 +964,14 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestor
         overlapMap->beginNewOverlapTestingContext();
         // This layer is going to be composited, so children can safely ignore the fact that there's an
         // animation running behind this layer, meaning they can rely on the overlap map testing again
-        childState.m_testingOverlap = true;
+        childRecursionState.m_testingOverlap = true;
     }
 
     if (Vector<RenderLayer*>* normalFlowList = layer->normalFlowList()) {
         size_t listSize = normalFlowList->size();
         for (size_t i = 0; i < listSize; ++i) {
             RenderLayer* curLayer = normalFlowList->at(i);
-            computeCompositingRequirements(layer, curLayer, overlapMap, childState, layersChanged, anyDescendantHas3DTransform, unclippedDescendants);
+            computeCompositingRequirements(layer, curLayer, overlapMap, childRecursionState, layersChanged, anyDescendantHas3DTransform, unclippedDescendants);
         }
     }
 
@@ -973,7 +980,7 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestor
             size_t listSize = posZOrderList->size();
             for (size_t i = 0; i < listSize; ++i) {
                 RenderLayer* curLayer = posZOrderList->at(i);
-                computeCompositingRequirements(layer, curLayer, overlapMap, childState, layersChanged, anyDescendantHas3DTransform, unclippedDescendants);
+                computeCompositingRequirements(layer, curLayer, overlapMap, childRecursionState, layersChanged, anyDescendantHas3DTransform, unclippedDescendants);
             }
         }
     }
@@ -989,14 +996,14 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestor
     // All layers (even ones that aren't being composited) need to get added to
     // the overlap map. Layers that do not composite will draw into their
     // compositing ancestor's backing, and so are still considered for overlap.
-    if (overlapMap && childState.m_compositingAncestor && !childState.m_compositingAncestor->isRootLayer())
+    if (overlapMap && childRecursionState.m_compositingAncestor && !childRecursionState.m_compositingAncestor->isRootLayer())
         addToOverlapMap(*overlapMap, layer, absBounds, haveComputedBounds);
 
     // Now check for reasons to become composited that depend on the state of descendant layers.
-    CompositingReasons subtreeCompositingReasons = subtreeReasonsForCompositing(layer->renderer(), childState.m_subtreeIsCompositing, anyDescendantHas3DTransform);
+    CompositingReasons subtreeCompositingReasons = subtreeReasonsForCompositing(layer->renderer(), childRecursionState.m_subtreeIsCompositing, anyDescendantHas3DTransform);
     reasonsToComposite |= subtreeCompositingReasons;
     if (!willBeComposited && canBeComposited(layer) && requiresCompositing(subtreeCompositingReasons)) {
-        childState.m_compositingAncestor = layer;
+        childRecursionState.m_compositingAncestor = layer;
         if (overlapMap) {
             // FIXME: this context push is effectively a no-op but needs to exist for
             // now, because the code is designed to push overlap information to the
@@ -1015,28 +1022,28 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestor
     }
 
     // Subsequent layers in the parent's stacking context may also need to composite.
-    if (childState.m_subtreeIsCompositing)
-        compositingState.m_subtreeIsCompositing = true;
+    if (childRecursionState.m_subtreeIsCompositing)
+        currentRecursionState.m_subtreeIsCompositing = true;
 
     // Set the flag to say that this SC has compositing children.
-    layer->setHasCompositingDescendant(childState.m_subtreeIsCompositing);
+    layer->setHasCompositingDescendant(childRecursionState.m_subtreeIsCompositing);
 
 
     // Turn overlap testing off for later layers if it's already off, or if we have an animating transform.
     // Note that if the layer clips its descendants, there's no reason to propagate the child animation to the parent layers. That's because
     // we know for sure the animation is contained inside the clipping rectangle, which is already added to the overlap map.
     bool isCompositedClippingLayer = canBeComposited(layer) && (reasonsToComposite & CompositingReasonClipsCompositingDescendants);
-    if ((!childState.m_testingOverlap && !isCompositedClippingLayer) || isRunningAcceleratedTransformAnimation(layer->renderer()))
-        compositingState.m_testingOverlap = false;
+    if ((!childRecursionState.m_testingOverlap && !isCompositedClippingLayer) || isRunningAcceleratedTransformAnimation(layer->renderer()))
+        currentRecursionState.m_testingOverlap = false;
 
-    if (overlapMap && childState.m_compositingAncestor == layer && !layer->isRootLayer())
+    if (overlapMap && childRecursionState.m_compositingAncestor == layer && !layer->isRootLayer())
         overlapMap->finishCurrentOverlapTestingContext();
 
     // If we're back at the root, and no other layers need to be composited, and the root layer itself doesn't need
     // to be composited, then we can drop out of compositing mode altogether. However, don't drop out of compositing mode
     // if there are composited layers that we didn't hit in our traversal (e.g. because of visibility:hidden).
     // FIXME: hasAnyAdditionalCompositedLayers() code seems fishy. We need to make root layer logic more obvious.
-    if (layer->isRootLayer() && !childState.m_subtreeIsCompositing && !requiresCompositing(directReasons) && !m_forceCompositingMode && !hasAnyAdditionalCompositedLayers(layer)) {
+    if (layer->isRootLayer() && !childRecursionState.m_subtreeIsCompositing && !requiresCompositing(directReasons) && !m_forceCompositingMode && !hasAnyAdditionalCompositedLayers(layer)) {
         enableCompositingMode(false);
         willBeComposited = false;
         reasonsToComposite = CompositingReasonNone;
@@ -1045,7 +1052,7 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestor
     // At this point we have finished collecting all reasons to composite this layer.
     layer->setCompositingReasons(reasonsToComposite);
 
-    // Update backing now, so that we can use isComposited() reliably during tree traversal in rebuildCompositingLayerTree().
+    // Update backing now, so that we can use backing() reliably during tree traversal in rebuildCompositingLayerTree().
     if (updateBacking(layer, CompositingChangeRepaintNow))
         layersChanged = true;
 
@@ -1061,12 +1068,12 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestor
 void RenderLayerCompositor::setCompositingParent(RenderLayer* childLayer, RenderLayer* parentLayer)
 {
     ASSERT(!parentLayer || childLayer->ancestorCompositingLayer() == parentLayer);
-    ASSERT(childLayer->isComposited());
+    ASSERT(childLayer->backing());
 
     // It's possible to be called with a parent that isn't yet composited when we're doing
     // partial updates as required by painting or hit testing. Just bail in that case;
     // we'll do a full layer update soon.
-    if (!parentLayer || !parentLayer->isComposited())
+    if (!parentLayer || !parentLayer->backing())
         return;
 
     if (parentLayer) {
@@ -1080,7 +1087,7 @@ void RenderLayerCompositor::setCompositingParent(RenderLayer* childLayer, Render
 
 void RenderLayerCompositor::removeCompositedChildren(RenderLayer* layer)
 {
-    ASSERT(layer->isComposited());
+    ASSERT(layer->backing());
 
     GraphicsLayer* hostingLayer = layer->backing()->parentForSublayers();
     hostingLayer->removeAllChildren();
@@ -1369,7 +1376,7 @@ bool RenderLayerCompositor::parentFrameContentLayers(RenderPart* renderer)
         return false;
 
     RenderLayer* layer = renderer->layer();
-    if (!layer->isComposited())
+    if (!layer->backing())
         return false;
 
     RenderLayerBacking* backing = layer->backing();
@@ -1495,7 +1502,7 @@ void RenderLayerCompositor::repaintCompositedLayers(const IntRect* absRect)
 void RenderLayerCompositor::recursiveRepaintLayer(RenderLayer* layer, const IntRect* rect)
 {
     // FIXME: This method does not work correctly with transforms.
-    if (layer->isComposited() && !layer->backing()->paintsIntoCompositedAncestor()) {
+    if (layer->compositingState() == PaintsIntoOwnBacking) {
         if (rect)
             layer->setBackingNeedsRepaintInRect(*rect);
         else
@@ -1588,7 +1595,7 @@ void RenderLayerCompositor::clearBackingForLayerIncludingDescendants(RenderLayer
     if (!layer)
         return;
 
-    if (layer->isComposited()) {
+    if (layer->backing()) {
         removeViewportConstrainedLayer(layer);
         layer->clearBacking();
     }
@@ -1642,6 +1649,8 @@ bool RenderLayerCompositor::canBeComposited(const RenderLayer* layer) const
 bool RenderLayerCompositor::requiresOwnBackingStore(const RenderLayer* layer, const RenderLayer* compositingAncestorLayer) const
 {
     RenderObject* renderer = layer->renderer();
+
+    // A layer definitely needs its own backing if we cannot paint into the composited ancestor.
     if (compositingAncestorLayer
         && !(compositingAncestorLayer->backing()->graphicsLayer()->drawsContent()
             || compositingAncestorLayer->backing()->paintsIntoCompositedAncestor()))
@@ -1732,7 +1741,7 @@ CompositingReasons RenderLayerCompositor::reasonsForCompositing(const RenderLaye
 {
     CompositingReasons reasons = CompositingReasonNone;
 
-    if (!layer || !layer->isComposited())
+    if (!layer || !layer->backing())
         return reasons;
 
     return layer->compositingReasons();
@@ -1823,7 +1832,7 @@ const char* RenderLayerCompositor::logReasonsForCompositing(const RenderLayer* l
 // but a sibling in the z-order hierarchy.
 bool RenderLayerCompositor::clippedByAncestor(const RenderLayer* layer) const
 {
-    if (!layer->isComposited() || !layer->parent())
+    if (!layer->backing() || !layer->parent())
         return false;
 
     const RenderLayer* compositingAncestor = layer->ancestorCompositingLayer();
@@ -1932,7 +1941,7 @@ bool RenderLayerCompositor::requiresCompositingForPlugin(RenderObject* renderer)
     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();
+        return pluginRenderer->hasLayer() && pluginRenderer->layer()->backing();
 
     // Don't go into compositing mode if height or width are zero, or size is 1x1.
     IntRect contentBox = pixelSnappedIntRect(pluginRenderer->contentBoxRect());
@@ -1957,7 +1966,7 @@ bool RenderLayerCompositor::requiresCompositingForFrame(RenderObject* renderer)
 
     // 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();
+        return frameRenderer->hasLayer() && frameRenderer->layer()->backing();
 
     // Don't go into compositing mode if height or width are zero.
     IntRect contentBox = pixelSnappedIntRect(frameRenderer->contentBoxRect());
@@ -2132,7 +2141,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_reevaluateCompositingAfterLayout = true;
-        return layer->isComposited();
+        return layer->backing();
     }
 
     bool paintsContent = layer->isVisuallyNonEmpty() || layer->hasVisibleDescendant();
@@ -2243,7 +2252,7 @@ GraphicsLayer* RenderLayerCompositor::fixedRootBackgroundLayer() const
     if (!viewLayer)
         return 0;
 
-    if (viewLayer->isComposited() && viewLayer->backing()->backgroundLayerPaintsFixedRootBackground())
+    if (viewLayer->compositingState() == PaintsIntoOwnBacking && viewLayer->backing()->backgroundLayerPaintsFixedRootBackground())
         return viewLayer->backing()->backgroundLayer();
 
     return 0;
@@ -2656,7 +2665,7 @@ static bool isRootmostFixedOrStickyLayer(RenderLayer* layer)
         return false;
 
     for (RenderLayer* stackingContainer = layer->ancestorStackingContainer(); stackingContainer; stackingContainer = stackingContainer->ancestorStackingContainer()) {
-        if (stackingContainer->isComposited() && stackingContainer->renderer()->style()->position() == FixedPosition)
+        if (stackingContainer->backing() && stackingContainer->renderer()->style()->position() == FixedPosition)
             return false;
     }
 
@@ -2686,7 +2695,7 @@ void RenderLayerCompositor::removeViewportConstrainedLayer(RenderLayer* layer)
 
 FixedPositionViewportConstraints RenderLayerCompositor::computeFixedViewportConstraints(RenderLayer* layer) const
 {
-    ASSERT(layer->isComposited());
+    ASSERT(layer->backing());
 
     FrameView* frameView = m_renderView->frameView();
     LayoutRect viewportRect = frameView->viewportConstrainedVisibleContentRect();
@@ -2724,7 +2733,7 @@ FixedPositionViewportConstraints RenderLayerCompositor::computeFixedViewportCons
 
 StickyPositionViewportConstraints RenderLayerCompositor::computeStickyViewportConstraints(RenderLayer* layer) const
 {
-    ASSERT(layer->isComposited());
+    ASSERT(layer->backing());
 
     FrameView* frameView = m_renderView->frameView();
     LayoutRect viewportRect = frameView->viewportConstrainedVisibleContentRect();