Remove root layer specialness in calculateDrawTransforms

This patch is step 2 in removing root layer specialness. The previous patch removed root
layer specialness from code outside of CCLayerTreeHostCommon, this patch removes it from
within CCLayerTreeHostCommon.

One subtle semantics change occurs with this patch, that only affects tests and not
real-world code: The root renderSurface now re-parents the root layer's drawTransform. In
practice, the root layer's drawTransform is always an identity matrix, so it does not
matter.

BUG=154442


Review URL: https://chromiumcodereview.appspot.com/11276061

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@165000 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 66 insertions, 56 deletions

diff --git a/cc/layer_tree_host_common.cc b/cc/layer_tree_host_common.cc
index 92b44d1..b51fd00 100644
--- a/cc/layer_tree_host_common.cc
+++ b/cc/layer_tree_host_common.cc
@@ -53,6 +53,12 @@ IntRect LayerTreeHostCommon::calculateVisibleRect(const IntRect& targetSurfaceRe
     return layerRect;
 }
 
+template <typename LayerType>
+static inline bool isRootLayer(LayerType* layer)
+{
+    return !layer->parent();
+}
+
 template<typename LayerType>
 static inline bool layerIsInExisting3DRenderingContext(LayerType* layer)
 {
@@ -62,7 +68,7 @@ static inline bool layerIsInExisting3DRenderingContext(LayerType* layer)
 }
 
 template<typename LayerType>
-static bool layerIsRootOfNewRenderingContext(LayerType* layer)
+static bool isRootLayerOfNewRenderingContext(LayerType* layer)
 {
     // According to current W3C spec on CSS transforms (Section 6.1), a layer is the
     // beginning of 3d rendering context if its parent does not have transform-style:
@@ -95,7 +101,7 @@ static bool isSurfaceBackFaceVisible(LayerType* layer, const WebTransformationMa
     if (layerIsInExisting3DRenderingContext(layer))
         return drawTransform.isBackFaceVisible();
 
-    if (layerIsRootOfNewRenderingContext(layer))
+    if (isRootLayerOfNewRenderingContext(layer))
         return layer->transform().isBackFaceVisible();
 
     // If the renderSurface is not part of a new or existing rendering context, then the
@@ -218,18 +224,14 @@ static inline bool subtreeShouldBeSkipped(Layer* layer)
 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 RenderSurfaceImpl if any of these rules hold:
     //
 
+    // The root layer should always have a renderSurface.
+    if (isRootLayer(layer))
+        return true;
+
     // If we force it.
     if (layer->forceRenderSurface())
         return true;
@@ -246,6 +248,9 @@ static bool subtreeShouldRenderToSeparateSurface(LayerType* layer, bool axisAlig
     if (!layer->filters().isEmpty() || !layer->backgroundFilters().isEmpty() || layer->filter())
         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)
@@ -307,8 +312,8 @@ WebTransformationMatrix computeScrollCompensationMatrixForChildren(LayerImpl* la
     //    it is fixed to an ancestor, and is a container for any fixed-position descendants.
     //  - A layer that is a fixed-position container and has a renderSurface should behave the same as a container
     //    without a renderSurface, the renderSurface is irrelevant in that case.
-    //  - A layer that does not have an explicit container is simply fixed to the viewport
-    //    (i.e. the root renderSurface, and it would still compensate for root layer's scrollDelta).
+    //  - A layer that does not have an explicit container is simply fixed to the viewport.
+    //    (i.e. the root renderSurface.)
     //  - If the fixed-position layer has its own renderSurface, then the renderSurface is
     //    the one who gets fixed.
     //
@@ -377,24 +382,10 @@ static inline void updateLayerContentsScale(Layer* layer, const WebTransformatio
         replicaMaskLayer->setContentsScale(contentsScale);
 }
 
-// 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();
-
-    DCHECK(renderSurfaceLayerList.empty());
-    renderSurfaceLayerList.push_back(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,
+static void calculateDrawTransformsInternal(LayerType* layer, const WebTransformationMatrix& parentMatrix,
     const WebTransformationMatrix& fullHierarchyMatrix, const WebTransformationMatrix& currentScrollCompensationMatrix,
     const IntRect& clipRectFromAncestor, bool ancestorClipsSubtree,
     RenderSurfaceType* nearestAncestorThatMovesPixels, LayerList& renderSurfaceLayerList, LayerList& layerList,
@@ -485,7 +476,8 @@ static void calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLay
     // 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 (!isRootLayer(layer) && subtreeShouldBeSkipped(layer))
         return;
 
     IntRect clipRectForSubtree;
@@ -642,6 +634,8 @@ static void calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLay
 
         renderSurfaceLayerList.push_back(layer);
     } else {
+        DCHECK(layer->parent());
+
         layer->setDrawTransform(drawTransform);
         layer->setDrawTransformIsAnimating(animatingTransformToTarget);
         layer->setScreenSpaceTransformIsAnimating(animatingTransformToScreen);
@@ -650,25 +644,15 @@ static void calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLay
         layer->setDrawOpacity(drawOpacity);
         layer->setDrawOpacityIsAnimating(drawOpacityIsAnimating);
 
-        if (layer != rootLayer) {
-            DCHECK(layer->parent());
-            layer->clearRenderSurface();
+        layer->clearRenderSurface();
 
-            // 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
-            DCHECK(!layer->parent());
-            DCHECK(layer->renderSurface());
-            DCHECK(ancestorClipsSubtree);
-            layer->renderSurface()->setClipRect(clipRectFromAncestor);
-            subtreeShouldBeClipped = false;
-        }
+        // 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());
     }
 
     IntRect rectInTargetSpace = enclosingIntRect(MathUtil::mapClippedRect(layer->drawTransform(), contentRect));
@@ -705,7 +689,7 @@ static void calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLay
     for (size_t i = 0; i < layer->children().size(); ++i) {
         LayerType* child = LayerTreeHostCommon::getChildAsRawPtr(layer->children(), i);
         IntRect drawableContentRectOfChildSubtree;
-        calculateDrawTransformsInternal<LayerType, LayerList, RenderSurfaceType, LayerSorter>(child, rootLayer, sublayerMatrix, nextHierarchyMatrix, nextScrollCompensationMatrix,
+        calculateDrawTransformsInternal<LayerType, LayerList, RenderSurfaceType, LayerSorter>(child, sublayerMatrix, nextHierarchyMatrix, nextScrollCompensationMatrix,
                                                                                               clipRectForSubtree, subtreeShouldBeClipped, nearestAncestorThatMovesPixels,
                                                                                               renderSurfaceLayerList, descendants, layerSorter, maxTextureSize, deviceScaleFactor, pageScaleFactor, drawableContentRectOfChildSubtree);
         if (!drawableContentRectOfChildSubtree.isEmpty()) {
@@ -733,7 +717,11 @@ static void calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLay
     layer->setVisibleContentRect(visibleContentRectOfLayer);
 
     // Compute the remaining properties for the render surface, if the layer has one.
-    if (layer->renderSurface() && layer != rootLayer) {
+    if (isRootLayer(layer)) {
+        // The root layer's surface's contentRect is always the entire viewport.
+        DCHECK(layer->renderSurface());
+        layer->renderSurface()->setContentRect(clipRectFromAncestor);
+    } else if (layer->renderSurface() && !isRootLayer(layer)) {
         RenderSurfaceType* renderSurface = layer->renderSurface();
         IntRect clippedContentRect = localDrawableContentRectOfSubtree;
 
@@ -830,14 +818,25 @@ void LayerTreeHostCommon::calculateDrawTransforms(Layer* rootLayer, const IntSiz
     WebTransformationMatrix identityMatrix;
     WebTransformationMatrix deviceScaleTransform;
     deviceScaleTransform.scale(deviceScaleFactor);
+    std::vector<scoped_refptr<Layer> > dummyLayerList;
+
+    // The root layer's renderSurface should receive the deviceViewport as the initial clipRect.
+    bool subtreeShouldBeClipped = true;
+    IntRect deviceViewportRect(IntPoint::zero(), deviceViewportSize);
 
-    setupRootLayerAndSurfaceForRecursion<Layer, std::vector<scoped_refptr<Layer> > >(rootLayer, renderSurfaceLayerList, deviceViewportSize);
+    // This function should have received a root layer.
+    DCHECK(isRootLayer(rootLayer));
 
     cc::calculateDrawTransformsInternal<Layer, std::vector<scoped_refptr<Layer> >, RenderSurface, void>(
-        rootLayer, rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
-        rootLayer->renderSurface()->contentRect(), true, 0, renderSurfaceLayerList,
-        rootLayer->renderSurface()->layerList(), 0, maxTextureSize,
+        rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
+        deviceViewportRect, subtreeShouldBeClipped, 0, renderSurfaceLayerList,
+        dummyLayerList, 0, maxTextureSize,
         deviceScaleFactor, pageScaleFactor, totalDrawableContentRect);
+
+    // The dummy layer list should not have been used.
+    DCHECK(dummyLayerList.size() == 0);
+    // A root layer renderSurface should always exist after calculateDrawTransforms.
+    DCHECK(rootLayer->renderSurface());
 }
 
 void LayerTreeHostCommon::calculateDrawTransforms(LayerImpl* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, LayerSorter* layerSorter, int maxTextureSize, std::vector<LayerImpl*>& renderSurfaceLayerList)
@@ -846,14 +845,25 @@ void LayerTreeHostCommon::calculateDrawTransforms(LayerImpl* rootLayer, const In
     WebTransformationMatrix identityMatrix;
     WebTransformationMatrix deviceScaleTransform;
     deviceScaleTransform.scale(deviceScaleFactor);
+    std::vector<LayerImpl*> dummyLayerList;
+
+    // The root layer's renderSurface should receive the deviceViewport as the initial clipRect.
+    bool subtreeShouldBeClipped = true;
+    IntRect deviceViewportRect(IntPoint::zero(), deviceViewportSize);
 
-    setupRootLayerAndSurfaceForRecursion<LayerImpl, std::vector<LayerImpl*> >(rootLayer, renderSurfaceLayerList, deviceViewportSize);
+    // This function should have received a root layer.
+    DCHECK(isRootLayer(rootLayer));
 
     cc::calculateDrawTransformsInternal<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerSorter>(
-        rootLayer, rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
-        rootLayer->renderSurface()->contentRect(), true, 0, renderSurfaceLayerList,
-        rootLayer->renderSurface()->layerList(), layerSorter, maxTextureSize,
+        rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
+        deviceViewportRect, subtreeShouldBeClipped, 0, renderSurfaceLayerList,
+        dummyLayerList, layerSorter, maxTextureSize,
         deviceScaleFactor, pageScaleFactor, totalDrawableContentRect);
+
+    // The dummy layer list should not have been used.
+    DCHECK(dummyLayerList.size() == 0);
+    // A root layer renderSurface should always exist after calculateDrawTransforms.
+    DCHECK(rootLayer->renderSurface());
 }
 
 static bool pointHitsRect(const IntPoint& screenSpacePoint, const WebTransformationMatrix& localSpaceToScreenSpaceTransform, FloatRect localSpaceRect)