Reduce more matrix math in calculateDrawProperties

cc/layer_tree_host_common.cc

 // 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 "cc/layer_tree_host_common.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "cc/layer.h"
@@ skipping 22 matching lines @@
     NOTREACHED();
 }
 
 static void sortLayers(std::vector<LayerImpl*>::iterator first, std::vector<LayerImpl*>::iterator end, LayerSorter* layerSorter)
 {
     DCHECK(layerSorter);
     TRACE_EVENT0("cc", "layer_tree_host_common::sortLayers");
     layerSorter->sort(first, end);
 }
 
-gfx::Rect LayerTreeHostCommon::calculateVisibleRect(const gfx::Rect& targetSurfaceRect, const gfx::Rect& layerBoundRect, const gfx::Transform& transform)
+static inline gfx::Rect calculateVisibleRectWithCachedLayerRect(const gfx::Rect& targetSurfaceRect, const gfx::Rect& layerBoundRect, const gfx::Rect& layerRectInTargetSpace, const gfx::Transform& transform)

[jamesr, 2012/12/11 19:13:21]

i think the 'static' and 'inline' here are redundant - 'inline' implies static
linkage, no?

[shawnsingh, 2012/12/11 22:33:18]

Done.

 {
     // Is this layer fully contained within the target surface?
-    gfx::Rect layerInSurfaceSpace = MathUtil::mapClippedRect(transform, layerBoundRect);
-    if (targetSurfaceRect.Contains(layerInSurfaceSpace))
+    if (targetSurfaceRect.Contains(layerRectInTargetSpace))
         return layerBoundRect;
 
     // If the layer doesn't fill up the entire surface, then find the part of
     // the surface rect where the layer could be visible. This avoids trying to
     // project surface rect points that are behind the projection point.
     gfx::Rect minimalSurfaceRect = targetSurfaceRect;
-    minimalSurfaceRect.Intersect(layerInSurfaceSpace);
+    minimalSurfaceRect.Intersect(layerRectInTargetSpace);
 
     // Project the corners of the target surface rect into the layer space.
     // This bounding rectangle may be larger than it needs to be (being
     // axis-aligned), but is a reasonable filter on the space to consider.
     // Non-invertible transforms will create an empty rect here.
     const gfx::Transform surfaceToLayer = MathUtil::inverse(transform);
     gfx::Rect layerRect = gfx::ToEnclosingRect(MathUtil::projectClippedRect(surfaceToLayer, gfx::RectF(minimalSurfaceRect)));
     layerRect.Intersect(layerBoundRect);
     return layerRect;
 }
 
+gfx::Rect LayerTreeHostCommon::calculateVisibleRect(const gfx::Rect& targetSurfaceRect, const gfx::Rect& layerBoundRect, const gfx::Transform& transform)
+{
+    gfx::Rect layerInSurfaceSpace = MathUtil::mapClippedRect(transform, layerBoundRect);
+    return calculateVisibleRectWithCachedLayerRect(targetSurfaceRect, layerBoundRect, layerInSurfaceSpace, transform);
+}
+
 template <typename LayerType>
 static inline bool isRootLayer(LayerType* layer)
 {
     return !layer->parent();
 }
 
 template<typename LayerType>
 static inline bool layerIsInExisting3DRenderingContext(LayerType* layer)
 {
     // According to current W3C spec on CSS transforms, a layer is part of an established
@@ skipping 43 matching lines @@
     return false;
 }
 
 template<typename LayerType>
 static inline bool layerClipsSubtree(LayerType* layer)
 {
     return layer->masksToBounds() || layer->maskLayer();
 }
 
 template<typename LayerType>
-static gfx::Rect calculateVisibleContentRect(LayerType* layer)
+static gfx::Rect calculateVisibleContentRect(LayerType* layer, const gfx::Rect& ancestorClipRectInDescendantSurfaceSpace, const gfx::Rect& layerRectInTargetSpace)
 {
     DCHECK(layer->renderTarget());
 
     // Nothing is visible if the layer bounds are empty.
     if (!layer->drawsContent() || layer->contentBounds().IsEmpty() || layer->drawableContentRect().IsEmpty())
         return gfx::Rect();
 
-    gfx::Rect targetSurfaceClipRect;
+    // Compute visible bounds in target surface space.
+    gfx::Rect visibleRectInTargetSurfaceSpace = layer->drawableContentRect();
 
-    // First, compute visible bounds in target surface space.
-    if (layer->renderTarget()->renderSurface()->clipRect().IsEmpty())
-        targetSurfaceClipRect = layer->drawableContentRect();
-    else {
+    if (!layer->renderTarget()->renderSurface()->clipRect().IsEmpty()) {
+        //gfx::Rect ancestorSurfaceClipRect = gfx::ToEnclosingRect(MathUtil::projectClippedRect(MathUtil::inverse(layer->renderTarget()->renderSurface()->drawTransform()), layer->renderTarget()->renderSurface()->clipRect()));

[jamesr, 2012/12/11 19:13:21]

?

[shawnsingh, 2012/12/11 22:33:18]

residue from debugging =)   it's removed now

+        //visibleRectInTargetSurfaceSpace.Intersect(ancestorSurfaceClipRect);
+
         // In this case the target surface does clip layers that contribute to it. So, we
         // have convert the current surface's clipRect from its ancestor surface space to
         // the current surface space.
-        targetSurfaceClipRect = gfx::ToEnclosingRect(MathUtil::projectClippedRect(MathUtil::inverse(layer->renderTarget()->renderSurface()->drawTransform()), layer->renderTarget()->renderSurface()->clipRect()));
-        targetSurfaceClipRect.Intersect(layer->drawableContentRect());
+        //gfx::Rect ancestorSurfaceClipRect = gfx::ToEnclosingRect(MathUtil::projectClippedRect(MathUtil::inverse(layer->renderTarget()->renderSurface()->drawTransform()), layer->renderTarget()->renderSurface()->clipRect()));
+
+        visibleRectInTargetSurfaceSpace.Intersect(ancestorClipRectInDescendantSurfaceSpace);
     }
 
-    if (targetSurfaceClipRect.IsEmpty())
+    if (visibleRectInTargetSurfaceSpace.IsEmpty())
         return gfx::Rect();
 
-    return LayerTreeHostCommon::calculateVisibleRect(targetSurfaceClipRect, gfx::Rect(gfx::Point(), layer->contentBounds()), layer->drawTransform());
+    return calculateVisibleRectWithCachedLayerRect(visibleRectInTargetSurfaceSpace, gfx::Rect(gfx::Point(), layer->contentBounds()), layerRectInTargetSpace, layer->drawTransform());
 }
 
 static inline bool transformToParentIsKnown(LayerImpl*)
 {
     return true;
 }
 
 static inline bool transformToParentIsKnown(Layer* layer)
 {
     return !layer->transformIsAnimating();
@@ skipping 230 matching lines @@
 
     Layer* maskLayer = layer->maskLayer();
     if (maskLayer)
         maskLayer->setContentsScale(contentsScale);
 
     Layer* replicaMaskLayer = layer->replicaLayer() ? layer->replicaLayer()->maskLayer() : 0;
     if (replicaMaskLayer)
         replicaMaskLayer->setContentsScale(contentsScale);
 }
 
+template<typename LayerType, typename LayerList>
+static inline void removeSurfaceForEarlyExit(LayerType* layerToRemove, LayerList& renderSurfaceLayerList)
+{
+    DCHECK(layerToRemove->renderSurface());
+    // Technically, we know that the layer we want to remove should be
+    // at the back of the renderSurfaceLayerList. However, we have had
+    // bugs before that added unnecessary layers here
+    // (https://bugs.webkit.org/show_bug.cgi?id=74147), but that causes
+    // things to crash. So here we proactively remove any additional
+    // layers from the end of the list.
+    while (renderSurfaceLayerList.back() != layerToRemove) {
+        renderSurfaceLayerList.back()->clearRenderSurface();
+        renderSurfaceLayerList.pop_back();
+    }
+    DCHECK(renderSurfaceLayerList.back() == layerToRemove);
+    renderSurfaceLayerList.pop_back();
+    layerToRemove->clearRenderSurface();
+}
+
 // 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>
 static void calculateDrawPropertiesInternal(LayerType* layer, const gfx::Transform& parentMatrix,
     const gfx::Transform& fullHierarchyMatrix, const gfx::Transform& currentScrollCompensationMatrix,
-    const gfx::Rect& clipRectFromAncestor, bool ancestorClipsSubtree,
+    const gfx::Rect& clipRectFromAncestor, const gfx::Rect& clipRectFromAncestorInDescendantSpace, bool ancestorClipsSubtree,
     RenderSurfaceType* nearestAncestorThatMovesPixels, LayerList& renderSurfaceLayerList, LayerList& layerList,
     LayerSorter* layerSorter, int maxTextureSize, float deviceScaleFactor, float pageScaleFactor, gfx::Rect& drawableContentRectOfSubtree)
 {
     // This function computes the new matrix transformations recursively for this
     // layer and all its descendants. It also computes the appropriate render surfaces.
     // Some important points to remember:
     //
     // 0. Here, transforms are notated in Matrix x Vector order, and in words we describe what
     //    the transform does from left to right.
     //
@@ skipping 81 matching lines @@
 
     // As this function proceeds, these are the properties for the current
     // layer that actually get computed. To avoid unnecessary copies
     // (particularly for matrices), we do computations directly on these values
     // when possible.
     DrawProperties<LayerType, RenderSurfaceType>& layerDrawProperties = layer->drawProperties();
 
     gfx::Rect clipRectForSubtree;
     bool subtreeShouldBeClipped = false;
 
+    // This value is cached on the stack so that we don't have to inverse-project
+    // the surface's clipRect redundantly for every layer. This value is the
+    // same as the surface's clipRect, except that instead of being described
+    // in the target surface space (i.e. the ancestor surface space), it is
+    // described in the current surface space.
+    gfx::Rect clipRectForSubtreeInDescendantSpace;
+
     float accumulatedDrawOpacity = layer->opacity();
     bool drawOpacityIsAnimating = layer->opacityIsAnimating();
     if (layer->parent()) {
         accumulatedDrawOpacity *= layer->parent()->drawOpacity();
         drawOpacityIsAnimating |= layer->parent()->drawOpacityIsAnimating();
     }
 
     bool animatingTransformToTarget = layer->transformIsAnimating();
     bool animatingTransformToScreen = animatingTransformToTarget;
     if (layer->parent()) {
         animatingTransformToTarget |= layer->parent()->drawTransformIsAnimating();
         animatingTransformToScreen |= layer->parent()->screenSpaceTransformIsAnimating();
     }
 
     gfx::Size bounds = layer->bounds();
     gfx::PointF anchorPoint = layer->anchorPoint();
     gfx::PointF position = layer->position() - layer->scrollDelta();
 
     gfx::Transform combinedTransform = parentMatrix;
-    // LT = Tr[origin] * Tr[origin2anchor]
-    combinedTransform.Translate3d(position.x() + anchorPoint.x() * bounds.width(), position.y() + anchorPoint.y() * bounds.height(), layer->anchorPointZ());
-    // LT = Tr[origin] * Tr[origin2anchor] * M[layer]
-    combinedTransform.PreconcatTransform(layer->transform());
-    // LT = Tr[origin] * Tr[origin2anchor] * M[layer] * Tr[anchor2origin]
-    combinedTransform.Translate3d(-anchorPoint.x() * bounds.width(), -anchorPoint.y() * bounds.height(), -layer->anchorPointZ());
+    if (!layer->transform().IsIdentity()) {
+        // LT = Tr[origin] * Tr[origin2anchor]
+        combinedTransform.Translate3d(position.x() + anchorPoint.x() * bounds.width(), position.y() + anchorPoint.y() * bounds.height(), layer->anchorPointZ());
+        // LT = Tr[origin] * Tr[origin2anchor] * M[layer]
+        combinedTransform.PreconcatTransform(layer->transform());
+        // LT = Tr[origin] * Tr[origin2anchor] * M[layer] * Tr[anchor2origin]
+        combinedTransform.Translate3d(-anchorPoint.x() * bounds.width(), -anchorPoint.y() * bounds.height(), -layer->anchorPointZ());
+    } else {
+        combinedTransform.Translate(position.x(), position.y());
+    }
 
     // The layer's contentsSize is determined from the combinedTransform, which then informs the
     // layer's drawTransform.
     updateLayerContentsScale(layer, combinedTransform, deviceScaleFactor, pageScaleFactor, animatingTransformToScreen);
 
     // If there is a transformation from the impl thread then it should be at
     // the start of the combinedTransform, but we don't want it to affect the
     // computation of contentsScale above.
     // Note carefully: this is Concat, not Preconcat (implTransform * combinedTransform).
     combinedTransform.ConcatTransform(layer->implTransform());
@@ skipping 90 matching lines @@
             replicaMaskDrawProperties.visible_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds());
         }
 
         // FIXME:  make this smarter for the SkImageFilter case (check for
         //         pixel-moving filters)
         if (layer->filters().hasFilterThatMovesPixels() || layer->filter())
             nearestAncestorThatMovesPixels = renderSurface;
 
         // The render surface clipRect is expressed in the space where this surface draws, i.e. the same space as clipRectFromAncestor.
         renderSurface->setIsClipped(ancestorClipsSubtree);
-        if (ancestorClipsSubtree)
+        if (ancestorClipsSubtree) {
             renderSurface->setClipRect(clipRectFromAncestor);
-        else
+            clipRectForSubtreeInDescendantSpace = gfx::ToEnclosingRect(MathUtil::projectClippedRect(MathUtil::inverse(renderSurface->drawTransform()), renderSurface->clipRect()));
+        } else {
             renderSurface->setClipRect(gfx::Rect());
+            clipRectForSubtreeInDescendantSpace = clipRectFromAncestorInDescendantSpace;
+        }
 
         renderSurface->setNearestAncestorThatMovesPixels(nearestAncestorThatMovesPixels);
 
         renderSurfaceLayerList.push_back(layer);
     } else {
         DCHECK(layer->parent());
 
         // Note: layerDrawProperties.target_space_transform is computed above,
         // before this if-else statement.
         layerDrawProperties.target_space_transform_is_animating = animatingTransformToTarget;
         layerDrawProperties.screen_space_transform_is_animating = animatingTransformToScreen;
         layerDrawProperties.opacity = accumulatedDrawOpacity;
         layerDrawProperties.opacity_is_animating = drawOpacityIsAnimating;
         sublayerMatrix = combinedTransform;
 
         layer->clearRenderSurface();
 
         // Layers without renderSurfaces directly inherit the ancestor's clip status.
         subtreeShouldBeClipped = ancestorClipsSubtree;
         if (ancestorClipsSubtree)
             clipRectForSubtree = clipRectFromAncestor;
 
+        // The surface's cached clipRect value propagates regardless of what clipping goes on between layers here.
+        clipRectForSubtreeInDescendantSpace = clipRectFromAncestorInDescendantSpace;
+
         // Layers that are not their own renderTarget will render into the target of their nearest ancestor.
         layerDrawProperties.render_target = layer->parent()->renderTarget();
     }
 
     gfx::Rect rectInTargetSpace = ToEnclosingRect(MathUtil::mapClippedRect(layer->drawTransform(), contentRect));
 
     if (layerClipsSubtree(layer)) {
         subtreeShouldBeClipped = true;
         if (ancestorClipsSubtree && !layer->renderSurface()) {
             clipRectForSubtree = clipRectFromAncestor;
@@ skipping 21 matching lines @@
     if (!layerShouldBeSkipped(layer))
         descendants.push_back(layer);
 
     gfx::Transform nextScrollCompensationMatrix = computeScrollCompensationMatrixForChildren(layer, parentMatrix, currentScrollCompensationMatrix);;
 
     gfx::Rect accumulatedDrawableContentRectOfChildren;
     for (size_t i = 0; i < layer->children().size(); ++i) {
         LayerType* child = LayerTreeHostCommon::getChildAsRawPtr(layer->children(), i);
         gfx::Rect drawableContentRectOfChildSubtree;
         calculateDrawPropertiesInternal<LayerType, LayerList, RenderSurfaceType>(child, sublayerMatrix, nextHierarchyMatrix, nextScrollCompensationMatrix,
-                                                                                 clipRectForSubtree, subtreeShouldBeClipped, nearestAncestorThatMovesPixels,
+                                                                                 clipRectForSubtree, clipRectForSubtreeInDescendantSpace, subtreeShouldBeClipped, nearestAncestorThatMovesPixels,
                                                                                  renderSurfaceLayerList, descendants, layerSorter, maxTextureSize, deviceScaleFactor, pageScaleFactor, drawableContentRectOfChildSubtree);
         if (!drawableContentRectOfChildSubtree.IsEmpty()) {
             accumulatedDrawableContentRectOfChildren.Union(drawableContentRectOfChildSubtree);
             if (child->renderSurface())
                 descendants.push_back(child);
         }
     }
 
+    if (layer->renderSurface() && !isRootLayer(layer) && !layer->renderSurface()->layerList().size()) {
+        removeSurfaceForEarlyExit(layer, renderSurfaceLayerList);
+        return;
+    }
+    
     // Compute the total drawableContentRect for this subtree (the rect is in targetSurface space)
     gfx::Rect localDrawableContentRectOfSubtree = accumulatedDrawableContentRectOfChildren;
     if (layer->drawsContent())
         localDrawableContentRectOfSubtree.Union(rectInTargetSpace);
     if (subtreeShouldBeClipped)
         localDrawableContentRectOfSubtree.Intersect(clipRectForSubtree);
 
     // Compute the layer's drawable content rect (the rect is in targetSurface space)
     layerDrawProperties.drawable_content_rect = rectInTargetSpace;
     if (subtreeShouldBeClipped)
         layerDrawProperties.drawable_content_rect.Intersect(clipRectForSubtree);
 
     // Tell the layer the rect that is clipped by. In theory we could use a
     // tighter clipRect here (drawableContentRect), but that actually does not
     // reduce how much would be drawn, and instead it would create unnecessary
     // changes to scissor state affecting GPU performance.
     layerDrawProperties.is_clipped = subtreeShouldBeClipped;
     if (subtreeShouldBeClipped)
         layerDrawProperties.clip_rect = clipRectForSubtree;
     else {
         // Initialize the clipRect to a safe value that will not clip the
         // layer, just in case clipping is still accidentally used.
         layerDrawProperties.clip_rect = rectInTargetSpace;
     }
 
     // Compute the layer's visible content rect (the rect is in content space)
-    layerDrawProperties.visible_content_rect = calculateVisibleContentRect(layer);
+    layerDrawProperties.visible_content_rect = calculateVisibleContentRect(layer, clipRectForSubtreeInDescendantSpace, rectInTargetSpace);
 
     // Compute the remaining properties for the render surface, if the layer has one.
     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();
         gfx::Rect 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()) {
                 gfx::Rect surfaceClipRect = LayerTreeHostCommon::calculateVisibleRect(renderSurface->clipRect(), clippedContentRect, renderSurface->drawTransform());
                 clippedContentRect.Intersect(surfaceClipRect);
             }
         }
 
         // The RenderSurfaceImpl backing texture cannot exceed the maximum supported
         // texture size.
         clippedContentRect.set_width(std::min(clippedContentRect.width(), maxTextureSize));
         clippedContentRect.set_height(std::min(clippedContentRect.height(), maxTextureSize));
 
-        if (clippedContentRect.IsEmpty())
+        if (clippedContentRect.IsEmpty()) {
             renderSurface->clearLayerLists();
-
+            removeSurfaceForEarlyExit(layer, renderSurfaceLayerList);
+            return;
+        }
+        
         renderSurface->setContentRect(clippedContentRect);
 
         // The owning layer's screenSpaceTransform has a scale from content to layer space which we need to undo and
         // replace with a scale from the surface's subtree into layer space.
         gfx::Transform screenSpaceTransform = layer->screenSpaceTransform();
         screenSpaceTransform.Scale(layer->contentsScaleX() / renderSurfaceSublayerScale.x(), layer->contentsScaleY() / renderSurfaceSublayerScale.y());
         renderSurface->setScreenSpaceTransform(screenSpaceTransform);
 
         if (layer->replicaLayer()) {
             gfx::Transform surfaceOriginToReplicaOriginTransform;
             surfaceOriginToReplicaOriginTransform.Scale(renderSurfaceSublayerScale.x(), renderSurfaceSublayerScale.y());
             surfaceOriginToReplicaOriginTransform.Translate(layer->replicaLayer()->position().x() + layer->replicaLayer()->anchorPoint().x() * bounds.width(),
                                                             layer->replicaLayer()->position().y() + layer->replicaLayer()->anchorPoint().y() * bounds.height());
             surfaceOriginToReplicaOriginTransform.PreconcatTransform(layer->replicaLayer()->transform());
             surfaceOriginToReplicaOriginTransform.Translate(-layer->replicaLayer()->anchorPoint().x() * bounds.width(), -layer->replicaLayer()->anchorPoint().y() * bounds.height());
             surfaceOriginToReplicaOriginTransform.Scale(1 / renderSurfaceSublayerScale.x(), 1 / renderSurfaceSublayerScale.y());
 
             // Compute the replica's "originTransform" that maps from the replica's origin space to the target surface origin space.
             gfx::Transform replicaOriginTransform = layer->renderSurface()->drawTransform() * surfaceOriginToReplicaOriginTransform;
             renderSurface->setReplicaDrawTransform(replicaOriginTransform);
 
             // Compute the replica's "screenSpaceTransform" that maps from the replica's origin space to the screen's origin space.
             gfx::Transform replicaScreenSpaceTransform = layer->renderSurface()->screenSpaceTransform() * surfaceOriginToReplicaOriginTransform;
             renderSurface->setReplicaScreenSpaceTransform(replicaScreenSpaceTransform);
         }
-
-        // If a render surface has no layer list, then it and none of its children needed to get drawn.
-        if (!layer->renderSurface()->layerList().size()) {
-            // FIXME: Originally we asserted that this layer was already at the end of the
-            //        list, and only needed to remove that layer. For now, we remove the
-            //        entire subtree of surfaces to fix a crash bug. The root cause is
-            //        https://bugs.webkit.org/show_bug.cgi?id=74147 and we should be able
-            //        to put the original assert after fixing that.
-            while (renderSurfaceLayerList.back() != layer) {
-                renderSurfaceLayerList.back()->clearRenderSurface();
-                renderSurfaceLayerList.pop_back();
-            }
-            DCHECK(renderSurfaceLayerList.back() == layer);
-            renderSurfaceLayerList.pop_back();
-            layer->clearRenderSurface();
-            return;
-        }
     }
 
     markLayerAsUpdated(layer);
 
     // If neither this layer nor any of its children were added, early out.
     if (sortingStartIndex == descendants.size())
         return;
 
     // If preserves-3d then sort all the descendants in 3D so that they can be
     // drawn from back to front. If the preserves-3d property is also set on the parent then
@@ skipping 20 matching lines @@
 
     // The root layer's renderSurface should receive the deviceViewport as the initial clipRect.
     bool subtreeShouldBeClipped = true;
     gfx::Rect deviceViewportRect(gfx::Point(), deviceViewportSize);
 
     // This function should have received a root layer.
     DCHECK(isRootLayer(rootLayer));
 
     cc::calculateDrawPropertiesInternal<Layer, std::vector<scoped_refptr<Layer> >, RenderSurface>(
         rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
-        deviceViewportRect, subtreeShouldBeClipped, 0, renderSurfaceLayerList,
+        deviceViewportRect, 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 calculateDrawProperties.
     DCHECK(rootLayer->renderSurface());
 }
 
 void LayerTreeHostCommon::calculateDrawProperties(LayerImpl* rootLayer, const gfx::Size& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, int maxTextureSize, std::vector<LayerImpl*>& renderSurfaceLayerList)
 {
     gfx::Rect totalDrawableContentRect;
     gfx::Transform identityMatrix;
     gfx::Transform deviceScaleTransform;
     deviceScaleTransform.Scale(deviceScaleFactor, deviceScaleFactor);
     std::vector<LayerImpl*> dummyLayerList;
     LayerSorter layerSorter;
     
     // The root layer's renderSurface should receive the deviceViewport as the initial clipRect.
     bool subtreeShouldBeClipped = true;
     gfx::Rect deviceViewportRect(gfx::Point(), deviceViewportSize);
 
     // This function should have received a root layer.
     DCHECK(isRootLayer(rootLayer));
 
     cc::calculateDrawPropertiesInternal<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl>(
         rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
-        deviceViewportRect, subtreeShouldBeClipped, 0, renderSurfaceLayerList,
+        deviceViewportRect, 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 calculateDrawProperties.
     DCHECK(rootLayer->renderSurface());
 }
 
 static bool pointHitsRect(const gfx::PointF& screenSpacePoint, const gfx::Transform& localSpaceToScreenSpaceTransform, gfx::RectF localSpaceRect)
@@ skipping 113 matching lines @@
 
         foundLayer = currentLayer;
         break;
     }
 
     // This can potentially return 0, which means the screenSpacePoint did not successfully hit test any layers, not even the root layer.
     return foundLayer;
 }
 
 }  // namespace cc