cc: Change LTHCommon tests to use impl painting.

cc/trees/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 "cc/trees/layer_tree_host_common.h"
 
 #include <set>
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_client.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/render_surface.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
+#include "cc/test/fake_picture_layer.h"
+#include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_tree_host_common_test.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/proxy.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/transform.h"
 
@@ skipping 17 matching lines @@
   MockContentLayerClient() {}
   virtual ~MockContentLayerClient() {}
   virtual void PaintContents(
       SkCanvas* canvas,
       const gfx::Rect& clip,
       ContentLayerClient::GraphicsContextStatus gc_status) OVERRIDE {}
   virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
   virtual bool FillsBoundsCompletely() const OVERRIDE { return false; }
 };
 
-scoped_refptr<ContentLayer> CreateDrawableContentLayer(
+scoped_refptr<FakePictureLayer> CreateDrawablePictureLayer(
     ContentLayerClient* delegate) {
-  scoped_refptr<ContentLayer> to_return = ContentLayer::Create(delegate);
+  scoped_refptr<FakePictureLayer> to_return =
+      FakePictureLayer::Create(delegate);
   to_return->SetIsDrawable(true);
   return to_return;
 }
 
 #define EXPECT_CONTENTS_SCALE_EQ(expected, layer)         \
   do {                                                    \
     EXPECT_FLOAT_EQ(expected, layer->contents_scale_x()); \
     EXPECT_FLOAT_EQ(expected, layer->contents_scale_y()); \
   } while (false)
 
@@ skipping 3178 matching lines @@
   EXPECT_RECT_EQ(gfx::Rect(0, 0, 26, 50), child1->visible_content_rect());
 
   // The child's DrawableContentRect is unclipped.
   EXPECT_RECT_EQ(unclipped_surface_content, child1->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsInHighDPI) {
   MockContentLayerClient client;
 
   scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<ContentLayer> render_surface1 =
-      CreateDrawableContentLayer(&client);
-  scoped_refptr<ContentLayer> render_surface2 =
-      CreateDrawableContentLayer(&client);
-  scoped_refptr<ContentLayer> child1 = CreateDrawableContentLayer(&client);
-  scoped_refptr<ContentLayer> child2 = CreateDrawableContentLayer(&client);
-  scoped_refptr<ContentLayer> child3 = CreateDrawableContentLayer(&client);
+  scoped_refptr<FakePictureLayer> render_surface1 =
+      CreateDrawablePictureLayer(&client);
+  scoped_refptr<FakePictureLayer> render_surface2 =
+      CreateDrawablePictureLayer(&client);
+  scoped_refptr<FakePictureLayer> child1 = CreateDrawablePictureLayer(&client);
+  scoped_refptr<FakePictureLayer> child2 = CreateDrawablePictureLayer(&client);
+  scoped_refptr<FakePictureLayer> child3 = CreateDrawablePictureLayer(&client);
   root->AddChild(render_surface1);
   render_surface1->AddChild(render_surface2);
   render_surface2->AddChild(child1);
   render_surface2->AddChild(child2);
   render_surface2->AddChild(child3);
 
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
@@ skipping 65 matching lines @@
 
   EXPECT_RECT_EQ(gfx::Rect(10, 10, 100, 100), child1->drawable_content_rect());
   EXPECT_RECT_EQ(gfx::Rect(150, 150, 100, 100),
                  child2->drawable_content_rect());
   EXPECT_RECT_EQ(gfx::Rect(250, 250, 100, 100),
                  child3->drawable_content_rect());
 
   // The root layer does not actually draw content of its own.
   EXPECT_RECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_content_rect());
 
-  // All layer visible content rects are expressed in content space of each
-  // layer, so they are also scaled by the device_scale_factor.
-  EXPECT_RECT_EQ(gfx::Rect(0, 0, 6, 8),
+  // All layer visible content rects are not expressed in content space of each
+  // layer, so they are also not scaled by the device_scale_factor.
+  EXPECT_RECT_EQ(gfx::Rect(0, 0, 3, 4),
                  render_surface1->visible_content_rect());
-  EXPECT_RECT_EQ(gfx::Rect(0, 0, 14, 26),
+  EXPECT_RECT_EQ(gfx::Rect(0, 0, 7, 13),
                  render_surface2->visible_content_rect());
-  EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), child1->visible_content_rect());
-  EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), child2->visible_content_rect());
-  EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), child3->visible_content_rect());
+  EXPECT_RECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_content_rect());
+  EXPECT_RECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_content_rect());
+  EXPECT_RECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithoutPreserves3d) {
   // Verify the behavior of back-face culling when there are no preserve-3d
   // layers. Note that 3d transforms still apply in this case, but they are
   // "flattened" to each parent layer according to current W3C spec.
 
   const gfx::Transform identity_matrix;
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> front_facing_child =
@@ skipping 627 matching lines @@
       2u,
       render_surface_layer_list.at(1)->render_surface()->layer_list().size());
   EXPECT_EQ(front_facing_surface->id(),
             render_surface_layer_list.at(1)
                 ->render_surface()->layer_list().at(0)->id());
   EXPECT_EQ(child1->id(),
             render_surface_layer_list.at(1)
                 ->render_surface()->layer_list().at(1)->id());
 }
 
+class NoScalePictureLayer : public PictureLayer {
+ public:
+  static scoped_refptr<NoScalePictureLayer> Create(ContentLayerClient* client) {
+    return make_scoped_refptr(new NoScalePictureLayer(client));
+  }
+
+  virtual void CalculateContentsScale(float ideal_contents_scale,
+                                      float* contents_scale_x,
+                                      float* contents_scale_y,
+                                      gfx::Size* contentBounds) OVERRIDE {
+    // Skip over the ContentLayer's method to the base Layer class.
+    Layer::CalculateContentsScale(ideal_contents_scale,
+                                  contents_scale_x,
+                                  contents_scale_y,
+                                  contentBounds);
+  }
+
+ private:
+  explicit NoScalePictureLayer(ContentLayerClient* client)
+      : PictureLayer(client) {}
+  virtual ~NoScalePictureLayer() {}
+};
+
+scoped_refptr<NoScalePictureLayer> CreateNoScaleDrawablePictureLayer(
+    ContentLayerClient* delegate) {
+  scoped_refptr<NoScalePictureLayer> to_return =
+      NoScalePictureLayer::Create(delegate);
+  to_return->SetIsDrawable(true);
+  return to_return;
+}
+
 class NoScaleContentLayer : public ContentLayer {
  public:
   static scoped_refptr<NoScaleContentLayer> Create(ContentLayerClient* client) {
     return make_scoped_refptr(new NoScaleContentLayer(client));
   }
 
   virtual void CalculateContentsScale(float ideal_contents_scale,
                                       float* contents_scale_x,
                                       float* contents_scale_y,
                                       gfx::Size* content_bounds) OVERRIDE {
@@ skipping 16 matching lines @@
       NoScaleContentLayer::Create(delegate);
   to_return->SetIsDrawable(true);
   return to_return;
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerTransformsInHighDPI) {
   // Verify draw and screen space transforms of layers not in a surface.
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
-  scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> parent =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> child = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> child = CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(child.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> child_empty =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> child_empty =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(child_empty.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(),
                                false,
                                true);
 
-  scoped_refptr<NoScaleContentLayer> child_no_scale =
-      CreateNoScaleDrawableContentLayer(&delegate);
+  scoped_refptr<NoScalePictureLayer> child_no_scale =
+      CreateNoScaleDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(child_no_scale.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   parent->AddChild(child);
   parent->AddChild(child_empty);
   parent->AddChild(child_no_scale);
 
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   host->SetRootLayer(parent);
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 1.f;
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       parent.get(), parent->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.page_scale_factor = page_scale_factor;
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
-  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
-  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, child);
-  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
-                           child_empty);
+  EXPECT_CONTENTS_SCALE_EQ(1, parent);
+  EXPECT_CONTENTS_SCALE_EQ(1, child);
+  EXPECT_CONTENTS_SCALE_EQ(1, child_empty);
   EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
 
   EXPECT_EQ(1u, render_surface_layer_list.size());
 
   // Verify parent transforms
   gfx::Transform expected_parent_transform;
+  expected_parent_transform.Scale(device_scale_factor * page_scale_factor,
+                                  device_scale_factor * page_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
                                   parent->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
                                   parent->draw_transform());
 
   // Verify results of transformed parent rects
   gfx::RectF parent_content_bounds(parent->content_bounds());
 
   gfx::RectF parent_draw_rect =
       MathUtil::MapClippedRect(parent->draw_transform(), parent_content_bounds);
   gfx::RectF parent_screen_space_rect = MathUtil::MapClippedRect(
       parent->screen_space_transform(), parent_content_bounds);
 
   gfx::RectF expected_parent_draw_rect(parent->bounds());
   expected_parent_draw_rect.Scale(device_scale_factor);
   EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_draw_rect);
   EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_screen_space_rect);
 
   // Verify child and child_empty transforms. They should match.
   gfx::Transform expected_child_transform;
   expected_child_transform.Translate(
       device_scale_factor * child->position().x(),
       device_scale_factor * child->position().y());
+  expected_child_transform.Scale(device_scale_factor, device_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_empty->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_empty->screen_space_transform());
 
   // Verify results of transformed child and child_empty rects. They should
@@ skipping 13 matching lines @@
   gfx::RectF expected_child_draw_rect(child->position(), child->bounds());
   expected_child_draw_rect.Scale(device_scale_factor);
   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_draw_rect);
   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_screen_space_rect);
   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_empty_draw_rect);
   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_empty_screen_space_rect);
 
   // Verify child_no_scale transforms
   gfx::Transform expected_child_no_scale_transform = child->draw_transform();
   // All transforms operate on content rects. The child's content rect
-  // incorporates device scale, but the child_no_scale does not; add it here.
-  expected_child_no_scale_transform.Scale(device_scale_factor,
-                                          device_scale_factor);
+  // incorporates device scale, the child_no_scale also does.
+
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_no_scale_transform,
                                   child_no_scale->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_no_scale_transform,
                                   child_no_scale->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, SurfaceLayerTransformsInHighDPI) {
   // Verify draw and screen space transforms of layers in a surface.
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   gfx::Transform perspective_matrix;
   perspective_matrix.ApplyPerspectiveDepth(2.0);
 
   gfx::Transform scale_small_matrix;
   scale_small_matrix.Scale(SK_MScalar1 / 10.f, SK_MScalar1 / 12.f);
 
   scoped_refptr<Layer> root = Layer::Create();
 
-  scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> parent =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> perspective_surface =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> perspective_surface =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(perspective_surface.get(),
                                perspective_matrix * scale_small_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> scale_surface =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> scale_surface =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(scale_surface.get(),
                                scale_small_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   perspective_surface->SetForceRenderSurface(true);
   scale_surface->SetForceRenderSurface(true);
@@ skipping 10 matching lines @@
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(), parent->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.page_scale_factor = page_scale_factor;
   inputs.page_scale_application_layer = root.get();
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
-  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
-  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
-                           perspective_surface);
-  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
-                           scale_surface);
+  EXPECT_CONTENTS_SCALE_EQ(1, parent);
+  EXPECT_CONTENTS_SCALE_EQ(1, perspective_surface);
+  EXPECT_CONTENTS_SCALE_EQ(1, scale_surface);
 
   EXPECT_EQ(3u, render_surface_layer_list.size());
 
   gfx::Transform expected_parent_draw_transform;
+  expected_parent_draw_transform.Scale(device_scale_factor * page_scale_factor,
+                                       device_scale_factor * page_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_draw_transform,
                                   parent->draw_transform());
 
   // The scaled surface is rendered at its appropriate scale, and drawn 1:1
   // into its target.
   gfx::Transform expected_scale_surface_draw_transform;
   expected_scale_surface_draw_transform.Translate(
       device_scale_factor * page_scale_factor * scale_surface->position().x(),
       device_scale_factor * page_scale_factor * scale_surface->position().y());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_scale_surface_draw_transform,
       scale_surface->render_surface()->draw_transform());
   gfx::Transform expected_scale_surface_layer_draw_transform =
       scale_small_matrix;
+  expected_scale_surface_layer_draw_transform.Scale(
+      device_scale_factor * page_scale_factor,
+      device_scale_factor * page_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_scale_surface_layer_draw_transform,
                                   scale_surface->draw_transform());
 
   // The scale for the perspective surface is not known, so it is rendered 1:1
   // with the screen, and then scaled during drawing.
   gfx::Transform expected_perspective_surface_draw_transform;
   expected_perspective_surface_draw_transform.Translate(
       device_scale_factor * page_scale_factor *
       perspective_surface->position().x(),
       device_scale_factor * page_scale_factor *
       perspective_surface->position().y());
   expected_perspective_surface_draw_transform.PreconcatTransform(
       perspective_matrix);
   expected_perspective_surface_draw_transform.PreconcatTransform(
       scale_small_matrix);
   gfx::Transform expected_perspective_surface_layer_draw_transform;
+  expected_perspective_surface_layer_draw_transform.Scale(
+      device_scale_factor * page_scale_factor,
+      device_scale_factor * page_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_perspective_surface_draw_transform,
       perspective_surface->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_perspective_surface_layer_draw_transform,
       perspective_surface->draw_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest,
      LayerTransformsInHighDPIAccurateScaleZeroChildPosition) {
   // Verify draw and screen space transforms of layers not in a surface.
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
-  scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> parent =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(133, 133),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> child = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> child = CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(child.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(13, 13),
                                false,
                                true);
 
-  scoped_refptr<NoScaleContentLayer> child_no_scale =
-      CreateNoScaleDrawableContentLayer(&delegate);
+  scoped_refptr<NoScalePictureLayer> child_no_scale =
+      CreateNoScaleDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(child_no_scale.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(13, 13),
                                false,
                                true);
 
   parent->AddChild(child);
   parent->AddChild(child_no_scale);
 
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   host->SetRootLayer(parent);
 
   float device_scale_factor = 1.7f;
   float page_scale_factor = 1.f;
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       parent.get(), parent->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.page_scale_factor = page_scale_factor;
   inputs.page_scale_application_layer = parent.get();
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
-  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
-  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, child);
+  EXPECT_CONTENTS_SCALE_EQ(1, parent);

[danakj, 2014/09/17 14:55:58]

we should check the layer's ideal_contents_scale instead of the
contents_scale_x() now. we're still computing something in LTHCommon it's just
being used differently on picture layer impl now.

+  EXPECT_CONTENTS_SCALE_EQ(1, child);
   EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
 
   EXPECT_EQ(1u, render_surface_layer_list.size());
 
   // Verify parent transforms
   gfx::Transform expected_parent_transform;
+  expected_parent_transform.Scale(device_scale_factor * page_scale_factor,
+                                  device_scale_factor * page_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
                                   parent->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
                                   parent->draw_transform());
 
   // Verify results of transformed parent rects
   gfx::RectF parent_content_bounds(parent->content_bounds());
 
   gfx::RectF parent_draw_rect =
       MathUtil::MapClippedRect(parent->draw_transform(), parent_content_bounds);
   gfx::RectF parent_screen_space_rect = MathUtil::MapClippedRect(
       parent->screen_space_transform(), parent_content_bounds);
 
   gfx::RectF expected_parent_draw_rect(parent->bounds());
   expected_parent_draw_rect.Scale(device_scale_factor);
-  expected_parent_draw_rect.set_width(ceil(expected_parent_draw_rect.width()));
-  expected_parent_draw_rect.set_height(
-      ceil(expected_parent_draw_rect.height()));
+  expected_parent_draw_rect.set_width((expected_parent_draw_rect.width()));
+  expected_parent_draw_rect.set_height((expected_parent_draw_rect.height()));
   EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_draw_rect);
   EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_screen_space_rect);
 
   // Verify child transforms
   gfx::Transform expected_child_transform;
+  expected_child_transform.Scale(device_scale_factor * page_scale_factor,
+                                 device_scale_factor * page_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->screen_space_transform());
 
   // Verify results of transformed child rects
   gfx::RectF child_content_bounds(child->content_bounds());
 
   gfx::RectF child_draw_rect =
       MathUtil::MapClippedRect(child->draw_transform(), child_content_bounds);
   gfx::RectF child_screen_space_rect = MathUtil::MapClippedRect(
       child->screen_space_transform(), child_content_bounds);
 
   gfx::RectF expected_child_draw_rect(child->bounds());
   expected_child_draw_rect.Scale(device_scale_factor);
-  expected_child_draw_rect.set_width(ceil(expected_child_draw_rect.width()));
-  expected_child_draw_rect.set_height(ceil(expected_child_draw_rect.height()));
+  expected_child_draw_rect.set_width((expected_child_draw_rect.width()));
+  expected_child_draw_rect.set_height((expected_child_draw_rect.height()));
   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_draw_rect);
   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_screen_space_rect);
 
   // Verify child_no_scale transforms
   gfx::Transform expected_child_no_scale_transform = child->draw_transform();
   // All transforms operate on content rects. The child's content rect
-  // incorporates device scale, but the child_no_scale does not; add it here.
-  expected_child_no_scale_transform.Scale(device_scale_factor,
-                                          device_scale_factor);
+  // incorporates device scale, the child_no_scale also does.
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_no_scale_transform,
                                   child_no_scale->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_no_scale_transform,
                                   child_no_scale->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, ContentsScale) {
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
   SkMScalar initial_parent_scale = 1.75;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 1.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(gfx::Size(100, 100));
 
-  scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> parent =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> child_scale =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> child_scale =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(child_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> child_empty =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> child_empty =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(child_empty.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(),
                                false,
                                true);
 
-  scoped_refptr<NoScaleContentLayer> child_no_scale =
-      CreateNoScaleDrawableContentLayer(&delegate);
+  scoped_refptr<NoScalePictureLayer> child_no_scale =
+      CreateNoScaleDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(child_no_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(12.f, 12.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   root->AddChild(parent);
 
@@ skipping 10 matching lines @@
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     inputs.device_scale_factor = device_scale_factor;
     inputs.page_scale_factor = page_scale_factor;
     inputs.page_scale_application_layer = root.get();
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
-    EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
-                             initial_parent_scale, parent);
-    EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
-                             initial_parent_scale * initial_child_scale,
-                             child_scale);
-    EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
-                             initial_parent_scale * initial_child_scale,
-                             child_empty);
+    // Picturelayer's content scale is 1.f
+    EXPECT_CONTENTS_SCALE_EQ(1, parent);
+    EXPECT_CONTENTS_SCALE_EQ(1, child_scale);
+    EXPECT_CONTENTS_SCALE_EQ(1, child_empty);
     EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
 
-    // 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
+    // The parent is not scaled up and we would need to scale during draw. The
+    // child that can scale its contents should also need to scale during
     // draw. This shouldn't change if the child has empty bounds. The other
     // children should.
-    EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().get(0, 0));
-    EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().get(1, 1));
-    EXPECT_FLOAT_EQ(1.0, child_scale->draw_transform().matrix().get(0, 0));
-    EXPECT_FLOAT_EQ(1.0, child_scale->draw_transform().matrix().get(1, 1));
-    EXPECT_FLOAT_EQ(1.0, child_empty->draw_transform().matrix().get(0, 0));
-    EXPECT_FLOAT_EQ(1.0, child_empty->draw_transform().matrix().get(1, 1));
+    EXPECT_FLOAT_EQ(
+        device_scale_factor * page_scale_factor * initial_parent_scale,
+        parent->draw_transform().matrix().get(0, 0));
+    EXPECT_FLOAT_EQ(
+        device_scale_factor * page_scale_factor * initial_parent_scale,
+        parent->draw_transform().matrix().get(1, 1));
+    EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
+                        initial_parent_scale * initial_child_scale,
+                    child_scale->draw_transform().matrix().get(0, 0));
+    EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
+                        initial_parent_scale * initial_child_scale,
+                    child_scale->draw_transform().matrix().get(1, 1));
+    EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
+                        initial_parent_scale * initial_child_scale,
+                    child_empty->draw_transform().matrix().get(0, 0));
+    EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
+                        initial_parent_scale * initial_child_scale,
+                    child_empty->draw_transform().matrix().get(1, 1));
     EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
                         initial_parent_scale * initial_child_scale,
                     child_no_scale->draw_transform().matrix().get(0, 0));
     EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
                         initial_parent_scale * initial_child_scale,
                     child_no_scale->draw_transform().matrix().get(1, 1));
   }
-
-  // If the device_scale_factor or page_scale_factor changes, then it should be
-  // updated using the initial transform as the raster scale.
-  device_scale_factor = 2.25f;
-  page_scale_factor = 1.25f;
-
-  {
-    RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
-    inputs.device_scale_factor = device_scale_factor;
-    inputs.page_scale_factor = page_scale_factor;
-    inputs.page_scale_application_layer = root.get();
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
-
-    EXPECT_CONTENTS_SCALE_EQ(
-        device_scale_factor * page_scale_factor * initial_parent_scale, parent);
-    EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
-                                 initial_parent_scale * initial_child_scale,
-                             child_scale);
-    EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
-                             initial_parent_scale * initial_child_scale,
-                             child_empty);
-    EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
-  }
-
-  // If the transform changes, we expect the raster scale to be reset to 1.0.
-  SkMScalar second_child_scale = 1.75;
-  child_scale_matrix.Scale(second_child_scale / initial_child_scale,
-                           second_child_scale / initial_child_scale);
-  child_scale->SetTransform(child_scale_matrix);
-  child_empty->SetTransform(child_scale_matrix);
-
-  {
-    RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
-    inputs.device_scale_factor = device_scale_factor;
-    inputs.page_scale_factor = page_scale_factor;
-    inputs.page_scale_application_layer = root.get();
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
-
-    EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
-                             initial_parent_scale,
-                             parent);
-    EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
-                             child_scale);
-    EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
-                             child_empty);
-    EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
-  }
-
-  // If the device_scale_factor or page_scale_factor changes, then it should be
-  // updated, but still using 1.0 as the raster scale.
-  device_scale_factor = 2.75f;
-  page_scale_factor = 1.75f;
-
-  {
-    RenderSurfaceLayerList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
-    inputs.device_scale_factor = device_scale_factor;
-    inputs.page_scale_factor = page_scale_factor;
-    inputs.page_scale_application_layer = root.get();
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
-
-    EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
-                             initial_parent_scale,
-                             parent);
-    EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
-                             child_scale);
-    EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
-                             child_empty);
-    EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
-  }
 }
 
 TEST_F(LayerTreeHostCommonTest,
      ContentsScale_LayerTransformsDontAffectContentsScale) {
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
   SkMScalar initial_parent_scale = 1.75;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 1.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(gfx::Size(100, 100));
 
-  scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> parent =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> child_scale =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> child_scale =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(child_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> child_empty =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> child_empty =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(child_empty.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(),
                                false,
                                true);
 
-  scoped_refptr<NoScaleContentLayer> child_no_scale =
-      CreateNoScaleDrawableContentLayer(&delegate);
+  scoped_refptr<NoScalePictureLayer> child_no_scale =
+      CreateNoScaleDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(child_no_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(12.f, 12.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   root->AddChild(parent);
 
   parent->AddChild(child_scale);
   parent->AddChild(child_empty);
   parent->AddChild(child_no_scale);
 
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   host->SetRootLayer(root);
 
   RenderSurfaceLayerList render_surface_layer_list;
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 1.f;
 
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.page_scale_factor = page_scale_factor;
   inputs.page_scale_application_layer = root.get(),
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
-  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
-  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
-                           child_scale);
-  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
-                           child_empty);
+  EXPECT_CONTENTS_SCALE_EQ(1, parent);
+  EXPECT_CONTENTS_SCALE_EQ(1, child_scale);
+  EXPECT_CONTENTS_SCALE_EQ(1, child_empty);
   EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
 
-  // Since the transform scale does not affect contents scale, it should affect
-  // the draw transform instead.
-  EXPECT_FLOAT_EQ(initial_parent_scale,
-                  parent->draw_transform().matrix().get(0, 0));
-  EXPECT_FLOAT_EQ(initial_parent_scale,
-                  parent->draw_transform().matrix().get(1, 1));
-  EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale,
+  // Since the transform scale affects contents scale, it should not affect
+  // the draw transform.
+  EXPECT_FLOAT_EQ(
+      initial_parent_scale * device_scale_factor * page_scale_factor,
+      parent->draw_transform().matrix().get(0, 0));
+  EXPECT_FLOAT_EQ(
+      initial_parent_scale * device_scale_factor * page_scale_factor,
+      parent->draw_transform().matrix().get(1, 1));
+  EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale *
+                      device_scale_factor * page_scale_factor,
                   child_scale->draw_transform().matrix().get(0, 0));
-  EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale,
+  EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale *
+                      device_scale_factor * page_scale_factor,
                   child_scale->draw_transform().matrix().get(1, 1));
-  EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale,
+  EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale *
+                      device_scale_factor * page_scale_factor,
                   child_empty->draw_transform().matrix().get(0, 0));
-  EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale,
+  EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale *
+                      device_scale_factor * page_scale_factor,
                   child_empty->draw_transform().matrix().get(1, 1));
   EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
                       initial_parent_scale * initial_child_scale,
                   child_no_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
                       initial_parent_scale * initial_child_scale,
                   child_no_scale->draw_transform().matrix().get(1, 1));
 }
 
 TEST_F(LayerTreeHostCommonTest, SmallContentsScale) {
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
   SkMScalar initial_parent_scale = 1.75;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 0.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(gfx::Size(100, 100));
 
-  scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> parent =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> child_scale =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> child_scale =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(child_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   root->AddChild(parent);
 
   parent->AddChild(child_scale);
 
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   host->SetRootLayer(root);
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 0.01f;
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     inputs.device_scale_factor = device_scale_factor;
     inputs.page_scale_factor = page_scale_factor;
     inputs.page_scale_application_layer = root.get();
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
-    EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
-                             initial_parent_scale,
-                             parent);
-    // The child's scale is < 1, so we should not save and use that scale
-    // factor.
-    EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor * 1,
-                             child_scale);
+    EXPECT_CONTENTS_SCALE_EQ(1, parent);
+    EXPECT_CONTENTS_SCALE_EQ(1, child_scale);
   }
 
   // When chilld's total scale becomes >= 1, we should save and use that scale
   // factor.
   child_scale_matrix.MakeIdentity();
   SkMScalar final_child_scale = 0.75;
   child_scale_matrix.Scale(final_child_scale, final_child_scale);
   child_scale->SetTransform(child_scale_matrix);
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     inputs.device_scale_factor = device_scale_factor;
     inputs.page_scale_factor = page_scale_factor;
     inputs.page_scale_application_layer = root.get();
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
-    EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
-                             initial_parent_scale,
-                             parent);
-    EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
-                             initial_parent_scale * final_child_scale,
-                             child_scale);
+    EXPECT_CONTENTS_SCALE_EQ(1, parent);
+    EXPECT_CONTENTS_SCALE_EQ(1, child_scale);
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, ContentsScaleForSurfaces) {
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
   SkMScalar initial_parent_scale = 2.0;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 3.0;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(gfx::Size(100, 100));
 
-  scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> parent =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> surface_scale =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> surface_scale =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(surface_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> surface_scale_child_scale =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> surface_scale_child_scale =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(surface_scale_child_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
-  scoped_refptr<NoScaleContentLayer> surface_scale_child_no_scale =
-      CreateNoScaleDrawableContentLayer(&delegate);
+  scoped_refptr<NoScalePictureLayer> surface_scale_child_no_scale =
+      CreateNoScaleDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(surface_scale_child_no_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<NoScaleContentLayer> surface_no_scale =
       CreateNoScaleDrawableContentLayer(&delegate);
   SetLayerPropertiesForTesting(surface_no_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(12.f, 12.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> surface_no_scale_child_scale =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> surface_no_scale_child_scale =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(surface_no_scale_child_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<NoScaleContentLayer> surface_no_scale_child_no_scale =
       CreateNoScaleDrawableContentLayer(&delegate);
@@ skipping 26 matching lines @@
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.page_scale_factor = page_scale_factor;
   inputs.page_scale_application_layer = root.get();
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
-  EXPECT_CONTENTS_SCALE_EQ(
-      device_scale_factor * page_scale_factor * initial_parent_scale, parent);
-  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
-                               initial_parent_scale * initial_child_scale,
-                           surface_scale);
+  EXPECT_CONTENTS_SCALE_EQ(1, parent);
+  EXPECT_CONTENTS_SCALE_EQ(1, surface_scale);
   EXPECT_CONTENTS_SCALE_EQ(1, surface_no_scale);
-  EXPECT_CONTENTS_SCALE_EQ(
-      device_scale_factor * page_scale_factor * initial_parent_scale *
-      initial_child_scale * initial_child_scale,
-      surface_scale_child_scale);
+  EXPECT_CONTENTS_SCALE_EQ(1, surface_scale_child_scale);
   EXPECT_CONTENTS_SCALE_EQ(1, surface_scale_child_no_scale);
-  EXPECT_CONTENTS_SCALE_EQ(
-      device_scale_factor * page_scale_factor * initial_parent_scale *
-      initial_child_scale * initial_child_scale,
-      surface_no_scale_child_scale);
+  EXPECT_CONTENTS_SCALE_EQ(1, surface_no_scale_child_scale);
   EXPECT_CONTENTS_SCALE_EQ(1, surface_no_scale_child_no_scale);
 
-  // The parent is scaled up and shouldn't need to scale during draw.
-  EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().get(0, 0));
-  EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().get(1, 1));
+  // The parent is not scaled up and should need to scale during draw.
+  EXPECT_FLOAT_EQ(
+      device_scale_factor * page_scale_factor * initial_parent_scale,
+      parent->draw_transform().matrix().get(0, 0));
+  EXPECT_FLOAT_EQ(
+      device_scale_factor * page_scale_factor * initial_parent_scale,
+      parent->draw_transform().matrix().get(1, 1));
 
   // RenderSurfaces should always be 1:1 with their target.
   EXPECT_FLOAT_EQ(
-      1.0,
-      surface_scale->render_surface()->draw_transform().matrix().get(0, 0));
+      1, surface_scale->render_surface()->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
-      1.0,
-      surface_scale->render_surface()->draw_transform().matrix().get(1, 1));
+      1, surface_scale->render_surface()->draw_transform().matrix().get(1, 1));
 
-  // The surface_scale can apply contents scale so the layer shouldn't need to
+  // The surface_scale cannot apply contents scale so the layer would need to
   // scale during draw.
-  EXPECT_FLOAT_EQ(1.0, surface_scale->draw_transform().matrix().get(0, 0));
-  EXPECT_FLOAT_EQ(1.0, surface_scale->draw_transform().matrix().get(1, 1));
+  EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
+                      initial_parent_scale * initial_child_scale,
+                  surface_scale->draw_transform().matrix().get(0, 0));
+  EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
+                      initial_parent_scale * initial_child_scale,
+                  surface_scale->draw_transform().matrix().get(1, 1));
 
-  // The surface_scale_child_scale can apply contents scale so it shouldn't need
+  // The surface_scale_child_scale cannot apply contents scale so it would need
   // to scale during draw.
   EXPECT_FLOAT_EQ(
-      1.0, surface_scale_child_scale->draw_transform().matrix().get(0, 0));
+      device_scale_factor * page_scale_factor * initial_parent_scale *
+          initial_child_scale * initial_child_scale,
+      surface_scale_child_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
-      1.0, surface_scale_child_scale->draw_transform().matrix().get(1, 1));
+      device_scale_factor * page_scale_factor * initial_parent_scale *
+          initial_child_scale * initial_child_scale,
+      surface_scale_child_scale->draw_transform().matrix().get(1, 1));
 
   // The surface_scale_child_no_scale can not apply contents scale, so it needs
   // to be scaled during draw.
   EXPECT_FLOAT_EQ(
       device_scale_factor * page_scale_factor * initial_parent_scale *
           initial_child_scale * initial_child_scale,
       surface_scale_child_no_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
       device_scale_factor * page_scale_factor * initial_parent_scale *
           initial_child_scale * initial_child_scale,
       surface_scale_child_no_scale->draw_transform().matrix().get(1, 1));
 
   // RenderSurfaces should always be 1:1 with their target.
   EXPECT_FLOAT_EQ(
-      1.0,
+      1,
       surface_no_scale->render_surface()->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
-      1.0,
+      1,
       surface_no_scale->render_surface()->draw_transform().matrix().get(1, 1));
 
   // The surface_no_scale layer can not apply contents scale, so it needs to be
   // scaled during draw.
   EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
                       initial_parent_scale * initial_child_scale,
                   surface_no_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
                       initial_parent_scale * initial_child_scale,
                   surface_no_scale->draw_transform().matrix().get(1, 1));
 
-  // The surface_scale_child_scale can apply contents scale so it shouldn't need
+  // The surface_scale_child_scale can not apply contents scale so it should
+  // need
   // to scale during draw.
   EXPECT_FLOAT_EQ(
-      1.0, surface_no_scale_child_scale->draw_transform().matrix().get(0, 0));
+      device_scale_factor * page_scale_factor * initial_parent_scale *
+          initial_child_scale * initial_child_scale,
+      surface_no_scale_child_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
-      1.0, surface_no_scale_child_scale->draw_transform().matrix().get(1, 1));
+      device_scale_factor * page_scale_factor * initial_parent_scale *
+          initial_child_scale * initial_child_scale,
+      surface_no_scale_child_scale->draw_transform().matrix().get(1, 1));
 
   // The surface_scale_child_no_scale can not apply contents scale, so it needs
   // to be scaled during draw.
   EXPECT_FLOAT_EQ(
       device_scale_factor * page_scale_factor * initial_parent_scale *
           initial_child_scale * initial_child_scale,
       surface_no_scale_child_no_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
       device_scale_factor * page_scale_factor * initial_parent_scale *
           initial_child_scale * initial_child_scale,
       surface_no_scale_child_no_scale->draw_transform().matrix().get(1, 1));
 }
 
 TEST_F(LayerTreeHostCommonTest,
      ContentsScaleForSurfaces_LayerTransformsDontAffectContentsScale) {
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
   SkMScalar initial_parent_scale = 2.0;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 3.0;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(gfx::Size(100, 100));
 
-  scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> parent =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> surface_scale =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> surface_scale =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(surface_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> surface_scale_child_scale =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> surface_scale_child_scale =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(surface_scale_child_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
-  scoped_refptr<NoScaleContentLayer> surface_scale_child_no_scale =
-      CreateNoScaleDrawableContentLayer(&delegate);
+  scoped_refptr<NoScalePictureLayer> surface_scale_child_no_scale =
+      CreateNoScaleDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(surface_scale_child_no_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
-  scoped_refptr<NoScaleContentLayer> surface_no_scale =
-      CreateNoScaleDrawableContentLayer(&delegate);
+  scoped_refptr<NoScalePictureLayer> surface_no_scale =
+      CreateNoScaleDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(surface_no_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(12.f, 12.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> surface_no_scale_child_scale =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> surface_no_scale_child_scale =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(surface_no_scale_child_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   scoped_refptr<NoScaleContentLayer> surface_no_scale_child_no_scale =
       CreateNoScaleDrawableContentLayer(&delegate);
@@ skipping 25 matching lines @@
 
   SkMScalar device_scale_factor = 5.0;
   SkMScalar page_scale_factor = 7.0;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.page_scale_factor = page_scale_factor;
   inputs.page_scale_application_layer = root.get();
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
-  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
-                           parent);
-  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
-                           surface_scale);
+  EXPECT_CONTENTS_SCALE_EQ(1, parent);
+  EXPECT_CONTENTS_SCALE_EQ(1, surface_scale);
   EXPECT_CONTENTS_SCALE_EQ(1.f, surface_no_scale);
-  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
-                           surface_scale_child_scale);
+  EXPECT_CONTENTS_SCALE_EQ(1, surface_scale_child_scale);
   EXPECT_CONTENTS_SCALE_EQ(1.f, surface_scale_child_no_scale);
-  EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
-                           surface_no_scale_child_scale);
+  EXPECT_CONTENTS_SCALE_EQ(1, surface_no_scale_child_scale);
   EXPECT_CONTENTS_SCALE_EQ(1.f, surface_no_scale_child_no_scale);
 
-  // The parent is scaled up during draw, since its contents are not scaled by
+  // The parent is not scaled up during draw, since its contents are scaled by
   // the transform hierarchy.
-  EXPECT_FLOAT_EQ(initial_parent_scale,
-                  parent->draw_transform().matrix().get(0, 0));
-  EXPECT_FLOAT_EQ(initial_parent_scale,
-                  parent->draw_transform().matrix().get(1, 1));
+  EXPECT_FLOAT_EQ(
+      device_scale_factor * page_scale_factor * initial_parent_scale,
+      parent->draw_transform().matrix().get(0, 0));
+  EXPECT_FLOAT_EQ(
+      device_scale_factor * page_scale_factor * initial_parent_scale,
+      parent->draw_transform().matrix().get(1, 1));
 
   // The child surface is scaled up during draw since its subtree is not scaled
   // by the transform hierarchy.
   EXPECT_FLOAT_EQ(
       initial_parent_scale * initial_child_scale,
       surface_scale->render_surface()->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
       initial_parent_scale * initial_child_scale,
       surface_scale->render_surface()->draw_transform().matrix().get(1, 1));
 
-  // The surface_scale's RenderSurface is scaled during draw, so the layer does
-  // not need to be scaled when drawing into its surface.
-  EXPECT_FLOAT_EQ(1.0, surface_scale->draw_transform().matrix().get(0, 0));
-  EXPECT_FLOAT_EQ(1.0, surface_scale->draw_transform().matrix().get(1, 1));
+  // The surface_scale's RenderSurface is not scaled during draw, so the layer
+  // need to be scaled when drawing into its surface.
+  EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor,
+                  surface_scale->draw_transform().matrix().get(0, 0));
+  EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor,
+                  surface_scale->draw_transform().matrix().get(1, 1));
 
-  // The surface_scale_child_scale is scaled when drawing into its surface,
-  // since its content bounds are not scaled by the transform hierarchy.
+  // The surface_scale_child_scale is not scaled when drawing into its surface,
+  // since its content bounds are scaled by the transform hierarchy.
   EXPECT_FLOAT_EQ(
-      initial_child_scale,
+      initial_child_scale * device_scale_factor * page_scale_factor,
       surface_scale_child_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
-      initial_child_scale,
+      initial_child_scale * device_scale_factor * page_scale_factor,
       surface_scale_child_scale->draw_transform().matrix().get(1, 1));
 
   // The surface_scale_child_no_scale has a fixed contents scale of 1, so it
   // needs to be scaled by the device and page scale factors, along with the
   // transform hierarchy.
   EXPECT_FLOAT_EQ(
       device_scale_factor * page_scale_factor * initial_child_scale,
       surface_scale_child_no_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
       device_scale_factor * page_scale_factor * initial_child_scale,
@@ skipping 10 matching lines @@
 
   // The surface_no_scale layer has a fixed contents scale of 1, so it needs to
   // be scaled by the device and page scale factors. Its surface is already
   // scaled by the transform hierarchy so those don't need to scale the layer's
   // drawing.
   EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor,
                   surface_no_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor,
                   surface_no_scale->draw_transform().matrix().get(1, 1));
 
-  // The surface_no_scale_child_scale has its contents scaled by the page and
-  // device scale factors, but needs to be scaled by the transform hierarchy
-  // when drawing.
+  // The surface_no_scale_child_scale doesnt have its contents scaled
+  // by the page and device scale factors.
   EXPECT_FLOAT_EQ(
-      initial_child_scale,
+      initial_child_scale * device_scale_factor * page_scale_factor,
       surface_no_scale_child_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
-      initial_child_scale,
+      initial_child_scale * device_scale_factor * page_scale_factor,
       surface_no_scale_child_scale->draw_transform().matrix().get(1, 1));
 
   // The surface_no_scale_child_no_scale has a fixed contents scale of 1, so it
   // needs to be scaled by the device and page scale factors. It also needs to
   // be scaled by any transform heirarchy below its target surface.
   EXPECT_FLOAT_EQ(
       device_scale_factor * page_scale_factor * initial_child_scale,
       surface_no_scale_child_no_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
       device_scale_factor * page_scale_factor * initial_child_scale,
       surface_no_scale_child_no_scale->draw_transform().matrix().get(1, 1));
 }
 
 TEST_F(LayerTreeHostCommonTest, ContentsScaleForAnimatingLayer) {
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
   SkMScalar initial_parent_scale = 1.75;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 1.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(gfx::Size(100, 100));
 
-  scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> parent =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> child_scale =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> child_scale =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(child_scale.get(),
                                child_scale_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   root->AddChild(parent);
 
   parent->AddChild(child_scale);
 
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   host->SetRootLayer(root);
 
   // Now put an animating transform on child.
   int animation_id = AddAnimatedTransformToController(
       child_scale->layer_animation_controller(), 10.0, 30, 0);
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
-    EXPECT_CONTENTS_SCALE_EQ(initial_parent_scale, parent);
+    // Picturelayer's content scale is 1.f
+    EXPECT_CONTENTS_SCALE_EQ(1, parent);
     // The layers with animating transforms should not compute a contents scale
     // other than 1 until they finish animating.
     EXPECT_CONTENTS_SCALE_EQ(1, child_scale);
   }
 
   // Remove the animation, now it can save a raster scale.
   child_scale->layer_animation_controller()->RemoveAnimation(animation_id);
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
-    EXPECT_CONTENTS_SCALE_EQ(initial_parent_scale, parent);
+    EXPECT_CONTENTS_SCALE_EQ(1, parent);
     // The layers with animating transforms should not compute a contents scale
     // other than 1 until they finish animating.
-    EXPECT_CONTENTS_SCALE_EQ(initial_parent_scale * initial_child_scale,
-                             child_scale);
+    EXPECT_CONTENTS_SCALE_EQ(1, child_scale);
   }
 }
 
 TEST_F(LayerTreeHostCommonTest,
        ChangeInContentBoundsOrScaleTriggersPushProperties) {
   MockContentLayerClient delegate;
   scoped_refptr<Layer> root = Layer::Create();
-  scoped_refptr<Layer> child = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> child = CreateDrawablePictureLayer(&delegate);
   root->AddChild(child);
 
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
@@ skipping 12 matching lines @@
   child->reset_needs_push_properties_for_testing();
 
   // This will change both layers' content bounds.
   ExecuteCalculateDrawProperties(root.get());
   EXPECT_TRUE(root->needs_push_properties());
   EXPECT_TRUE(child->needs_push_properties());
 
   root->reset_needs_push_properties_for_testing();
   child->reset_needs_push_properties_for_testing();
 
-  // This will change only the child layer's contents scale and content bounds,
-  // since the root layer is not a ContentsScalingLayer.
-  ExecuteCalculateDrawProperties(root.get(), 2.f);
-  EXPECT_FALSE(root->needs_push_properties());
-  EXPECT_TRUE(child->needs_push_properties());
-
-  root->reset_needs_push_properties_for_testing();
-  child->reset_needs_push_properties_for_testing();
-
   // This will not change either layer's contents scale or content bounds.
   ExecuteCalculateDrawProperties(root.get(), 2.f);
   EXPECT_FALSE(root->needs_push_properties());
   EXPECT_FALSE(child->needs_push_properties());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceTransformsInHighDPI) {
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
-  scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> parent =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(30, 30),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> child = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> child = CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(child.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   gfx::Transform replica_transform;
   replica_transform.Scale(1.0, -1.0);
-  scoped_refptr<ContentLayer> replica = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> replica =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(replica.get(),
                                replica_transform,
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   // This layer should end up in the same surface as child, with the same draw
   // and screen space transforms.
-  scoped_refptr<ContentLayer> duplicate_child_non_owner =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> duplicate_child_non_owner =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(duplicate_child_non_owner.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   parent->AddChild(child);
   child->AddChild(duplicate_child_non_owner);
   child->SetReplicaLayer(replica.get());
 
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   host->SetRootLayer(parent);
 
   RenderSurfaceLayerList render_surface_layer_list;
 
   float device_scale_factor = 1.5f;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       parent.get(), parent->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // 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, render_surface_layer_list.size());
 
   gfx::Transform expected_parent_transform;
+  expected_parent_transform.Scale(device_scale_factor, device_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
                                   parent->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
                                   parent->draw_transform());
 
   gfx::Transform expected_draw_transform;
+  expected_draw_transform.Scale(device_scale_factor, device_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_draw_transform,
                                   child->draw_transform());
 
   gfx::Transform expected_screen_space_transform;
   expected_screen_space_transform.Translate(
       device_scale_factor * child->position().x(),
       device_scale_factor * child->position().y());
+  expected_screen_space_transform.Scale(device_scale_factor,
+                                        device_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_screen_space_transform,
                                   child->screen_space_transform());
 
   gfx::Transform expected_duplicate_child_draw_transform =
       child->draw_transform();
   EXPECT_TRANSFORMATION_MATRIX_EQ(child->draw_transform(),
                                   duplicate_child_non_owner->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       child->screen_space_transform(),
       duplicate_child_non_owner->screen_space_transform());
@@ skipping 40 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_replica_screen_space_transform,
       child->render_surface()->replica_screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest,
      RenderSurfaceTransformsInHighDPIAccurateScaleZeroPosition) {
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
-  scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> parent =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(33, 31),
                                false,
                                true);
 
-  scoped_refptr<ContentLayer> child = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> child = CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(child.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(13, 11),
                                false,
                                true);
 
   gfx::Transform replica_transform;
   replica_transform.Scale(1.0, -1.0);
-  scoped_refptr<ContentLayer> replica = CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> replica =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(replica.get(),
                                replica_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(13, 11),
                                false,
                                true);
 
   // This layer should end up in the same surface as child, with the same draw
   // and screen space transforms.
-  scoped_refptr<ContentLayer> duplicate_child_non_owner =
-      CreateDrawableContentLayer(&delegate);
+  scoped_refptr<FakePictureLayer> duplicate_child_non_owner =
+      CreateDrawablePictureLayer(&delegate);
   SetLayerPropertiesForTesting(duplicate_child_non_owner.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(13, 11),
                                false,
                                true);
 
   parent->AddChild(child);
   child->AddChild(duplicate_child_non_owner);
   child->SetReplicaLayer(replica.get());
 
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   host->SetRootLayer(parent);
 
   float device_scale_factor = 1.7f;
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       parent.get(), parent->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // 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, render_surface_layer_list.size());
 
-  gfx::Transform identity_transform;
-
-  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_transform,
-                                  parent->screen_space_transform());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_transform, parent->draw_transform());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_transform, child->draw_transform());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_transform,
-                                  child->screen_space_transform());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_transform,
+  gfx::Transform transform;
+  transform.Scale(device_scale_factor, device_scale_factor);
+  EXPECT_TRANSFORMATION_MATRIX_EQ(transform, parent->screen_space_transform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(transform, parent->draw_transform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(transform, child->draw_transform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(transform, child->screen_space_transform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(transform,
                                   duplicate_child_non_owner->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_transform, duplicate_child_non_owner->screen_space_transform());
+      transform, duplicate_child_non_owner->screen_space_transform());
   EXPECT_RECT_EQ(child->drawable_content_rect(),
                  duplicate_child_non_owner->drawable_content_rect());
   EXPECT_EQ(child->content_bounds(),
             duplicate_child_non_owner->content_bounds());
 
+  gfx::Transform identity_transform;
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_transform,
                                   child->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_transform,
                                   child->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       identity_transform, child->render_surface()->screen_space_transform());
 
   gfx::Transform expected_replica_draw_transform;
   expected_replica_draw_transform.matrix().set(1, 1, -1.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
@@ skipping 3069 matching lines @@
   // by the viewport.
   EXPECT_EQ(gfx::Rect(768 / 2, 582 / 2), root->visible_content_rect());
 
   // Layers drawing to a child render surface should still have their visible
   // content rect clipped by the viewport.
   EXPECT_EQ(gfx::Rect(768 / 2, 582 / 2), content->visible_content_rect());
 }
 
 }  // namespace
 }  // namespace cc