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 c11833f599c2d3dea0361efc2b8ef41c04283ac7..77e386095d7b677033e4c507e950185c22867513 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 {
+    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& currentState, bool& layersChanged, bool& descendantHas3DTransform, Vector<RenderLayer*>& unclippedDescendants)

[Ian Vollick, 2013/10/02 19:12:26]

bikeshed: currentData?

[shawnsingh, 2013/10/03 03:04:04]

How about currentRecursionState?  "state" is actually not the wrong word.  It's
just not compositing state; it's the state of the recursive algorithm.   I used
that in the new patch, please feel free to bikeshed it more.

 {
     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 (currentState.m_compositingAncestor && currentState.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 = currentState.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() && currentState.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,13 +890,13 @@ 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);
+    CompositingRecursionData childState(currentState);
     childState.m_subtreeIsCompositing = false;
 
     bool willBeComposited = canBeComposited(layer) && requiresCompositing(reasonsToComposite);
     if (willBeComposited) {
         // Tell the parent it has compositing descendants.
-        compositingState.m_subtreeIsCompositing = true;
+        currentState.m_subtreeIsCompositing = true;
         // This layer now acts as the ancestor for kids.
         childState.m_compositingAncestor = layer;
 
@@ -1016,7 +1023,7 @@ 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;
+        currentState.m_subtreeIsCompositing = true;
 
     // Set the flag to say that this SC has compositing children.
     layer->setHasCompositingDescendant(childState.m_subtreeIsCompositing);
@@ -1027,7 +1034,7 @@ void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestor
     // 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;
+        currentState.m_testingOverlap = false;
 
     if (overlapMap && childState.m_compositingAncestor == layer && !layer->isRootLayer())
         overlapMap->finishCurrentOverlapTestingContext();
@@ -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())

[Ian Vollick, 2013/10/02 19:12:26]

I think this one is paints into own backing.

[shawnsingh, 2013/10/03 03:04:04]

Trying to do this makes it fail
compositing/overflow/scrollbars-with-clipped-owner.html.

         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->backing() && viewLayer->backing()->backgroundLayerPaintsFixedRootBackground())

[Ian Vollick, 2013/10/02 19:12:26]

this one's paints into own backing.

[shawnsingh, 2013/10/03 03:04:04]

Done.

         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();