Remove root layer specialness in calculateDrawTransforms

cc/CCLayerTreeHostCommon.cpp

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 #include "config.h"
 
 #include "CCLayerTreeHostCommon.h"
 
 #include "CCLayerImpl.h"
@@ skipping 200 matching lines @@
 {
     // If the opacity is being animated then the opacity on the main thread is unreliable
     // (since the impl thread may be using a different opacity), so it should not be trusted.
     // In particular, it should not cause the subtree to be skipped.
     return !layer->opacity() && !layer->opacityIsAnimating();
 }
 
 template<typename LayerType>
 static bool subtreeShouldRenderToSeparateSurface(LayerType* layer, bool axisAlignedWithRespectToParent)
 {
-    // The root layer has a special render surface that is set up externally, so
-    // it shouldn't be treated as a surface in this code.
-    if (!layer->parent())
-        return false;
-
-    // Cache this value, because otherwise it walks the entire subtree several times.
-    bool descendantDrawsContent = layer->descendantDrawsContent();
-
     //
     // A layer and its descendants should render onto a new RenderSurface if any of these rules hold:
     //
 
+    // The root layer should always have a renderSurface.
+    if (!layer->parent())

[danakj, 2012/10/09 22:21:54]

<3 this

[enne (OOO), 2012/10/15 18:29:45]

Can you remove the inconsistent use of layer == rootLayer vs !layer->parent()?
Do we even need to pass the root layer down this function recursively?

+        return true;
+
     // If we force it.
     if (layer->forceRenderSurface())
         return true;
 
     // If the layer uses a mask.
     if (layer->maskLayer())
         return true;
 
     // If the layer has a reflection.
     if (layer->replicaLayer())
         return true;
 
     // If the layer uses a CSS filter.
     if (!layer->filters().isEmpty() || !layer->backgroundFilters().isEmpty())
         return true;
 
+    // Cache this value, because otherwise it walks the entire subtree several times.
+    bool descendantDrawsContent = layer->descendantDrawsContent();
+
     // If the layer flattens its subtree (i.e. the layer doesn't preserve-3d), but it is
     // treated as a 3D object by its parent (i.e. parent does preserve-3d).
     if (layerIsInExisting3DRenderingContext(layer) && !layer->preserves3D() && descendantDrawsContent)
         return true;
 
     // If the layer clips its descendants but it is not axis-aligned with respect to its parent.
     if (layerClipsSubtree(layer) && !axisAlignedWithRespectToParent && descendantDrawsContent)
         return true;
 
     // If the layer has opacity != 1 and does not have a preserves-3d transform style.
@@ skipping 78 matching lines @@
     // The adjustment allows us to continue using the scrollCompensation on the next surface.
     //  Step 1 (right-most in the math): transform from the new surface to the original ancestor surface
     //  Step 2: apply the scroll compensation
     //  Step 3: transform back to the new surface.
     if (layer->renderSurface() && !nextScrollCompensationMatrix.isIdentity())
         nextScrollCompensationMatrix = layer->renderSurface()->drawTransform().inverse() * nextScrollCompensationMatrix * layer->renderSurface()->drawTransform();
 
     return nextScrollCompensationMatrix;
 }
 
-// Should be called just before the recursive calculateDrawTransformsInternal().
-template<typename LayerType, typename LayerList>
-void setupRootLayerAndSurfaceForRecursion(LayerType* rootLayer, LayerList& renderSurfaceLayerList, const IntSize& deviceViewportSize)
-{
-    if (!rootLayer->renderSurface())
-        rootLayer->createRenderSurface();
-
-    rootLayer->renderSurface()->setContentRect(IntRect(IntPoint::zero(), deviceViewportSize));
-    rootLayer->renderSurface()->clearLayerLists();
-
-    ASSERT(renderSurfaceLayerList.isEmpty());
-    renderSurfaceLayerList.append(rootLayer);
-}
-
 // Recursively walks the layer tree starting at the given node and computes all the
 // necessary transformations, clipRects, render surfaces, etc.
 template<typename LayerType, typename LayerList, typename RenderSurfaceType, typename LayerSorter>
 static void calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLayer, const WebTransformationMatrix& parentMatrix,
     const WebTransformationMatrix& fullHierarchyMatrix, const WebTransformationMatrix& currentScrollCompensationMatrix,
     const IntRect& clipRectFromAncestor, bool ancestorClipsSubtree,
     RenderSurfaceType* nearestAncestorThatMovesPixels, LayerList& renderSurfaceLayerList, LayerList& layerList,
     LayerSorter* layerSorter, int maxTextureSize, float deviceScaleFactor, IntRect& drawableContentRectOfSubtree)
 {
     // This function computes the new matrix transformations recursively for this
@@ skipping 74 matching lines @@
     // The replica draw transform to its target surface origin is:
     //        M[replicaDraw] = S[deviceScale] * M[surfaceDraw] * Tr[replica->position() + replica->anchor()] * Tr[replica] * Tr[origin2anchor].inverse() * S[contentsScale].inverse()
     //
     // The replica draw transform to the root (screen space) origin is:
     //        M[replica2root] = M[surface2root] * Tr[replica->position()] * Tr[replica] * Tr[origin2anchor].inverse()
     //
 
     // If we early-exit anywhere in this function, the drawableContentRect of this subtree should be considered empty.
     drawableContentRectOfSubtree = IntRect();
 
-    if (subtreeShouldBeSkipped(layer))
+    // The root layer cannot skip calcDrawTransforms.
+    if (layer != rootLayer && subtreeShouldBeSkipped(layer))
         return;
 
     IntRect clipRectForSubtree;
     bool subtreeShouldBeClipped = false;
     
     float drawOpacity = layer->opacity();
     bool drawOpacityIsAnimating = layer->opacityIsAnimating();
     if (layer->parent() && layer->parent()->preserves3D()) {
         drawOpacity *= layer->parent()->drawOpacity();
         drawOpacityIsAnimating |= layer->parent()->drawOpacityIsAnimating();
@@ skipping 117 matching lines @@
         // The render surface clipRect is expressed in the space where this surface draws, i.e. the same space as clipRectFromAncestor.
         if (ancestorClipsSubtree)
             renderSurface->setClipRect(clipRectFromAncestor);
         else
             renderSurface->setClipRect(IntRect());
 
         renderSurface->setNearestAncestorThatMovesPixels(nearestAncestorThatMovesPixels);
 
         renderSurfaceLayerList.append(layer);
     } else {
+        ASSERT(layer != rootLayer);
+        ASSERT(layer->parent());
+
         layer->setDrawTransform(drawTransform);
         layer->setDrawTransformIsAnimating(animatingTransformToTarget);
         layer->setScreenSpaceTransformIsAnimating(animatingTransformToScreen);
         sublayerMatrix = combinedTransform;
 
         layer->setDrawOpacity(drawOpacity);
         layer->setDrawOpacityIsAnimating(drawOpacityIsAnimating);
 
-        if (layer != rootLayer) {
-            ASSERT(layer->parent());
-            layer->clearRenderSurface();
+        layer->clearRenderSurface();
 
-            // Layers without renderSurfaces directly inherit the ancestor's clip status.
-            subtreeShouldBeClipped = ancestorClipsSubtree;
-            if (ancestorClipsSubtree)
-                clipRectForSubtree = clipRectFromAncestor;
+        // Layers without renderSurfaces directly inherit the ancestor's clip status.
+        subtreeShouldBeClipped = ancestorClipsSubtree;
+        if (ancestorClipsSubtree)
+            clipRectForSubtree = clipRectFromAncestor;
 
-            // Layers that are not their own renderTarget will render into the target of their nearest ancestor.
-            layer->setRenderTarget(layer->parent()->renderTarget());
-        } else {
-            // FIXME: This root layer special case code should eventually go away. https://bugs.webkit.org/show_bug.cgi?id=92290
-            ASSERT(!layer->parent());
-            ASSERT(layer->renderSurface());
-            ASSERT(ancestorClipsSubtree);
-            layer->renderSurface()->setClipRect(clipRectFromAncestor);
-            subtreeShouldBeClipped = false;
-        }
+        // Layers that are not their own renderTarget will render into the target of their nearest ancestor.
+        layer->setRenderTarget(layer->parent()->renderTarget());
     }
 
     IntRect rectInTargetSpace = enclosingIntRect(CCMathUtil::mapClippedRect(layer->drawTransform(), contentRect));
 
     if (layerClipsSubtree(layer)) {
         subtreeShouldBeClipped = true;
         if (ancestorClipsSubtree && !layer->renderSurface()) {
             clipRectForSubtree = clipRectFromAncestor;
             clipRectForSubtree.intersect(rectInTargetSpace);
         } else
@@ skipping 44 matching lines @@
     IntRect drawableContentRectOfLayer = rectInTargetSpace;
     if (subtreeShouldBeClipped)
         drawableContentRectOfLayer.intersect(clipRectForSubtree);
     layer->setDrawableContentRect(drawableContentRectOfLayer);
 
     // Compute the layer's visible content rect (the rect is in content space)
     IntRect visibleContentRectOfLayer = calculateVisibleContentRect(layer);
     layer->setVisibleContentRect(visibleContentRectOfLayer);
 
     // Compute the remaining properties for the render surface, if the layer has one.
-    if (layer->renderSurface() && layer != rootLayer) {
+    if (layer == rootLayer) {
+        // The root layer's surface's contentRect is always the entire viewport.
+        ASSERT(layer->renderSurface());
+        layer->renderSurface()->setContentRect(clipRectFromAncestor);
+    } else if (layer->renderSurface() && layer != rootLayer) {
         RenderSurfaceType* renderSurface = layer->renderSurface();
         IntRect clippedContentRect = localDrawableContentRectOfSubtree;
 
         // Don't clip if the layer is reflected as the reflection shouldn't be
         // clipped. If the layer is animating, then the surface's transform to
         // its target is not known on the main thread, and we should not use it
         // to clip.
         if (!layer->replicaLayer() && transformToParentIsKnown(layer)) {
             // Note, it is correct to use ancestorClipsSubtree here, because we are looking at this layer's renderSurface, not the layer itself.
             if (ancestorClipsSubtree && !clippedContentRect.isEmpty()) {
@@ skipping 64 matching lines @@
     else
         drawableContentRectOfSubtree = localDrawableContentRectOfSubtree;
 
     if (layer->hasContributingDelegatedRenderPasses())
         layer->renderTarget()->renderSurface()->addContributingDelegatedRenderPassLayer(layer);
 }
 
 void CCLayerTreeHostCommon::calculateDrawTransforms(LayerChromium* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, int maxTextureSize, Vector<RefPtr<LayerChromium> >& renderSurfaceLayerList)
 {
     IntRect totalDrawableContentRect;
+    IntRect deviceViewportRect(IntPoint::zero(), deviceViewportSize);
     WebTransformationMatrix identityMatrix;
     WebTransformationMatrix deviceScaleTransform;
     deviceScaleTransform.scale(deviceScaleFactor);
-
-    setupRootLayerAndSurfaceForRecursion<LayerChromium, Vector<RefPtr<LayerChromium> > >(rootLayer, renderSurfaceLayerList, deviceViewportSize);
+    Vector<RefPtr<LayerChromium> > dummyLayerList;
 
     cc::calculateDrawTransformsInternal<LayerChromium, Vector<RefPtr<LayerChromium> >, RenderSurfaceChromium, void>(rootLayer, rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
-                                                                                                                         rootLayer->renderSurface()->contentRect(), true, 0, renderSurfaceLayerList,
-                                                                                                                         rootLayer->renderSurface()->layerList(), 0, maxTextureSize, deviceScaleFactor, totalDrawableContentRect);
+                                                                                                                         deviceViewportRect, true, 0, renderSurfaceLayerList,
+                                                                                                                         dummyLayerList, 0, maxTextureSize, deviceScaleFactor, totalDrawableContentRect);
+
+    // The dummy layer list should not have been used.
+    ASSERT(dummyLayerList.size() == 0);
+    // A root layer renderSurface should always exist after calcDrawTransforms.
+    ASSERT(rootLayer->renderSurface());
 }
 
 void CCLayerTreeHostCommon::calculateDrawTransforms(CCLayerImpl* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, CCLayerSorter* layerSorter, int maxTextureSize, Vector<CCLayerImpl*>& renderSurfaceLayerList)
 {
     IntRect totalDrawableContentRect;
+    IntRect deviceViewportRect(IntPoint::zero(), deviceViewportSize);
     WebTransformationMatrix identityMatrix;
     WebTransformationMatrix deviceScaleTransform;
     deviceScaleTransform.scale(deviceScaleFactor);
-
-    setupRootLayerAndSurfaceForRecursion<CCLayerImpl, Vector<CCLayerImpl*> >(rootLayer, renderSurfaceLayerList, deviceViewportSize);
+    Vector<CCLayerImpl*> dummyLayerList;
 
     cc::calculateDrawTransformsInternal<CCLayerImpl, Vector<CCLayerImpl*>, CCRenderSurface, CCLayerSorter>(rootLayer, rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
-                                                                                                                rootLayer->renderSurface()->contentRect(), true, 0, renderSurfaceLayerList,
-                                                                                                                rootLayer->renderSurface()->layerList(), layerSorter, maxTextureSize, deviceScaleFactor, totalDrawableContentRect);
+                                                                                                                deviceViewportRect, true, 0, renderSurfaceLayerList,

[danakj, 2012/10/09 22:21:54]

Can we remove the magic true bool here and give it a variable while we're here?

+                                                                                                                dummyLayerList, layerSorter, maxTextureSize, deviceScaleFactor, totalDrawableContentRect);
+
+    // The dummy layer list should not have been used.
+    ASSERT(dummyLayerList.size() == 0);
+    // A root layer renderSurface should always exist after calcDrawTransforms.
+    ASSERT(rootLayer->renderSurface());
 }
 
 static bool pointHitsRect(const IntPoint& viewportPoint, const WebTransformationMatrix& localSpaceToScreenSpaceTransform, FloatRect localSpaceRect)
 {
     // If the transform is not invertible, then assume that this point doesn't hit this rect.
     if (!localSpaceToScreenSpaceTransform.isInvertible())
         return false;
 
     // Transform the hit test point from screen space to the local space of the given rect.
     bool clipped = false;
@@ skipping 54 matching lines @@
 
         foundLayer = currentLayer;
         break;
     }
 
     // This can potentially return 0, which means the viewportPoint did not successfully hit test any layers, not even the root layer.
     return foundLayer;
 }
 
 } // namespace cc