cc: Apply the layer's initial CSS scale to the contentsScale to render text at the right resolution.

cc/layer_tree_host_common_unittest.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 "config.h"
 
 #include "CCLayerTreeHostCommon.h"
 
 #include "CCAnimationTestCommon.h"
 #include "CCGeometryTestUtils.h"
@@ skipping 33 matching lines @@
 {
     setLayerPropertiesForTesting<LayerChromium>(layer, transform, sublayerTransform, anchor, position, bounds, preserves3D);
 }
 
 void setLayerPropertiesForTesting(CCLayerImpl* layer, const WebTransformationMatrix& transform, const WebTransformationMatrix& sublayerTransform, const FloatPoint& anchor, const FloatPoint& position, const IntSize& bounds, bool preserves3D)
 {
     setLayerPropertiesForTesting<CCLayerImpl>(layer, transform, sublayerTransform, anchor, position, bounds, preserves3D);
     layer->setContentBounds(bounds);
 }
 
-void executeCalculateDrawTransformsAndVisibility(LayerChromium* rootLayer, float deviceScaleFactor = 1)
+void executeCalculateDrawTransformsAndVisibility(LayerChromium* rootLayer, float deviceScaleFactor = 1, float pageScaleFactor = 1)
 {
     WebTransformationMatrix identityMatrix;
     std::vector<scoped_refptr<LayerChromium> > dummyRenderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     IntSize deviceViewportSize = IntSize(rootLayer->bounds().width() * deviceScaleFactor, rootLayer->bounds().height() * deviceScaleFactor);
 
     // We are probably not testing what is intended if the rootLayer bounds are empty.
     ASSERT(!rootLayer->bounds().isEmpty());
-    CCLayerTreeHostCommon::calculateDrawTransforms(rootLayer, deviceViewportSize, deviceScaleFactor, dummyMaxTextureSize, dummyRenderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(rootLayer, deviceViewportSize, deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, dummyRenderSurfaceLayerList);
 }
 
-void executeCalculateDrawTransformsAndVisibility(CCLayerImpl* rootLayer, float deviceScaleFactor = 1)
+void executeCalculateDrawTransformsAndVisibility(CCLayerImpl* rootLayer, float deviceScaleFactor = 1, float pageScaleFactor = 1)
 {
     // Note: this version skips layer sorting.
 
     WebTransformationMatrix identityMatrix;
     std::vector<CCLayerImpl*> dummyRenderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     IntSize deviceViewportSize = IntSize(rootLayer->bounds().width() * deviceScaleFactor, rootLayer->bounds().height() * deviceScaleFactor);
 
     // We are probably not testing what is intended if the rootLayer bounds are empty.
     ASSERT(!rootLayer->bounds().isEmpty());
-    CCLayerTreeHostCommon::calculateDrawTransforms(rootLayer, deviceViewportSize, deviceScaleFactor, 0, dummyMaxTextureSize, dummyRenderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(rootLayer, deviceViewportSize, deviceScaleFactor, pageScaleFactor, 0, dummyMaxTextureSize, dummyRenderSurfaceLayerList);
 }
 
 WebTransformationMatrix remove3DComponentOfMatrix(const WebTransformationMatrix& mat)
 {
     WebTransformationMatrix ret = mat;
     ret.setM13(0);
     ret.setM23(0);
     ret.setM31(0);
     ret.setM32(0);
     ret.setM33(1);
@@ skipping 238 matching lines @@
     WebTransformationMatrix parentLayerTransform;
     parentLayerTransform.scale3d(1, 0.9, 1);
     WebTransformationMatrix parentTranslationToAnchor;
     parentTranslationToAnchor.translate(25, 30);
     WebTransformationMatrix parentSublayerMatrix;
     parentSublayerMatrix.scale3d(0.9, 1, 3.3);
     WebTransformationMatrix parentTranslationToCenter;
     parentTranslationToCenter.translate(50, 60);
     WebTransformationMatrix parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * parentTranslationToAnchor.inverse()
             * parentTranslationToCenter * parentSublayerMatrix * parentTranslationToCenter.inverse();
+    FloatPoint parentCompositeScale = CCMathUtil::computeTransform2dScaleComponents(parentCompositeTransform);
+    WebTransformationMatrix surfaceSublayerTransform;
+    surfaceSublayerTransform.scaleNonUniform(parentCompositeScale.x(), parentCompositeScale.y());
+    WebTransformationMatrix surfaceSublayerCompositeTransform = parentCompositeTransform * surfaceSublayerTransform.inverse();
 
     // Child's render surface should not exist yet.
     ASSERT_FALSE(child->renderSurface());
 
     setLayerPropertiesForTesting(parent.get(), parentLayerTransform, parentSublayerMatrix, FloatPoint(0.25, 0.25), FloatPoint(0, 0), IntSize(100, 120), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(16, 18), false);
     setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(8, 10), false);
     executeCalculateDrawTransformsAndVisibility(parent.get());
 
     // Render surface should have been created now.
     ASSERT_TRUE(child->renderSurface());
     ASSERT_EQ(child, child->renderTarget());
 
     // The child layer's draw transform should refer to its new render surface.
     // The screen-space transform, however, should still refer to the root.
-    EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->drawTransform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(surfaceSublayerTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->screenSpaceTransform());
 
     // Because the grandChild is the only drawable content, the child's renderSurface will tighten its bounds to the grandChild.
-    EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->renderTarget()->renderSurface()->drawTransform());
+    // The scale at which the surface's subtree is drawn must be removed from the composite transform.
+    EXPECT_TRANSFORMATION_MATRIX_EQ(surfaceSublayerCompositeTransform, child->renderTarget()->renderSurface()->drawTransform());
 
     // The screen space is the same as the target since the child surface draws into the root.
-    EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->renderTarget()->renderSurface()->screenSpaceTransform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(surfaceSublayerCompositeTransform, child->renderTarget()->renderSurface()->screenSpaceTransform());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyTransformsForReplica)
 {
     scoped_refptr<LayerChromium> parent = LayerChromium::create();
     scoped_refptr<LayerChromium> child = LayerChromium::create();
     scoped_refptr<LayerChromium> childReplica = LayerChromium::create();
     scoped_refptr<LayerChromiumWithForcedDrawsContent> grandChild = make_scoped_refptr(new LayerChromiumWithForcedDrawsContent());
     parent->addChild(child);
     child->addChild(grandChild);
@@ skipping 10 matching lines @@
     WebTransformationMatrix parentSublayerMatrix;
     parentSublayerMatrix.scale3d(10, 10, 3.3);
     WebTransformationMatrix parentTranslationToCenter;
     parentTranslationToCenter.translate(5, 6);
     WebTransformationMatrix parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * parentTranslationToAnchor.inverse()
             * parentTranslationToCenter * parentSublayerMatrix * parentTranslationToCenter.inverse();
     WebTransformationMatrix childTranslationToCenter;
     childTranslationToCenter.translate(8, 9);
     WebTransformationMatrix replicaLayerTransform;
     replicaLayerTransform.scale3d(3, 3, 1);
-    WebTransformationMatrix replicaCompositeTransform = parentCompositeTransform * replicaLayerTransform;
+    FloatPoint parentCompositeScale = CCMathUtil::computeTransform2dScaleComponents(parentCompositeTransform);
+    WebTransformationMatrix surfaceSublayerTransform;
+    surfaceSublayerTransform.scaleNonUniform(parentCompositeScale.x(), parentCompositeScale.y());
+    WebTransformationMatrix replicaCompositeTransform = parentCompositeTransform * replicaLayerTransform * surfaceSublayerTransform.inverse();
 
     // Child's render surface should not exist yet.
     ASSERT_FALSE(child->renderSurface());
 
     setLayerPropertiesForTesting(parent.get(), parentLayerTransform, parentSublayerMatrix, FloatPoint(0.25, 0.25), FloatPoint(0, 0), IntSize(10, 12), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(16, 18), false);
     setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(-0.5, -0.5), IntSize(1, 1), false);
     setLayerPropertiesForTesting(childReplica.get(), replicaLayerTransform, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(0, 0), false);
     executeCalculateDrawTransformsAndVisibility(parent.get());
 
@@ skipping 56 matching lines @@
     WebTransformationMatrix sublayerTransform;
     sublayerTransform.scale3d(10, 1, 1);
     WebTransformationMatrix replicaLayerTransform;
     replicaLayerTransform.scale3d(-2, 5, 1);
 
     WebTransformationMatrix A = translationToAnchor * layerTransform * translationToAnchor.inverse();
     WebTransformationMatrix B = translationToCenter * sublayerTransform * translationToCenter.inverse();
     WebTransformationMatrix R = A * translationToAnchor * replicaLayerTransform * translationToAnchor.inverse();
     WebTransformationMatrix identityMatrix;
 
+    FloatPoint surface1ParentTransformScale = CCMathUtil::computeTransform2dScaleComponents(A * B);
+    WebTransformationMatrix surface1SublayerTransform;
+    surface1SublayerTransform.scaleNonUniform(surface1ParentTransformScale.x(), surface1ParentTransformScale.y());
+
+    // SS1 = transform given to the subtree of renderSurface1
+    WebTransformationMatrix SS1 = surface1SublayerTransform;
+    // S1 = transform to move from renderSurface1 pixels to the layer space of the owning layer
+    WebTransformationMatrix S1 = surface1SublayerTransform.inverse();
+
+    FloatPoint surface2ParentTransformScale = CCMathUtil::computeTransform2dScaleComponents(SS1 * A * B);
+    WebTransformationMatrix surface2SublayerTransform;
+    surface2SublayerTransform.scaleNonUniform(surface2ParentTransformScale.x(), surface2ParentTransformScale.y());
+
+    // SS2 = transform given to the subtree of renderSurface2
+    WebTransformationMatrix SS2 = surface2SublayerTransform;
+    // S2 = transform to move from renderSurface2 pixels to the layer space of the owning layer
+    WebTransformationMatrix S2 = surface2SublayerTransform.inverse();
+
     setLayerPropertiesForTesting(parent.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);
     setLayerPropertiesForTesting(renderSurface1.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);
     setLayerPropertiesForTesting(renderSurface2.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);
     setLayerPropertiesForTesting(childOfRoot.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);
     setLayerPropertiesForTesting(childOfRS1.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);
     setLayerPropertiesForTesting(childOfRS2.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);
     setLayerPropertiesForTesting(grandChildOfRoot.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);
     setLayerPropertiesForTesting(grandChildOfRS1.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);
     setLayerPropertiesForTesting(grandChildOfRS2.get(), layerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(10, 10), false);
     setLayerPropertiesForTesting(replicaOfRS1.get(), replicaLayerTransform, sublayerTransform, FloatPoint(0.25, 0), FloatPoint(0, 0), IntSize(), false);
@@ skipping 30 matching lines @@
     EXPECT_EQ(renderSurface2, grandChildOfRS2->renderTarget());
 
     // Verify layer draw transforms
     //  note that draw transforms are described with respect to the nearest ancestor render surface
     //  but screen space transforms are described with respect to the root.
     //
     EXPECT_TRANSFORMATION_MATRIX_EQ(A, parent->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A, childOfRoot->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A, grandChildOfRoot->drawTransform());
 
-    EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, renderSurface1->drawTransform());
-    EXPECT_TRANSFORMATION_MATRIX_EQ(B * A, childOfRS1->drawTransform());
-    EXPECT_TRANSFORMATION_MATRIX_EQ(B * A * B * A, grandChildOfRS1->drawTransform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(SS1, renderSurface1->drawTransform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(SS1 * B * A, childOfRS1->drawTransform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(SS1 * B * A * B * A, grandChildOfRS1->drawTransform());
 
-    EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, renderSurface2->drawTransform());
-    EXPECT_TRANSFORMATION_MATRIX_EQ(B * A, childOfRS2->drawTransform());
-    EXPECT_TRANSFORMATION_MATRIX_EQ(B * A * B * A, grandChildOfRS2->drawTransform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(SS2, renderSurface2->drawTransform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(SS2 * B * A, childOfRS2->drawTransform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(SS2 * B * A * B * A, grandChildOfRS2->drawTransform());
 
     // Verify layer screen-space transforms
     //
     EXPECT_TRANSFORMATION_MATRIX_EQ(A, parent->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A, childOfRoot->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A, grandChildOfRoot->screenSpaceTransform());
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A, renderSurface1->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A, childOfRS1->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A * B * A, grandChildOfRS1->screenSpaceTransform());
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A, renderSurface2->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A * B * A, childOfRS2->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A * B * A * B * A, grandChildOfRS2->screenSpaceTransform());
 
     // Verify render surface transforms.
     //
     // Draw transform of render surface 1 is described with respect to root.
-    EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A, renderSurface1->renderSurface()->drawTransform());
-    EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * R, renderSurface1->renderSurface()->replicaDrawTransform());
-    EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A, renderSurface1->renderSurface()->screenSpaceTransform());
-    EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * R, renderSurface1->renderSurface()->replicaScreenSpaceTransform());
-    // Draw transform of render surface 2 is described with respect to render surface 2.
-    EXPECT_TRANSFORMATION_MATRIX_EQ(B * A, renderSurface2->renderSurface()->drawTransform());
-    EXPECT_TRANSFORMATION_MATRIX_EQ(B * R, renderSurface2->renderSurface()->replicaDrawTransform());
-    EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A, renderSurface2->renderSurface()->screenSpaceTransform());
-    EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * R, renderSurface2->renderSurface()->replicaScreenSpaceTransform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * S1, renderSurface1->renderSurface()->drawTransform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * R * S1, renderSurface1->renderSurface()->replicaDrawTransform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * S1, renderSurface1->renderSurface()->screenSpaceTransform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * R * S1, renderSurface1->renderSurface()->replicaScreenSpaceTransform());
+    // Draw transform of render surface 2 is described with respect to render surface 1.
+    EXPECT_TRANSFORMATION_MATRIX_EQ(SS1 * B * A * S2, renderSurface2->renderSurface()->drawTransform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(SS1 * B * R * S2, renderSurface2->renderSurface()->replicaDrawTransform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * A * S2, renderSurface2->renderSurface()->screenSpaceTransform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(A * B * A * B * R * S2, renderSurface2->renderSurface()->replicaScreenSpaceTransform());
 
     // Sanity check. If these fail there is probably a bug in the test itself.
     // It is expected that we correctly set up transforms so that the y-component of the screen-space transform
     // encodes the "depth" of the layer in the tree.
     EXPECT_FLOAT_EQ(1, parent->screenSpaceTransform().m42());
     EXPECT_FLOAT_EQ(2, childOfRoot->screenSpaceTransform().m42());
     EXPECT_FLOAT_EQ(3, grandChildOfRoot->screenSpaceTransform().m42());
 
     EXPECT_FLOAT_EQ(2, renderSurface1->screenSpaceTransform().m42());
     EXPECT_FLOAT_EQ(3, childOfRS1->screenSpaceTransform().m42());
@@ skipping 90 matching lines @@
     setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, FloatPoint::zero(), FloatPoint::zero(), IntSize(10, 10), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint::zero(), FloatPoint(30, 30), IntSize(10, 10), false);
 
     parent->addChild(renderSurface1);
     parent->setMasksToBounds(true);
     renderSurface1->addChild(child);
     renderSurface1->setForceRenderSurface(true);
 
     std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // The child layer's content is entirely outside the parent's clip rect, so the intermediate
     // render surface should not be listed here, even if it was forced to be created. Render surfaces without children or visible
     // content are unexpected at draw time (e.g. we might try to create a content texture of size 0).
     ASSERT_TRUE(parent->renderSurface());
     ASSERT_FALSE(renderSurface1->renderSurface());
     EXPECT_EQ(1U, renderSurfaceLayerList.size());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyRenderSurfaceListForTransparentChild)
 {
     scoped_refptr<LayerChromium> parent = LayerChromium::create();
     scoped_refptr<LayerChromium> renderSurface1 = LayerChromium::create();
     scoped_refptr<LayerChromiumWithForcedDrawsContent> child = make_scoped_refptr(new LayerChromiumWithForcedDrawsContent());
 
     const WebTransformationMatrix identityMatrix;
     setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, FloatPoint::zero(), FloatPoint::zero(), IntSize(10, 10), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint::zero(), FloatPoint::zero(), IntSize(10, 10), false);
 
     parent->addChild(renderSurface1);
     renderSurface1->addChild(child);
     renderSurface1->setForceRenderSurface(true);
     renderSurface1->setOpacity(0);
 
     std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Since the layer is transparent, renderSurface1->renderSurface() should not have gotten added anywhere.
     // Also, the drawable content rect should not have been extended by the children.
     ASSERT_TRUE(parent->renderSurface());
     EXPECT_EQ(0U, parent->renderSurface()->layerList().size());
     EXPECT_EQ(1U, renderSurfaceLayerList.size());
     EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());
     EXPECT_EQ(IntRect(), parent->drawableContentRect());
 }
 
@@ skipping 11 matching lines @@
 
     parent->addChild(renderSurface1);
     renderSurface1->addChild(child);
 
     // Sanity check before the actual test
     EXPECT_FALSE(parent->renderSurface());
     EXPECT_FALSE(renderSurface1->renderSurface());
 
     std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // The root layer always creates a renderSurface
     EXPECT_TRUE(parent->renderSurface());
     EXPECT_TRUE(renderSurface1->renderSurface());
     EXPECT_EQ(2U, renderSurfaceLayerList.size());
 
     renderSurfaceLayerList.clear();
     renderSurface1->setForceRenderSurface(false);
-    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
     EXPECT_TRUE(parent->renderSurface());
     EXPECT_FALSE(renderSurface1->renderSurface());
     EXPECT_EQ(1U, renderSurfaceLayerList.size());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithDirectContainer)
 {
     // This test checks for correct scroll compensation when the fixed-position container
     // is the direct parent of the fixed-position layer.
 
@@ skipping 593 matching lines @@
     setLayerPropertiesForTesting(leafNode1.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(500, 500), false);
     setLayerPropertiesForTesting(leafNode2.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(20, 20), false);
 
     child->setMasksToBounds(true);
     child->setOpacity(0.4f);
     grandChild->setOpacity(0.5);
     greatGrandChild->setOpacity(0.4f);
 
     std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     ASSERT_EQ(2U, renderSurfaceLayerList.size());
     EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());
     EXPECT_EQ(child->id(), renderSurfaceLayerList[1]->id());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyClipRectCullsSurfaceWithoutVisibleContent)
 {
     // When a renderSurface has a clipRect, it is used to clip the contentRect
     // of the surface. When the renderSurface is animating its transforms, then
@@ skipping 24 matching lines @@
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(20, 20), false);
     setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(200, 200), IntSize(10, 10), false);
     setLayerPropertiesForTesting(leafNode.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(10, 10), false);
 
     parent->setMasksToBounds(true);
     child->setOpacity(0.4f);
     grandChild->setOpacity(0.4f);
 
     std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Without an animation, we should cull child and grandChild from the renderSurfaceLayerList.
     ASSERT_EQ(1U, renderSurfaceLayerList.size());
     EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());
 
     // Now put an animating transform on child.
     addAnimatedTransformToController(*child->layerAnimationController(), 10, 30, 0);
 
     parent->clearRenderSurface();
     child->clearRenderSurface();
     grandChild->clearRenderSurface();
     renderSurfaceLayerList.clear();
 
-    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // With an animating transform, we should keep child and grandChild in the renderSurfaceLayerList.
     ASSERT_EQ(3U, renderSurfaceLayerList.size());
     EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());
     EXPECT_EQ(child->id(), renderSurfaceLayerList[1]->id());
     EXPECT_EQ(grandChild->id(), renderSurfaceLayerList[2]->id());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyDrawableContentRectForLayers)
 {
@@ skipping 31 matching lines @@
 
     // Force everyone to be a render surface.
     child->setOpacity(0.4f);
     grandChild1->setOpacity(0.5);
     grandChild2->setOpacity(0.5);
     grandChild3->setOpacity(0.5);
     grandChild4->setOpacity(0.5);
 
     std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     EXPECT_RECT_EQ(IntRect(IntPoint(5, 5), IntSize(10, 10)), grandChild1->drawableContentRect());
     EXPECT_RECT_EQ(IntRect(IntPoint(15, 15), IntSize(5, 5)), grandChild3->drawableContentRect());
     EXPECT_RECT_EQ(IntRect(IntPoint(15, 15), IntSize(5, 5)), grandChild3->drawableContentRect());
     EXPECT_TRUE(grandChild4->drawableContentRect().isEmpty());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyClipRectIsPropagatedCorrectlyToSurfaces)
 {
     // Verify that renderSurfaces (and their layers) get the appropriate clipRects when their parent masksToBounds is true.
@@ skipping 44 matching lines @@
 
     // Force everyone to be a render surface.
     child->setOpacity(0.4f);
     grandChild1->setOpacity(0.5);
     grandChild2->setOpacity(0.5);
     grandChild3->setOpacity(0.5);
     grandChild4->setOpacity(0.5);
 
     std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     ASSERT_TRUE(grandChild1->renderSurface());
     ASSERT_TRUE(grandChild2->renderSurface());
     ASSERT_TRUE(grandChild3->renderSurface());
     EXPECT_FALSE(grandChild4->renderSurface()); // Because grandChild4 is entirely clipped, it is expected to not have a renderSurface.
 
     // Surfaces are clipped by their parent, but un-affected by the owning layer's masksToBounds.
     EXPECT_RECT_EQ(IntRect(IntPoint(0, 0), IntSize(20, 20)), grandChild1->renderSurface()->clipRect());
     EXPECT_RECT_EQ(IntRect(IntPoint(0, 0), IntSize(20, 20)), grandChild2->renderSurface()->clipRect());
     EXPECT_RECT_EQ(IntRect(IntPoint(0, 0), IntSize(20, 20)), grandChild3->renderSurface()->clipRect());
@@ skipping 821 matching lines @@
     setLayerPropertiesForTesting(backFacingChild.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(frontFacingSurface.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(backFacingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(frontFacingChildOfFrontFacingSurface.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(backFacingChildOfFrontFacingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(frontFacingChildOfBackFacingSurface.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(backFacingChildOfBackFacingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
 
     std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Verify which renderSurfaces were created.
     EXPECT_FALSE(frontFacingChild->renderSurface());
     EXPECT_FALSE(backFacingChild->renderSurface());
     EXPECT_TRUE(frontFacingSurface->renderSurface());
     EXPECT_TRUE(backFacingSurface->renderSurface());
     EXPECT_FALSE(frontFacingChildOfFrontFacingSurface->renderSurface());
     EXPECT_FALSE(backFacingChildOfFrontFacingSurface->renderSurface());
     EXPECT_FALSE(frontFacingChildOfBackFacingSurface->renderSurface());
     EXPECT_FALSE(backFacingChildOfBackFacingSurface->renderSurface());
@@ skipping 78 matching lines @@
     setLayerPropertiesForTesting(backFacingChild.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(frontFacingSurface.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), true); // surface transform style is preserve-3d.
     setLayerPropertiesForTesting(backFacingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), true); // surface transform style is preserve-3d.
     setLayerPropertiesForTesting(frontFacingChildOfFrontFacingSurface.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(backFacingChildOfFrontFacingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(frontFacingChildOfBackFacingSurface.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(backFacingChildOfBackFacingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
 
     std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Verify which renderSurfaces were created.
     EXPECT_FALSE(frontFacingChild->renderSurface());
     EXPECT_FALSE(backFacingChild->renderSurface());
     EXPECT_TRUE(frontFacingSurface->renderSurface());
     EXPECT_FALSE(backFacingSurface->renderSurface());
     EXPECT_FALSE(frontFacingChildOfFrontFacingSurface->renderSurface());
     EXPECT_FALSE(backFacingChildOfFrontFacingSurface->renderSurface());
     EXPECT_FALSE(frontFacingChildOfBackFacingSurface->renderSurface());
     EXPECT_FALSE(backFacingChildOfBackFacingSurface->renderSurface());
@@ skipping 59 matching lines @@
 
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(child.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(animatingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(childOfAnimatingSurface.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(animatingChild.get(), backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
 
     std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     EXPECT_FALSE(child->renderSurface());
     EXPECT_TRUE(animatingSurface->renderSurface());
     EXPECT_FALSE(childOfAnimatingSurface->renderSurface());
     EXPECT_FALSE(animatingChild->renderSurface());
     EXPECT_FALSE(child2->renderSurface());
 
     // Verify that the animatingChild and childOfAnimatingSurface were not culled, but that child was.
     ASSERT_EQ(2u, renderSurfaceLayerList.size());
     EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());
@@ skipping 45 matching lines @@
     backfaceMatrix.translate(-50, -50);
 
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), true); // parent transform style is preserve3d.
     setLayerPropertiesForTesting(frontFacingSurface.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); // surface transform style is flat.
     setLayerPropertiesForTesting(backFacingSurface.get(),  backfaceMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false); // surface transform style is flat.
     setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
     setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
 
     std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Verify which renderSurfaces were created.
     EXPECT_TRUE(frontFacingSurface->renderSurface());
     EXPECT_FALSE(backFacingSurface->renderSurface()); // because it should be culled
     EXPECT_FALSE(child1->renderSurface());
     EXPECT_FALSE(child2->renderSurface());
 
     // Verify the renderSurfaceLayerList. The back-facing surface should be culled.
     ASSERT_EQ(2u, renderSurfaceLayerList.size());
     EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());
@@ skipping 33 matching lines @@
 
     WebTransformationMatrix identityMatrix;
     FloatPoint anchor(0, 0);
     FloatPoint position(0, 0);
     IntSize bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
 
     // Hit testing for a point outside the layer should return a null pointer.
     IntPoint testPoint(101, 101);
     CCLayerImpl* resultLayer = CCLayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 
@@ skipping 28 matching lines @@
 
     WebTransformationMatrix identityMatrix;
     FloatPoint anchor(0, 0);
     FloatPoint position(0, 0);
     IntSize bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), uninvertibleTransform, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
     ASSERT_FALSE(root->screenSpaceTransform().isInvertible());
 
     // Hit testing any point should not hit the layer. If the invertible matrix is
     // accidentally ignored and treated like an identity, then the hit testing will
     // incorrectly hit the layer when it shouldn't.
     IntPoint testPoint(1, 1);
@@ skipping 33 matching lines @@
 
     WebTransformationMatrix identityMatrix;
     FloatPoint anchor(0, 0);
     FloatPoint position(50, 50); // this layer is positioned, and hit testing should correctly know where the layer is located.
     IntSize bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
 
     // Hit testing for a point outside the layer should return a null pointer.
     IntPoint testPoint(49, 49);
     CCLayerImpl* resultLayer = CCLayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 
@@ skipping 26 matching lines @@
     rotation45DegreesAboutCenter.rotate3d(0, 0, 45);
     rotation45DegreesAboutCenter.translate(-50, -50);
     FloatPoint anchor(0, 0);
     FloatPoint position(0, 0);
     IntSize bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), rotation45DegreesAboutCenter, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
 
     // Hit testing for points outside the layer.
     // These corners would have been inside the un-transformed layer, but they should not hit the correctly transformed layer.
     IntPoint testPoint(99, 99);
     CCLayerImpl* resultLayer = CCLayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
@@ skipping 35 matching lines @@
     translationByZ.translate3d(0, 0, -1);
 
     FloatPoint anchor(0, 0);
     FloatPoint position(0, 0);
     IntSize bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), perspectiveProjectionAboutCenter * translationByZ, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
 
     // Hit testing for points outside the layer.
     // These corners would have been inside the un-transformed layer, but they should not hit the correctly transformed layer.
     IntPoint testPoint(24, 24);
     CCLayerImpl* resultLayer = CCLayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
@@ skipping 43 matching lines @@
 
         // override contentBounds
         testLayer->setContentBounds(IntSize(100, 100));
 
         testLayer->setDrawsContent(true);
         root->addChild(testLayer.Pass());
     }
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     // The visibleContentRect for testLayer is actually 100x100, even though its layout size is 50x50, positioned at 25x25.
     CCLayerImpl* testLayer = root->children()[0];
     EXPECT_RECT_EQ(IntRect(IntPoint::zero(), IntSize(100, 100)), testLayer->visibleContentRect());
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
 
     // Hit testing for a point outside the layer should return a null pointer (the root layer does not draw content, so it will not be hit tested either).
     IntPoint testPoint(101, 101);
@@ skipping 43 matching lines @@
         position = FloatPoint(-50, -50);
         bounds = IntSize(300, 300);
         setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child->setDrawsContent(true);
         clippingLayer->addChild(child.Pass());
         root->addChild(clippingLayer.Pass());
     }
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
     ASSERT_EQ(456, root->renderSurface()->layerList()[0]->id());
 
     // Hit testing for a point outside the layer should return a null pointer.
     // Despite the child layer being very large, it should be clipped to the root layer's bounds.
     IntPoint testPoint(24, 24);
     CCLayerImpl* resultLayer = CCLayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
@@ skipping 69 matching lines @@
         setLayerPropertiesForTesting(rotatedLeaf.get(), rotatedLeafTransform, identityMatrix, anchor, position, bounds, false);
         rotatedLeaf->setDrawsContent(true);
 
         grandChild->addChild(rotatedLeaf.Pass());
         child->addChild(grandChild.Pass());
         root->addChild(child.Pass());
     }
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     // The grandChild is expected to create a renderSurface because it masksToBounds and is not axis aligned.
     ASSERT_EQ(2u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, renderSurfaceLayerList[0]->renderSurface()->layerList().size());
     ASSERT_EQ(789, renderSurfaceLayerList[0]->renderSurface()->layerList()[0]->id()); // grandChild's surface.
     ASSERT_EQ(1u, renderSurfaceLayerList[1]->renderSurface()->layerList().size());
     ASSERT_EQ(2468, renderSurfaceLayerList[1]->renderSurface()->layerList()[0]->id());
 
     // (11, 89) is close to the the bottom left corner within the clip, but it is not inside the layer.
@@ skipping 61 matching lines @@
         position = FloatPoint(60, 60); // 70, 70 in screen space
         bounds = IntSize(20, 20);
         setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child->setDrawsContent(true);
         intermediateLayer->addChild(child.Pass());
         root->addChild(intermediateLayer.Pass());
     }
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
     ASSERT_EQ(456, root->renderSurface()->layerList()[0]->id());
 
     // Hit testing for a point outside the layer should return a null pointer.
     IntPoint testPoint(69, 69);
     CCLayerImpl* resultLayer = CCLayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
@@ skipping 59 matching lines @@
         root->addChild(child1.Pass());
         root->addChild(child2.Pass());
     }
 
     CCLayerImpl* child1 = root->children()[0];
     CCLayerImpl* child2 = root->children()[1];
     CCLayerImpl* grandChild1 = child1->children()[0];
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_TRUE(child1);
     ASSERT_TRUE(child2);
     ASSERT_TRUE(grandChild1);
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(4u, root->renderSurface()->layerList().size());
     ASSERT_EQ(1, root->renderSurface()->layerList()[0]->id()); // root layer
     ASSERT_EQ(2, root->renderSurface()->layerList()[1]->id()); // child1
     ASSERT_EQ(4, root->renderSurface()->layerList()[2]->id()); // grandChild1
@@ skipping 87 matching lines @@
         root->addChild(child1.Pass());
         root->addChild(child2.Pass());
     }
 
     CCLayerImpl* child1 = root->children()[0];
     CCLayerImpl* child2 = root->children()[1];
     CCLayerImpl* grandChild1 = child1->children()[0];
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_TRUE(child1);
     ASSERT_TRUE(child2);
     ASSERT_TRUE(grandChild1);
     ASSERT_TRUE(child1->renderSurface());
     ASSERT_TRUE(child2->renderSurface());
     ASSERT_TRUE(grandChild1->renderSurface());
     ASSERT_EQ(4u, renderSurfaceLayerList.size());
     ASSERT_EQ(3u, root->renderSurface()->layerList().size()); // The root surface has the root layer, and child1's and child2's renderSurfaces.
@@ skipping 35 matching lines @@
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(3, resultLayer->id());
 
     // At (20, 51), child1 and grandChild1 overlap. grandChild1 is expected to be on top.
     testPoint = IntPoint(20, 51);
     resultLayer = CCLayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(4, resultLayer->id());
 }
 
+class NoScaleContentLayerChromium : public ContentLayerChromium
+{
+public:
+    static scoped_refptr<NoScaleContentLayerChromium> create(ContentLayerChromiumClient* client) { return make_scoped_refptr(new NoScaleContentLayerChromium(client)); }
+
+    virtual bool needsContentsScale() const OVERRIDE { return false; }
+
+protected:
+    explicit NoScaleContentLayerChromium(ContentLayerChromiumClient* client) : ContentLayerChromium(client) { }
+    virtual ~NoScaleContentLayerChromium() { }
+};
+
+scoped_refptr<NoScaleContentLayerChromium> createNoScaleDrawableContentLayerChromium(ContentLayerChromiumClient* delegate)
+{
+    scoped_refptr<NoScaleContentLayerChromium> toReturn = NoScaleContentLayerChromium::create(delegate);
+    toReturn->setIsDrawable(true);
+    return toReturn;
+}
+
 TEST(CCLayerTreeHostCommonTest, verifyLayerTransformsInHighDPI)
 {
     // Verify draw and screen space transforms of layers not in a surface.
     MockContentLayerChromiumClient delegate;
     WebTransformationMatrix identityMatrix;
 
     scoped_refptr<ContentLayerChromium> parent = createDrawableContentLayerChromium(&delegate);
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), true);
 
     scoped_refptr<ContentLayerChromium> child = createDrawableContentLayerChromium(&delegate);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(2, 2), IntSize(10, 10), true);
 
-    scoped_refptr<ContentLayerChromium> childNoScale = createDrawableContentLayerChromium(&delegate);
+    scoped_refptr<NoScaleContentLayerChromium> childNoScale = createNoScaleDrawableContentLayerChromium(&delegate);
     setLayerPropertiesForTesting(childNoScale.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(2, 2), IntSize(10, 10), true);
 
     parent->addChild(child);
     parent->addChild(childNoScale);
 
     std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
 
     const double deviceScaleFactor = 2.5;
-    parent->setContentsScale(deviceScaleFactor);
-    child->setContentsScale(deviceScaleFactor);
-    EXPECT_EQ(childNoScale->contentsScale(), 1);
+    const double pageScaleFactor = 1;
 
-    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
+
+    EXPECT_EQ(deviceScaleFactor * pageScaleFactor, parent->contentsScale());
+    EXPECT_EQ(deviceScaleFactor * pageScaleFactor, child->contentsScale());
+    EXPECT_EQ(1, childNoScale->contentsScale());
 
     EXPECT_EQ(1u, renderSurfaceLayerList.size());
 
     // Verify parent transforms
     WebTransformationMatrix expectedParentTransform;
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedParentTransform, parent->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedParentTransform, parent->drawTransform());
 
     // Verify results of transformed parent rects
     FloatRect parentContentBounds(FloatPoint(), FloatSize(parent->contentBounds()));
@@ skipping 26 matching lines @@
 
     // Verify childNoScale transforms
     WebTransformationMatrix expectedChildNoScaleTransform = child->drawTransform();
     // All transforms operate on content rects. The child's content rect
     // incorporates device scale, but the childNoScale does not; add it here.
     expectedChildNoScaleTransform.scale(deviceScaleFactor);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildNoScaleTransform, childNoScale->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildNoScaleTransform, childNoScale->screenSpaceTransform());
 }
 
+TEST(CCLayerTreeHostCommonTest, verifyContentsScale)
+{
+    MockContentLayerChromiumClient delegate;
+    WebTransformationMatrix identityMatrix;
+
+    WebTransformationMatrix parentScaleMatrix;
+    const double initialParentScale = 1.75;
+    parentScaleMatrix.scale(initialParentScale);
+
+    WebTransformationMatrix childScaleMatrix;
+    const double initialChildScale = 1.25;
+    childScaleMatrix.scale(initialChildScale);
+
+    scoped_refptr<ContentLayerChromium> parent = createDrawableContentLayerChromium(&delegate);
+    setLayerPropertiesForTesting(parent.get(), parentScaleMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), true);
+
+    scoped_refptr<ContentLayerChromium> childScale = createDrawableContentLayerChromium(&delegate);
+    setLayerPropertiesForTesting(childScale.get(), childScaleMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(2, 2), IntSize(10, 10), true);
+
+    scoped_refptr<NoScaleContentLayerChromium> childNoScale = createNoScaleDrawableContentLayerChromium(&delegate);
+    setLayerPropertiesForTesting(childNoScale.get(), childScaleMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(12, 12), IntSize(10, 10), true);
+
+    // FIXME: Remove this when pageScaleFactor is applied in the compositor.
+    // Page scale should not apply to the parent.
+    parent->setBoundsContainPageScale(true);
+
+    parent->addChild(childScale);
+    parent->addChild(childNoScale);
+
+    std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+
+    double deviceScaleFactor = 2.5;
+    double pageScaleFactor = 1.5;
+
+    // FIXME: Remove this when pageScaleFactor is applied in the compositor.
+    WebTransformationMatrix pageScaleMatrix;
+    pageScaleMatrix.scale(pageScaleFactor);
+    parent->setSublayerTransform(pageScaleMatrix);
+
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
+
+    EXPECT_FLOAT_EQ(deviceScaleFactor * initialParentScale, parent->contentsScale());
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childScale->contentsScale());
+    EXPECT_FLOAT_EQ(1, childNoScale->contentsScale());
+
+    // The parent is scaled up and shouldn't need to scale during draw. The child that can scale its contents should
+    // also not need to scale during draw. The other should.
+    // There is some rounding error due to contentBounds being a rounded integer.
+    EXPECT_NEAR(parent->drawTransform().m11(), 1, 0.01);
+    EXPECT_NEAR(parent->drawTransform().m22(), 1, 0.01);
+    EXPECT_NEAR(childScale->drawTransform().m11(), 1, 0.01);
+    EXPECT_NEAR(childScale->drawTransform().m22(), 1, 0.01);
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childNoScale->drawTransform().m11());
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childNoScale->drawTransform().m22());
+
+    // If the transform changes, we expect the contentsScale to remain unchanged.
+    childScale->setTransform(identityMatrix);
+
+    renderSurfaceLayerList.clear();
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
+
+    EXPECT_FLOAT_EQ(deviceScaleFactor * initialParentScale, parent->contentsScale());
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childScale->contentsScale());
+    EXPECT_FLOAT_EQ(1, childNoScale->contentsScale());
+
+    // But if the deviceScaleFactor or pageScaleFactor changes, then it should be updated, but using the initial transform.
+    deviceScaleFactor = 2.25;
+    pageScaleFactor = 1.25;
+
+    // FIXME: Remove this when pageScaleFactor is applied in the compositor.
+    pageScaleMatrix = identityMatrix;
+    pageScaleMatrix.scale(pageScaleFactor);
+    parent->setSublayerTransform(pageScaleMatrix);
+
+    renderSurfaceLayerList.clear();
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
+
+    EXPECT_FLOAT_EQ(deviceScaleFactor * initialParentScale, parent->contentsScale());
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childScale->contentsScale());
+    EXPECT_FLOAT_EQ(1, childNoScale->contentsScale());
+}
+
+TEST(CCLayerTreeHostCommonTest, verifyContentsScaleForSurfaces)
+{
+    MockContentLayerChromiumClient delegate;
+    WebTransformationMatrix identityMatrix;
+
+    WebTransformationMatrix parentScaleMatrix;
+    const double initialParentScale = 2;
+    parentScaleMatrix.scale(initialParentScale);
+
+    WebTransformationMatrix childScaleMatrix;
+    const double initialChildScale = 3;
+    childScaleMatrix.scale(initialChildScale);
+
+    scoped_refptr<ContentLayerChromium> parent = createDrawableContentLayerChromium(&delegate);
+    setLayerPropertiesForTesting(parent.get(), parentScaleMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), true);
+
+    scoped_refptr<ContentLayerChromium> surfaceScale = createDrawableContentLayerChromium(&delegate);
+    setLayerPropertiesForTesting(surfaceScale.get(), childScaleMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(2, 2), IntSize(10, 10), true);
+
+    scoped_refptr<ContentLayerChromium> surfaceScaleChildScale = createDrawableContentLayerChromium(&delegate);
+    setLayerPropertiesForTesting(surfaceScaleChildScale.get(), childScaleMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(10, 10), true);
+
+    scoped_refptr<NoScaleContentLayerChromium> surfaceScaleChildNoScale = createNoScaleDrawableContentLayerChromium(&delegate);
+    setLayerPropertiesForTesting(surfaceScaleChildNoScale.get(), childScaleMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(10, 10), true);
+
+    scoped_refptr<NoScaleContentLayerChromium> surfaceNoScale = createNoScaleDrawableContentLayerChromium(&delegate);
+    setLayerPropertiesForTesting(surfaceNoScale.get(), childScaleMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(12, 12), IntSize(10, 10), true);
+
+    scoped_refptr<ContentLayerChromium> surfaceNoScaleChildScale = createDrawableContentLayerChromium(&delegate);
+    setLayerPropertiesForTesting(surfaceNoScaleChildScale.get(), childScaleMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(10, 10), true);
+
+    scoped_refptr<NoScaleContentLayerChromium> surfaceNoScaleChildNoScale = createNoScaleDrawableContentLayerChromium(&delegate);
+    setLayerPropertiesForTesting(surfaceNoScaleChildNoScale.get(), childScaleMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(10, 10), true);
+
+    // FIXME: Remove this when pageScaleFactor is applied in the compositor.
+    // Page scale should not apply to the parent.
+    parent->setBoundsContainPageScale(true);
+
+    parent->addChild(surfaceScale);
+    parent->addChild(surfaceNoScale);
+
+    surfaceScale->setForceRenderSurface(true);
+    surfaceScale->addChild(surfaceScaleChildScale);
+    surfaceScale->addChild(surfaceScaleChildNoScale);
+
+    surfaceNoScale->setForceRenderSurface(true);
+    surfaceNoScale->addChild(surfaceNoScaleChildScale);
+    surfaceNoScale->addChild(surfaceNoScaleChildNoScale);
+
+    std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+
+    double deviceScaleFactor = 5;
+    double pageScaleFactor = 7;
+
+    // FIXME: Remove this when pageScaleFactor is applied in the compositor.
+    WebTransformationMatrix pageScaleMatrix;
+    pageScaleMatrix.scale(pageScaleFactor);
+    parent->setSublayerTransform(pageScaleMatrix);
+
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
+
+    EXPECT_EQ(deviceScaleFactor * initialParentScale, parent->contentsScale());
+    EXPECT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, surfaceScale->contentsScale());
+    EXPECT_EQ(1, surfaceNoScale->contentsScale());
+    EXPECT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceScaleChildScale->contentsScale());
+    EXPECT_EQ(1, surfaceScaleChildNoScale->contentsScale());
+    EXPECT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceNoScaleChildScale->contentsScale());
+    EXPECT_EQ(1, surfaceNoScaleChildNoScale->contentsScale());
+
+    // The parent is scaled up and shouldn't need to scale during draw.
+    EXPECT_FLOAT_EQ(1, parent->drawTransform().m11());
+    EXPECT_FLOAT_EQ(1, parent->drawTransform().m22());
+
+    // RenderSurfaces should always be 1:1 with their target.
+    EXPECT_FLOAT_EQ(1, surfaceScale->renderSurface()->drawTransform().m11());
+    EXPECT_FLOAT_EQ(1, surfaceScale->renderSurface()->drawTransform().m22());
+
+    // The surfaceScale can apply contents scale so the layer shouldn't need to scale during draw.
+    EXPECT_FLOAT_EQ(1, surfaceScale->drawTransform().m11());
+    EXPECT_FLOAT_EQ(1, surfaceScale->drawTransform().m22());
+
+    // The surfaceScaleChildScale can apply contents scale so it shouldn't need to scale during draw.
+    EXPECT_FLOAT_EQ(1, surfaceScaleChildScale->drawTransform().m11());
+    EXPECT_FLOAT_EQ(1, surfaceScaleChildScale->drawTransform().m22());
+
+    // The surfaceScaleChildNoScale can not apply contents scale, so it needs to be scaled during draw.
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceScaleChildNoScale->drawTransform().m11());
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceScaleChildNoScale->drawTransform().m22());
+
+    // RenderSurfaces should always be 1:1 with their target.
+    EXPECT_FLOAT_EQ(1, surfaceNoScale->renderSurface()->drawTransform().m11());
+    EXPECT_FLOAT_EQ(1, surfaceNoScale->renderSurface()->drawTransform().m22());
+
+    // The surfaceScale layer can not apply contents scale, so it needs to be scaled during draw.
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, surfaceNoScale->drawTransform().m11());
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, surfaceNoScale->drawTransform().m22());
+
+    // The surfaceScaleChildScale can apply contents scale so it shouldn't need to scale during draw.
+    EXPECT_FLOAT_EQ(1, surfaceNoScaleChildScale->drawTransform().m11());
+    EXPECT_FLOAT_EQ(1, surfaceNoScaleChildScale->drawTransform().m22());
+
+    // The surfaceScaleChildNoScale can not apply contents scale, so it needs to be scaled during draw.
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceNoScaleChildNoScale->drawTransform().m11());
+    EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceNoScaleChildNoScale->drawTransform().m22());
+
+}
+
 TEST(CCLayerTreeHostCommonTest, verifyRenderSurfaceTransformsInHighDPI)
 {
     MockContentLayerChromiumClient delegate;
     WebTransformationMatrix identityMatrix;
 
     scoped_refptr<ContentLayerChromium> parent = createDrawableContentLayerChromium(&delegate);
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(30, 30), true);
 
     scoped_refptr<ContentLayerChromium> child = createDrawableContentLayerChromium(&delegate);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, FloatPoint(0, 0), FloatPoint(2, 2), IntSize(10, 10), true);
@@ skipping 14 matching lines @@
 
     std::vector<scoped_refptr<LayerChromium> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
 
     const double deviceScaleFactor = 1.5;
     parent->setContentsScale(deviceScaleFactor);
     child->setContentsScale(deviceScaleFactor);
     duplicateChildNonOwner->setContentsScale(deviceScaleFactor);
     replica->setContentsScale(deviceScaleFactor);
 
-    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
+    CCLayerTreeHostCommon::calculateDrawTransforms(parent.get(), parent->bounds(), deviceScaleFactor, 1, dummyMaxTextureSize, renderSurfaceLayerList);
 
     // We should have two render surfaces. The root's render surface and child's
     // render surface (it needs one because it has a replica layer).
     EXPECT_EQ(2u, renderSurfaceLayerList.size());
 
     WebTransformationMatrix expectedParentTransform;
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedParentTransform, parent->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedParentTransform, parent->drawTransform());
 
     WebTransformationMatrix expectedDrawTransform;
@@ skipping 50 matching lines @@
     int nonexistentId = -1;
     EXPECT_EQ(root, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), root->id()));
     EXPECT_EQ(child, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), child->id()));
     EXPECT_EQ(grandChild, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), grandChild->id()));
     EXPECT_EQ(maskLayer, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), maskLayer->id()));
     EXPECT_EQ(replicaLayer, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), replicaLayer->id()));
     EXPECT_EQ(0, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), nonexistentId));
 }
 
 } // namespace