cc: Remove SetLayerPropertiesForTesting from LayerTreeHostCommonTestBase

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 <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 109 matching lines @@
       const gfx::Rect& layer_rect) {
     LayerImpl* root = root_layer_for_testing();
     LayerImpl* target = AddChild<LayerImpl>(root);
     LayerImpl* drawing_layer = AddChild<LayerImpl>(target);
 
     root->SetDrawsContent(true);
     target->SetDrawsContent(true);
     target->SetMasksToBounds(true);
     drawing_layer->SetDrawsContent(true);
 
-    gfx::Transform identity;
-
     root->SetBounds(gfx::Size(500, 500));
     root->test_properties()->force_render_surface = true;
     target->SetPosition(gfx::PointF(target_rect.origin()));
     target->SetBounds(target_rect.size());
     target->test_properties()->force_render_surface = true;
     drawing_layer->SetTransform(layer_transform);
     drawing_layer->SetPosition(gfx::PointF(layer_rect.origin()));
     drawing_layer->SetBounds(layer_rect.size());
     drawing_layer->test_properties()->should_flatten_transform = false;
 
     host_impl()->active_tree()->property_trees()->needs_rebuild = true;
     ExecuteCalculateDrawProperties(root);
 
     return drawing_layer;
   }
 };
 
 TEST_F(LayerTreeHostCommonTest, TransformsForNoOpLayer) {
   // Sanity check: For layers positioned at zero, with zero size,
   // and with identity transforms, then the draw transform,
   // screen space transform, and the hierarchy passed on to children
   // layers should also be identity transforms.
 
   LayerImpl* parent = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
-  gfx::Transform identity_matrix;
   parent->SetBounds(gfx::Size(100, 100));
 
   ExecuteCalculateDrawProperties(parent);
 
-  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->DrawTransform());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
+  EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), child->DrawTransform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                   child->ScreenSpaceTransform());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
+  EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                   grand_child->DrawTransform());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
+  EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                   grand_child->ScreenSpaceTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, EffectTreeTransformIdTest) {
   // Tests that effect tree node gets a valid transform id when a layer
   // has opacity but doesn't create a render surface.
   LayerImpl* parent = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   child->SetDrawsContent(true);
 
-  gfx::Transform identity_matrix;
   parent->SetBounds(gfx::Size(100, 100));
   child->SetPosition(gfx::PointF(10, 10));
   child->SetBounds(gfx::Size(100, 100));
   child->test_properties()->opacity = 0.f;
   ExecuteCalculateDrawProperties(parent);
   EffectTree& effect_tree =
       parent->layer_tree_impl()->property_trees()->effect_tree;
   EffectNode* node = effect_tree.Node(child->effect_tree_index());
   const int transform_tree_size = parent->layer_tree_impl()
                                       ->property_trees()
                                       ->transform_tree.next_available_id();
   EXPECT_LT(node->transform_id, transform_tree_size);
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForSingleLayer) {
-  gfx::Transform identity_matrix;
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* layer = AddChild<LayerImpl>(root);
 
   TransformTree& transform_tree =
       host_impl()->active_tree()->property_trees()->transform_tree;
   EffectTree& effect_tree =
       host_impl()->active_tree()->property_trees()->effect_tree;
 
   root->SetBounds(gfx::Size(1, 2));
 
   // Case 1: Setting the bounds of the layer should not affect either the draw
   // transform or the screenspace transform.
   layer->SetBounds(gfx::Size(10, 12));
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_matrix,
+      gfx::Transform(),
       draw_property_utils::DrawTransform(layer, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_matrix,
+      gfx::Transform(),
       draw_property_utils::ScreenSpaceTransform(layer, transform_tree));
 
   // Case 2: The anchor point by itself (without a layer transform) should have
   // no effect on the transforms.
   layer->test_properties()->transform_origin = gfx::Point3F(2.5f, 3.0f, 0.f);
   layer->SetBounds(gfx::Size(10, 12));
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_matrix,
+      gfx::Transform(),
       draw_property_utils::DrawTransform(layer, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_matrix,
+      gfx::Transform(),
       draw_property_utils::ScreenSpaceTransform(layer, transform_tree));
 
   // Case 3: A change in actual position affects both the draw transform and
   // screen space transform.
   gfx::Transform position_transform;
   position_transform.Translate(0.f, 1.2f);
   layer->SetPosition(gfx::PointF(0.f, 1.2f));
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
@@ skipping 59 matching lines @@
                                          -kScrollOffset.y());
   float page_scale = 0.888f;
   const float kDeviceScale = 1.666f;
 
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
 
-  gfx::Transform identity_matrix;
   std::unique_ptr<LayerImpl> sublayer_scoped_ptr(
       LayerImpl::Create(host_impl.active_tree(), 1));
   LayerImpl* sublayer = sublayer_scoped_ptr.get();
   sublayer->SetDrawsContent(true);
   sublayer->SetBounds(gfx::Size(500, 500));
 
   std::unique_ptr<LayerImpl> scroll_layer_scoped_ptr(
       LayerImpl::Create(host_impl.active_tree(), 2));
   LayerImpl* scroll_layer = scroll_layer_scoped_ptr.get();
   scroll_layer->SetBounds(gfx::Size(10, 20));
@@ skipping 19 matching lines @@
   std::unique_ptr<LayerImpl> root(
       LayerImpl::Create(host_impl.active_tree(), 3));
   root->SetBounds(gfx::Size(3, 4));
   root->test_properties()->AddChild(std::move(clip_layer_scoped_ptr));
   root->SetHasRenderSurface(true);
   LayerImpl* root_layer = root.get();
   host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
 
   ExecuteCalculateDrawProperties(root_layer, kDeviceScale, page_scale,
                                  scroll_layer->test_properties()->parent);
-  gfx::Transform expected_transform = identity_matrix;
+  gfx::Transform expected_transform;
   gfx::PointF sub_layer_screen_position = kScrollLayerPosition - kScrollDelta;
   expected_transform.Translate(MathUtil::Round(sub_layer_screen_position.x() *
                                                page_scale * kDeviceScale),
                                MathUtil::Round(sub_layer_screen_position.y() *
                                                page_scale * kDeviceScale));
   expected_transform.Scale(page_scale * kDeviceScale,
                            page_scale * kDeviceScale);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
                                   sublayer->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
@@ skipping 38 matching lines @@
       MathUtil::Round(kTranslateY * page_scale * kDeviceScale +
                       sub_layer_screen_position.y() * page_scale *
                           kDeviceScale));
   expected_transform.Scale(page_scale * kDeviceScale,
                            page_scale * kDeviceScale);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
                                   sublayer->DrawTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForSimpleHierarchy) {
-  gfx::Transform identity_matrix;
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   // One-time setup of root layer
   root->SetBounds(gfx::Size(1, 2));
 
   TransformTree& transform_tree =
       host_impl()->active_tree()->property_trees()->transform_tree;
   EffectTree& effect_tree =
       host_impl()->active_tree()->property_trees()->effect_tree;
 
   // Case 1: parent's anchor point should not affect child or grand_child.
   parent->test_properties()->transform_origin = gfx::Point3F(2.5f, 3.0f, 0.f);
   parent->SetBounds(gfx::Size(10, 12));
   child->SetBounds(gfx::Size(16, 18));
   grand_child->SetBounds(gfx::Size(76, 78));
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_matrix,
+      gfx::Transform(),
       draw_property_utils::DrawTransform(child, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_matrix,
+      gfx::Transform(),
       draw_property_utils::ScreenSpaceTransform(child, transform_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_matrix, draw_property_utils::DrawTransform(
-                           grand_child, transform_tree, effect_tree));
+      gfx::Transform(), draw_property_utils::DrawTransform(
+                            grand_child, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_matrix,
+      gfx::Transform(),
       draw_property_utils::ScreenSpaceTransform(grand_child, transform_tree));
 
   // Case 2: parent's position affects child and grand_child.
   gfx::Transform parent_position_transform;
   parent_position_transform.Translate(0.f, 1.2f);
   parent->SetPosition(gfx::PointF(0.f, 1.2f));
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_position_transform,
@@ skipping 569 matching lines @@
   ASSERT_TRUE(child->has_render_surface());
   // This is the real test, the rest are sanity checks.
   EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                   child->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                   grand_child->DrawTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceWithSublayerScale) {
-  const gfx::Transform identity_matrix;
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(render_surface);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   gfx::Transform translate;
   translate.Translate3d(5, 5, 5);
 
   root->SetBounds(gfx::Size(100, 100));
   render_surface->SetTransform(translate);
@@ skipping 17 matching lines @@
   // Between grand_child and render_surface, we translate by (10, 10) and scale
   // by a factor of 2.
   gfx::Vector2dF expected_translation(20.0f, 20.0f);
   EXPECT_EQ(grand_child->DrawTransform().To2dTranslation(),
             expected_translation);
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
   // Transformations applied at the root of the tree should be forwarded
   // to child layers instead of applied to the root RenderSurface.
-  const gfx::Transform identity_matrix;
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
 
   root->SetDrawsContent(true);
   root->SetBounds(gfx::Size(20, 20));
   child->SetDrawsContent(true);
   child->SetScrollClipLayer(root->id());
   child->SetBounds(gfx::Size(20, 20));
 
   gfx::Transform translate;
   translate.Translate(50, 50);
   {
     LayerImplList render_surface_layer_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), translate, &render_surface_layer_list_impl);
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         translate, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         translate, child->draw_properties().target_space_transform);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
+    EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                     root->render_surface()->draw_transform());
   }
 
   gfx::Transform scale;
   scale.Scale(2, 2);
   {
     LayerImplList render_surface_layer_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), scale, &render_surface_layer_list_impl);
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         scale, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         scale, child->draw_properties().target_space_transform);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
+    EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                     root->render_surface()->draw_transform());
   }
 
   gfx::Transform rotate;
   rotate.Rotate(2);
   {
     LayerImplList render_surface_layer_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), rotate, &render_surface_layer_list_impl);
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         rotate, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         rotate, child->draw_properties().target_space_transform);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
+    EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                     root->render_surface()->draw_transform());
   }
 
   gfx::Transform composite;
   composite.ConcatTransform(translate);
   composite.ConcatTransform(scale);
   composite.ConcatTransform(rotate);
   {
     LayerImplList render_surface_layer_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), composite, &render_surface_layer_list_impl);
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         composite, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         composite, child->draw_properties().target_space_transform);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
+    EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                     root->render_surface()->draw_transform());
   }
 
   // Verify it composes correctly with device scale.
   float device_scale_factor = 1.5f;
 
   {
     LayerImplList render_surface_layer_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), translate, &render_surface_layer_list_impl);
     inputs.device_scale_factor = device_scale_factor;
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     gfx::Transform device_scaled_translate = translate;
     device_scaled_translate.Scale(device_scale_factor, device_scale_factor);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         device_scaled_translate,
         root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         device_scaled_translate,
         child->draw_properties().target_space_transform);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
+    EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                     root->render_surface()->draw_transform());
   }
 
   // Verify it composes correctly with page scale.
   float page_scale_factor = 2.f;
 
   {
     LayerImplList render_surface_layer_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), translate, &render_surface_layer_list_impl);
     inputs.page_scale_factor = page_scale_factor;
     inputs.page_scale_layer = root;
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     gfx::Transform page_scaled_translate = translate;
     page_scaled_translate.Scale(page_scale_factor, page_scale_factor);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         page_scaled_translate, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         page_scaled_translate, child->draw_properties().target_space_transform);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
+    EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                     root->render_surface()->draw_transform());
   }
 
   // Verify that it composes correctly with transforms directly on root layer.
   root->SetTransform(composite);
 
   {
     LayerImplList render_surface_layer_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), composite, &render_surface_layer_list_impl);
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     gfx::Transform compositeSquared = composite;
     compositeSquared.ConcatTransform(composite);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         compositeSquared, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         compositeSquared, child->draw_properties().target_space_transform);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
+    EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                     root->render_surface()->draw_transform());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceListForRenderSurfaceWithClippedLayer) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
   LayerImpl* child = AddChild<LayerImpl>(render_surface1);
 
@@ skipping 421 matching lines @@
 
   // In this configuration, grand_child should be outside the clipped
   // content rect of the child, making grand_child not appear in the
   // render_surface_layer_list.
 
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   LayerImpl* leaf_node = AddChild<LayerImpl>(grand_child);
 
-  const gfx::Transform identity_matrix;
-
   root->SetMasksToBounds(true);
   root->SetBounds(gfx::Size(100, 100));
   child->SetBounds(gfx::Size(20, 20));
   child->test_properties()->force_render_surface = true;
   grand_child->SetPosition(gfx::PointF(200.f, 200.f));
   grand_child->SetBounds(gfx::Size(10, 10));
   grand_child->test_properties()->force_render_surface = true;
   leaf_node->SetBounds(gfx::Size(10, 10));
   leaf_node->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
@@ skipping 11 matching lines @@
   //    render target,
   //  - a surface is clipped by an ancestor that contributes to the same
   //    render target.
   //
   // In particular, for a layer that owns a render surface:
   //  - the render surface inherits any clip from ancestors, and does NOT
   //    pass that clipped status to the layer itself.
   //  - but if the layer itself masks to bounds, it is considered clipped
   //    and propagates the clip to the subtree.
 
-  const gfx::Transform identity_matrix;
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child1 = AddChild<LayerImpl>(parent);
   LayerImpl* child2 = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child1);
   LayerImpl* leaf_node1 = AddChild<LayerImpl>(grand_child);
   LayerImpl* leaf_node2 = AddChild<LayerImpl>(child2);
 
   root->SetBounds(gfx::Size(100, 100));
   parent->SetBounds(gfx::Size(100, 100));
@@ skipping 260 matching lines @@
   //   grand_child1 - completely inside the region; DrawableContentRect should
   //   be the layer rect expressed in target space.
   //   grand_child2 - partially clipped but NOT MasksToBounds; the clip rect
   //   will be the intersection of layer bounds and the mask region.
   //   grand_child3 - partially clipped and MasksToBounds; the
   //   DrawableContentRect will still be the intersection of layer bounds and
   //   the mask region.
   //   grand_child4 - outside parent's clip rect; the DrawableContentRect should
   //   be empty.
 
-  const gfx::Transform identity_matrix;
   LayerImpl* parent = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child1 = AddChild<LayerImpl>(child);
   LayerImpl* grand_child2 = AddChild<LayerImpl>(child);
   LayerImpl* grand_child3 = AddChild<LayerImpl>(child);
   LayerImpl* grand_child4 = AddChild<LayerImpl>(child);
 
   parent->SetBounds(gfx::Size(500, 500));
   child->SetMasksToBounds(true);
   child->SetBounds(gfx::Size(20, 20));
@@ skipping 535 matching lines @@
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   LayerImpl* great_grand_child = AddChild<LayerImpl>(grand_child);
 
   root->SetDrawsContent(true);
   child->SetDrawsContent(true);
   grand_child->SetDrawsContent(true);
   great_grand_child->SetDrawsContent(true);
 
-  gfx::Transform identity;
-
   root->SetBounds(gfx::Size(10, 10));
   child->SetBounds(gfx::Size(10, 10));
   grand_child->SetBounds(gfx::Size(10, 10));
   great_grand_child->SetBounds(gfx::Size(10, 10));
 
   SetElementIdsForTesting();
 
   // Add a transform animation with a start delay to |grand_child|.
   std::unique_ptr<Animation> animation = Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1.0)), 0, 1,
@@ skipping 411 matching lines @@
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), grand_child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 25, 25), grand_child2->drawable_content_rect());
   EXPECT_TRUE(grand_child3->drawable_content_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectWithClippingAndScaling) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
-  gfx::Transform identity_matrix;
   gfx::Transform child_scale_matrix;
   child_scale_matrix.Scale(0.25f, 0.25f);
   gfx::Transform grand_child_scale_matrix;
   grand_child_scale_matrix.Scale(0.246f, 0.246f);
 
   root->SetBounds(gfx::Size(100, 100));
   child->SetTransform(child_scale_matrix);
   child->SetBounds(gfx::Size(10, 10));
   child->SetMasksToBounds(true);
   grand_child->SetTransform(grand_child_scale_matrix);
@@ skipping 275 matching lines @@
        DrawableAndVisibleContentRectsForLayersWithUninvertibleTransform) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChildToRoot<LayerImpl>();
 
   root->SetBounds(gfx::Size(100, 100));
   child->SetPosition(gfx::PointF(5.f, 5.f));
   child->SetBounds(gfx::Size(50, 50));
   child->SetDrawsContent(true);
 
   // Case 1: a truly degenerate matrix
-  gfx::Transform identity_matrix;
   gfx::Transform uninvertible_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
 
   child->SetTransform(uninvertible_matrix);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(child->visible_layer_rect().IsEmpty());
   EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
 
   // Case 2: a matrix with flattened z, uninvertible and not visible according
@@ skipping 20 matching lines @@
   EXPECT_TRUE(child->visible_layer_rect().IsEmpty());
   EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleContentRectForLayerWithUninvertibleDrawTransform) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
-  gfx::Transform identity_matrix;
-
   gfx::Transform perspective;
   perspective.ApplyPerspectiveDepth(SkDoubleToMScalar(1e-12));
 
   gfx::Transform rotation;
   rotation.RotateAboutYAxis(45.0);
 
   root->SetBounds(gfx::Size(100, 100));
   child->SetTransform(perspective);
   child->SetPosition(gfx::PointF(10.f, 10.f));
   child->SetBounds(gfx::Size(100, 100));
@@ skipping 108 matching lines @@
 
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 1);
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl.active_tree(), 2);
   std::unique_ptr<LayerImpl> grand_child =
       LayerImpl::Create(host_impl.active_tree(), 3);
   std::unique_ptr<LayerImpl> occluding_child =
       LayerImpl::Create(host_impl.active_tree(), 4);
 
-  gfx::Transform identity_matrix;
   gfx::Transform perspective;
   perspective.ApplyPerspectiveDepth(SkDoubleToMScalar(1e-12));
 
   gfx::Transform rotation;
   rotation.RotateAboutYAxis(45.0);
 
   root->SetBounds(gfx::Size(1000, 1000));
   child->SetTransform(perspective);
   child->SetPosition(gfx::PointF(10.f, 10.f));
   child->SetBounds(gfx::Size(300, 300));
@@ skipping 357 matching lines @@
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsWithTransformOnUnclippedSurface) {
   // Layers that have non-axis aligned bounds (due to transforms) have an
   // expanded, axis-aligned DrawableContentRect and visible content rect.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* child1 = AddChild<LayerImpl>(render_surface);
 
-  gfx::Transform identity_matrix;
   gfx::Transform child_rotation;
   child_rotation.Rotate(45.0);
 
   root->SetBounds(gfx::Size(100, 100));
   render_surface->SetBounds(gfx::Size(3, 4));
   render_surface->test_properties()->force_render_surface = true;
   child1->SetTransform(child_rotation);
   child1->SetPosition(gfx::PointF(25.f, 25.f));
   child1->SetBounds(gfx::Size(50, 50));
   child1->SetDrawsContent(true);
@@ skipping 134 matching lines @@
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_layer_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;
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* front_facing_child = AddChildToRoot<LayerImpl>();
   LayerImpl* back_facing_child = AddChildToRoot<LayerImpl>();
   LayerImpl* front_facing_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* back_facing_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* front_facing_child_of_front_facing_surface =
       AddChild<LayerImpl>(front_facing_surface);
   LayerImpl* back_facing_child_of_front_facing_surface =
       AddChild<LayerImpl>(front_facing_surface);
   LayerImpl* front_facing_child_of_back_facing_surface =
@@ skipping 70 matching lines @@
   EXPECT_TRUE(UpdateLayerListImplContains(
       front_facing_child_of_front_facing_surface->id()));
   EXPECT_TRUE(UpdateLayerListImplContains(
       front_facing_child_of_back_facing_surface->id()));
 }
 
 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithPreserves3d) {
   // Verify the behavior of back-face culling when preserves-3d transform style
   // is used.
 
-  const gfx::Transform identity_matrix;
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* front_facing_child = AddChildToRoot<LayerImpl>();
   LayerImpl* back_facing_child = AddChildToRoot<LayerImpl>();
   LayerImpl* front_facing_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* back_facing_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* front_facing_child_of_front_facing_surface =
       AddChild<LayerImpl>(front_facing_surface);
   LayerImpl* back_facing_child_of_front_facing_surface =
       AddChild<LayerImpl>(front_facing_surface);
   LayerImpl* front_facing_child_of_back_facing_surface =
@@ skipping 89 matching lines @@
   EXPECT_TRUE(UpdateLayerListImplContains(
       front_facing_child_of_front_facing_surface->id()));
 }
 
 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {
   // Verify that layers are appropriately culled when their back face is showing
   // and they are not double sided, while animations are going on.
   //
   // Even layers that are animating get culled if their back face is showing and
   // they are not double sided.
-  const gfx::Transform identity_matrix;
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   LayerImpl* animating_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* child_of_animating_surface =
       AddChild<LayerImpl>(animating_surface);
   LayerImpl* animating_child = AddChildToRoot<LayerImpl>();
   LayerImpl* child2 = AddChildToRoot<LayerImpl>();
 
   // Nothing is double-sided
   child->test_properties()->double_sided = false;
@@ skipping 54 matching lines @@
   EXPECT_TRUE(animating_child->visible_layer_rect().IsEmpty());
 
   EXPECT_EQ(gfx::Rect(100, 100), child2->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
      BackFaceCullingWithPreserves3dForFlatteningSurface) {
   // Verify the behavior of back-face culling for a render surface that is
   // created when it flattens its subtree, and its parent has preserves-3d.
 
-  const gfx::Transform identity_matrix;
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* front_facing_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* back_facing_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* child1 = AddChild<LayerImpl>(front_facing_surface);
   LayerImpl* child2 = AddChild<LayerImpl>(back_facing_surface);
 
   // RenderSurfaces are not double-sided
   front_facing_surface->test_properties()->double_sided = false;
   back_facing_surface->test_properties()->double_sided = false;
 
@@ skipping 30 matching lines @@
   EXPECT_FALSE(child1->has_render_surface());
   EXPECT_FALSE(child2->has_render_surface());
 
   EXPECT_EQ(2u, update_layer_list_impl()->size());
   EXPECT_TRUE(UpdateLayerListImplContains(front_facing_surface->id()));
   EXPECT_TRUE(UpdateLayerListImplContains(child1->id()));
 }
 
 TEST_F(LayerTreeHostCommonScalingTest, LayerTransformsInHighDPI) {
   // Verify draw and screen space transforms of layers not in a surface.
-  gfx::Transform identity_matrix;
-
   LayerImpl* root = root_layer_for_testing();
   root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
 
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   child->SetPosition(gfx::PointF(2.f, 2.f));
   child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
 
   LayerImpl* child2 = AddChildToRoot<LayerImpl>();
@@ skipping 64 matching lines @@
                                       gfx::SizeF(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, child2_draw_rect);
   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child2_screen_space_rect);
 }
 
 TEST_F(LayerTreeHostCommonScalingTest, SurfaceLayerTransformsInHighDPI) {
   // Verify draw and screen space transforms of layers in a surface.
-  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);
 
   LayerImpl* root = root_layer_for_testing();
   root->SetBounds(gfx::Size(100, 100));
 
   LayerImpl* page_scale = AddChildToRoot<LayerImpl>();
@@ skipping 151 matching lines @@
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_IDEAL_SCALE_EQ(initial_parent_scale, parent);
   // Animating layers compute ideal scale in the same way as when
   // they are static.
   EXPECT_IDEAL_SCALE_EQ(initial_child_scale * initial_parent_scale,
                         child_scale);
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceTransformsInHighDPI) {
-  gfx::Transform identity_matrix;
-
   LayerImpl* parent = root_layer_for_testing();
   parent->SetBounds(gfx::Size(30, 30));
   parent->SetDrawsContent(true);
   parent->Set3dSortingContextId(1);
   parent->test_properties()->should_flatten_transform = false;
 
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   child->SetBounds(gfx::Size(10, 10));
   child->SetPosition(gfx::PointF(2.f, 2.f));
   child->SetDrawsContent(true);
@@ skipping 90 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_replica_screen_space_transform,
       child->render_surface()->replica_screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_replica_screen_space_transform,
       child->render_surface()->replica_screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest,
      RenderSurfaceTransformsInHighDPIAccurateScaleZeroPosition) {
-  gfx::Transform identity_matrix;
-
   LayerImpl* parent = root_layer_for_testing();
   parent->SetBounds(gfx::Size(33, 31));
   parent->SetDrawsContent(true);
 
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   child->SetBounds(gfx::Size(13, 11));
   child->SetDrawsContent(true);
   child->test_properties()->force_render_surface = true;
 
   gfx::Transform replica_transform;
   replica_transform.Scale(1.0, -1.0);
   std::unique_ptr<LayerImpl> replica =
       LayerImpl::Create(host_impl()->active_tree(), 7);
   replica->SetTransform(replica_transform);
   child->test_properties()->SetReplicaLayer(std::move(replica));
 
   float device_scale_factor = 1.7f;
   ExecuteCalculateDrawProperties(parent, device_scale_factor);
 
   // 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_impl()->size());
 
-  gfx::Transform identity_transform;
-  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_transform,
+  EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                   child->render_surface()->draw_transform());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_transform,
+  EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                   child->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_transform, child->render_surface()->screen_space_transform());
+      gfx::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(
       expected_replica_draw_transform,
       child->render_surface()->replica_draw_transform());
 
   gfx::Transform expected_replica_screen_space_transform;
   expected_replica_screen_space_transform.matrix().set(1, 1, -1.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
@@ skipping 189 matching lines @@
     host_impl_.active_tree()->SetElementIdsForTesting();
 
     root_->SetContentsOpaque(true);
     child_->SetContentsOpaque(true);
     grand_child_->SetContentsOpaque(true);
 
     root_->SetDrawsContent(true);
     child_->SetDrawsContent(true);
     grand_child_->SetDrawsContent(true);
 
-    gfx::Transform identity_matrix;
     root_->SetBounds(gfx::Size(1, 1));
     child_->SetBounds(gfx::Size(1, 1));
     grand_child_->SetBounds(gfx::Size(1, 1));
 
     child_->test_properties()->force_render_surface =
         std::tr1::get<2>(GetParam());
   }
 
   bool can_use_lcd_text_;
   bool layers_always_allowed_lcd_text_;
 
   FakeImplTaskRunnerProvider task_runner_provider_;
   TestSharedBitmapManager shared_bitmap_manager_;
   TestTaskGraphRunner task_graph_runner_;
   FakeLayerTreeHostImpl host_impl_;
   scoped_refptr<AnimationTimeline> timeline_;
 
   LayerImpl* root_;
   LayerImpl* child_;
   LayerImpl* grand_child_;
 };
 
 TEST_P(LCDTextTest, CanUseLCDText) {
   bool expect_lcd_text = can_use_lcd_text_ || layers_always_allowed_lcd_text_;
   bool expect_not_lcd_text = layers_always_allowed_lcd_text_;
 
   // Case 1: Identity transform.
-  gfx::Transform identity_matrix;
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL);
   EXPECT_EQ(expect_lcd_text, root_->CanUseLCDText());
   EXPECT_EQ(expect_lcd_text, child_->CanUseLCDText());
   EXPECT_EQ(expect_lcd_text, grand_child_->CanUseLCDText());
 
   // Case 2: Integral translation.
   gfx::Transform integral_translation;
   integral_translation.Translate(1.0, 2.0);
   child_->SetTransform(integral_translation);
   child_->layer_tree_impl()->property_trees()->needs_rebuild = true;
@@ skipping 36 matching lines @@
   gfx::Transform skew;
   skew.Skew(10.0, 0.0);
   child_->SetTransform(skew);
   child_->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL);
   EXPECT_EQ(expect_lcd_text, root_->CanUseLCDText());
   EXPECT_EQ(expect_not_lcd_text, child_->CanUseLCDText());
   EXPECT_EQ(expect_not_lcd_text, grand_child_->CanUseLCDText());
 
   // Case 7: Translucent.
-  child_->SetTransform(identity_matrix);
+  child_->SetTransform(gfx::Transform());
   child_->layer_tree_impl()->property_trees()->needs_rebuild = true;
   child_->test_properties()->opacity = 0.5f;
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL);
   EXPECT_EQ(expect_lcd_text, root_->CanUseLCDText());
   EXPECT_EQ(expect_not_lcd_text, child_->CanUseLCDText());
   EXPECT_EQ(expect_not_lcd_text, grand_child_->CanUseLCDText());
 
   // Case 8: Sanity check: restore transform and opacity.
-  child_->SetTransform(identity_matrix);
+  child_->SetTransform(gfx::Transform());
   child_->layer_tree_impl()->property_trees()->needs_rebuild = true;
   child_->test_properties()->opacity = 1.f;
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL);
   EXPECT_EQ(expect_lcd_text, root_->CanUseLCDText());
   EXPECT_EQ(expect_lcd_text, child_->CanUseLCDText());
   EXPECT_EQ(expect_lcd_text, grand_child_->CanUseLCDText());
 
   // Case 9: Non-opaque content.
   child_->SetContentsOpaque(false);
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL);
@@ skipping 62 matching lines @@
                                          testing::Bool(),
                                          testing::Bool()));
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayerImpl) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
   host_impl.CreatePendingTree();
-  const gfx::Transform identity_matrix;
 
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.pending_tree(), 1);
   root->SetBounds(gfx::Size(50, 50));
   root->SetDrawsContent(true);
   LayerImpl* root_layer = root.get();
 
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl.pending_tree(), 2);
   child->SetBounds(gfx::Size(40, 40));
@@ skipping 24 matching lines @@
   EXPECT_EQ(2, root_layer->render_surface()->layer_list().at(1)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayersImpl) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
   host_impl.CreatePendingTree();
-  const gfx::Transform identity_matrix;
 
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.pending_tree(), 1);
   root->SetBounds(gfx::Size(50, 50));
   root->SetDrawsContent(true);
   LayerImpl* root_layer = root.get();
 
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl.pending_tree(), 2);
   child->SetBounds(gfx::Size(40, 40));
@@ skipping 24 matching lines @@
 
 void EmptyCopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {}
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
   host_impl.CreatePendingTree();
-  const gfx::Transform identity_matrix;
 
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.pending_tree(), 1);
   root->SetBounds(gfx::Size(50, 50));
   root->SetDrawsContent(true);
   LayerImpl* root_layer = root.get();
 
   std::unique_ptr<LayerImpl> copy_grand_parent =
       LayerImpl::Create(host_impl.pending_tree(), 2);
   copy_grand_parent->SetBounds(gfx::Size(40, 40));
@@ skipping 126 matching lines @@
   EXPECT_FALSE(copy_layer->render_surface()->contributes_to_drawn_surface());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClippedOutCopyRequest) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
   host_impl.CreatePendingTree();
-  const gfx::Transform identity_matrix;
 
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.pending_tree(), 1);
   root->SetBounds(gfx::Size(50, 50));
   root->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> copy_parent =
       LayerImpl::Create(host_impl.pending_tree(), 2);
   copy_parent->SetDrawsContent(true);
   copy_parent->SetMasksToBounds(true);
@@ skipping 29 matching lines @@
   EXPECT_EQ(root_layer->id(), render_surface_layer_list.at(0)->id());
 
   // The root render surface should only have 2 contributing layer, since the
   // other layers are empty/clipped away.
   ASSERT_EQ(2u, root_layer->render_surface()->layer_list().size());
   EXPECT_EQ(root_layer->id(),
             root_layer->render_surface()->layer_list().at(0)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleRectInNonRootCopyRequest) {
-  const gfx::Transform identity_matrix;
-
   LayerImpl* root = root_layer_for_testing();
   root->SetBounds(gfx::Size(50, 50));
   root->SetDrawsContent(true);
   root->SetMasksToBounds(true);
 
   LayerImpl* copy_layer = AddChild<LayerImpl>(root);
   copy_layer->SetBounds(gfx::Size(100, 100));
   copy_layer->SetDrawsContent(true);
   copy_layer->test_properties()->force_render_surface = true;
 
@@ skipping 102 matching lines @@
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
   clip_parent->test_properties()->clip_children.reset(clip_children.release());
 
   intervening->SetMasksToBounds(true);
   clip_parent->SetMasksToBounds(true);
 
   gfx::Transform scale_transform;
   scale_transform.Scale(2, 2);
 
-  gfx::Transform identity_transform;
-
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(render_surface, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
-                               true, false, true);
-  SetLayerPropertiesForTesting(clip_parent, scale_transform, gfx::Point3F(),
-                               gfx::PointF(1.f, 1.f), gfx::Size(10, 10), true,
-                               false, false);
-  SetLayerPropertiesForTesting(intervening, identity_transform, gfx::Point3F(),
-                               gfx::PointF(1.f, 1.f), gfx::Size(5, 5), true,
-                               false, false);
-  SetLayerPropertiesForTesting(clip_child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(1.f, 1.f), gfx::Size(10, 10), true,
-                               false, false);
-
+  root->SetBounds(gfx::Size(50, 50));
+  render_surface->SetBounds(gfx::Size(10, 10));
+  render_surface->test_properties()->force_render_surface = true;
+  clip_parent->SetTransform(scale_transform);
+  clip_parent->SetPosition(gfx::PointF(1.f, 1.f));
+  clip_parent->SetBounds(gfx::Size(10, 10));
+  intervening->SetPosition(gfx::PointF(1.f, 1.f));
+  intervening->SetBounds(gfx::Size(5, 5));
+  clip_child->SetPosition(gfx::PointF(1.f, 1.f));
+  clip_child->SetBounds(gfx::Size(10, 10));
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(root->render_surface());
   ASSERT_TRUE(render_surface->render_surface());
 
   // Ensure that we've inherited our clip parent's clip and weren't affected
   // by the intervening clip layer.
   ASSERT_EQ(gfx::Rect(1, 1, 20, 20), clip_parent->clip_rect());
   ASSERT_EQ(clip_parent->clip_rect(), clip_child->clip_rect());
   ASSERT_EQ(gfx::Rect(3, 3, 10, 10), intervening->clip_rect());
@@ skipping 34 matching lines @@
   clip_child->SetDrawsContent(true);
 
   clip_child->test_properties()->clip_parent = clip_parent;
 
   intervening->SetMasksToBounds(true);
   clip_parent->SetMasksToBounds(true);
 
   gfx::Transform translation_transform;
   translation_transform.Translate(2, 2);
 
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_parent, translation_transform,
-                               gfx::Point3F(), gfx::PointF(1.f, 1.f),
-                               gfx::Size(40, 40), true, false, false);
-  SetLayerPropertiesForTesting(render_surface1, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
-                               true, false, true);
-  SetLayerPropertiesForTesting(intervening, identity_transform, gfx::Point3F(),
-                               gfx::PointF(1.f, 1.f), gfx::Size(5, 5), true,
-                               false, false);
-  SetLayerPropertiesForTesting(render_surface2, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
-                               true, false, true);
-  SetLayerPropertiesForTesting(clip_child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(-10.f, -10.f), gfx::Size(60, 60),
-                               true, false, false);
-
+  root->SetBounds(gfx::Size(50, 50));
+  clip_parent->SetPosition(gfx::PointF(1.f, 1.f));
+  clip_parent->SetBounds(gfx::Size(40, 40));
+  render_surface1->SetBounds(gfx::Size(10, 10));
+  render_surface1->test_properties()->force_render_surface = true;
+  intervening->SetPosition(gfx::PointF(1.f, 1.f));
+  intervening->SetBounds(gfx::Size(5, 5));
+  render_surface2->SetBounds(gfx::Size(10, 10));
+  render_surface2->test_properties()->force_render_surface = true;
+  clip_child->SetPosition(gfx::PointF(-10.f, -10.f));
+  clip_child->SetBounds(gfx::Size(60, 60));
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->render_surface());
   EXPECT_TRUE(render_surface1->render_surface());
   EXPECT_TRUE(render_surface2->render_surface());
 
   // Since the render surfaces could have expanded, they should not clip (their
   // bounds would no longer be reliable). We should resort to layer clipping
   // in this case.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0),
@@ skipping 51 matching lines @@
   clip_child->test_properties()->clip_parent = clip_parent;
 
   intervening->SetMasksToBounds(true);
   clip_parent->SetMasksToBounds(true);
   intervening->SetScrollClipLayer(clip_parent->id());
   intervening->SetCurrentScrollOffset(gfx::ScrollOffset(3, 3));
 
   gfx::Transform translation_transform;
   translation_transform.Translate(2, 2);
 
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_parent, translation_transform,
-                               gfx::Point3F(), gfx::PointF(1.f, 1.f),
-                               gfx::Size(40, 40), true, false, false);
-  SetLayerPropertiesForTesting(render_surface1, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
-                               true, false, true);
-  SetLayerPropertiesForTesting(intervening, identity_transform, gfx::Point3F(),
-                               gfx::PointF(1.f, 1.f), gfx::Size(5, 5), true,
-                               false, false);
-  SetLayerPropertiesForTesting(render_surface2, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
-                               true, false, true);
-  SetLayerPropertiesForTesting(clip_child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(-10.f, -10.f), gfx::Size(60, 60),
-                               true, false, false);
-
+  root->SetBounds(gfx::Size(50, 50));
+  clip_parent->SetTransform(translation_transform);
+  clip_parent->SetPosition(gfx::PointF(1.f, 1.f));
+  clip_parent->SetBounds(gfx::Size(40, 40));
+  render_surface1->SetBounds(gfx::Size(10, 10));
+  render_surface1->test_properties()->force_render_surface = true;
+  intervening->SetPosition(gfx::PointF(1.f, 1.f));
+  intervening->SetBounds(gfx::Size(5, 5));
+  render_surface2->SetBounds(gfx::Size(10, 10));
+  render_surface2->test_properties()->force_render_surface = true;
+  clip_child->SetPosition(gfx::PointF(-10.f, -10.f));
+  clip_child->SetBounds(gfx::Size(60, 60));
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->render_surface());
   EXPECT_TRUE(render_surface1->render_surface());
   EXPECT_TRUE(render_surface2->render_surface());
 
   // Since the render surfaces could have expanded, they should not clip (their
   // bounds would no longer be reliable). We should resort to layer clipping
   // in this case.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0),
@@ skipping 37 matching lines @@
   //
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChild<LayerImpl>(root);
   LayerImpl* intervening = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(intervening);
   LayerImpl* child = AddChild<LayerImpl>(clip_child);
   clip_child->SetDrawsContent(true);
   child->SetDrawsContent(true);
 
   clip_child->test_properties()->clip_parent = clip_parent;
-  std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
-  clip_children->insert(clip_child);
-  clip_parent->test_properties()->clip_children.reset(clip_children.release());
+  clip_parent->test_properties()->clip_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  clip_parent->test_properties()->clip_children->insert(clip_child);
 
+  root->SetBounds(gfx::Size(50, 50));
+  clip_parent->SetBounds(gfx::Size(40, 40));
+  clip_parent->SetMasksToBounds(true);
+  intervening->SetBounds(gfx::Size(5, 5));
   intervening->SetMasksToBounds(true);
-  clip_parent->SetMasksToBounds(true);
-
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_parent, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(40, 40), true, false,
-                               false);
-  SetLayerPropertiesForTesting(intervening, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(5, 5), true, false,
-                               false);
-  SetLayerPropertiesForTesting(clip_child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(60, 60), true, false,
-                               false);
-  SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(60, 60), true, false,
-                               false);
+  clip_child->SetBounds(gfx::Size(60, 60));
+  child->SetBounds(gfx::Size(60, 60));
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->render_surface());
 
   // Neither the clip child nor its descendant should have inherited the clip
   // from |intervening|.
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), clip_child->clip_rect());
   EXPECT_TRUE(clip_child->is_clipped());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40), child->visible_layer_rect());
   EXPECT_TRUE(child->is_clipped());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        SurfacesShouldBeUnaffectedByNonDescendantClipChildren) {
   // Ensures that non-descendant clip children in the tree do not affect
   // render surfaces.
   //
   //   root (a render surface)
   //    + clip_parent (masks to bounds)
   //      + render_surface1
   //        + clip_child
   //      + render_surface2
   //        + non_clip_child
   //
   // In this example render_surface2 should be unaffected by clip_child.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_parent);
-  render_surface1->SetDrawsContent(true);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface1);
-  clip_child->SetDrawsContent(true);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(clip_parent);
-  render_surface2->SetDrawsContent(true);
   LayerImpl* non_clip_child = AddChild<LayerImpl>(render_surface2);
-  non_clip_child->SetDrawsContent(true);
 
   clip_child->test_properties()->clip_parent = clip_parent;
-  std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
-  clip_children->insert(clip_child);
-  clip_parent->test_properties()->clip_children.reset(clip_children.release());
+  clip_parent->test_properties()->clip_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  clip_parent->test_properties()->clip_children->insert(clip_child);
 
   clip_parent->SetMasksToBounds(true);
   render_surface1->SetMasksToBounds(true);
 
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(15, 15), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_parent, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-  SetLayerPropertiesForTesting(render_surface1, identity_transform,
-                               gfx::Point3F(), gfx::PointF(5, 5),
-                               gfx::Size(5, 5), true, false, true);
-  SetLayerPropertiesForTesting(render_surface2, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(5, 5),
-                               true, false, true);
-  SetLayerPropertiesForTesting(clip_child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(-1, 1), gfx::Size(10, 10), true,
-                               false, false);
-  SetLayerPropertiesForTesting(non_clip_child, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(5, 5),
-                               true, false, false);
+  render_surface1->SetDrawsContent(true);
+  clip_child->SetDrawsContent(true);
+  render_surface2->SetDrawsContent(true);
+  non_clip_child->SetDrawsContent(true);
+
+  root->SetBounds(gfx::Size(15, 15));
+  clip_parent->SetBounds(gfx::Size(10, 10));
+  render_surface1->SetPosition(gfx::PointF(5, 5));
+  render_surface1->SetBounds(gfx::Size(5, 5));
+  render_surface1->test_properties()->force_render_surface = true;
+  render_surface2->SetBounds(gfx::Size(5, 5));
+  render_surface2->test_properties()->force_render_surface = true;
+  clip_child->SetPosition(gfx::PointF(-1, 1));
+  clip_child->SetBounds(gfx::Size(10, 10));
+  non_clip_child->SetBounds(gfx::Size(5, 5));
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->render_surface());
   EXPECT_TRUE(render_surface1->render_surface());
   EXPECT_TRUE(render_surface2->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 5, 5), render_surface1->clip_rect());
   EXPECT_TRUE(render_surface1->is_clipped());
 
@@ skipping 26 matching lines @@
 TEST_F(LayerTreeHostCommonTest,
        CreateRenderSurfaceWhenFlattenInsideRenderingContext) {
   // Verifies that Render Surfaces are created at the edge of rendering context.
 
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child1 = AddChildToRoot<LayerImpl>();
   LayerImpl* child2 = AddChild<LayerImpl>(child1);
   LayerImpl* child3 = AddChild<LayerImpl>(child2);
   root->SetDrawsContent(true);
 
-  const gfx::Transform identity_matrix;
-  gfx::Point3F transform_origin;
-  gfx::PointF position;
   gfx::Size bounds(100, 100);
 
-  SetLayerPropertiesForTesting(root, identity_matrix, transform_origin,
-                               position, bounds, true, false);
-  SetLayerPropertiesForTesting(child1, identity_matrix, transform_origin,
-                               position, bounds, false, true);
+  root->SetBounds(bounds);
+  child1->SetBounds(bounds);
   child1->SetDrawsContent(true);
-  SetLayerPropertiesForTesting(child2, identity_matrix, transform_origin,
-                               position, bounds, true, false);
+  child1->Set3dSortingContextId(1);
+  child1->test_properties()->should_flatten_transform = false;
+  child2->SetBounds(bounds);
   child2->SetDrawsContent(true);
-  SetLayerPropertiesForTesting(child3, identity_matrix, transform_origin,
-                               position, bounds, true, false);
+  child2->Set3dSortingContextId(1);
+  child3->SetBounds(bounds);
   child3->SetDrawsContent(true);
-
-  child2->Set3dSortingContextId(1);
   child3->Set3dSortingContextId(1);
-
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
 
   // Verify which render surfaces were created.
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_FALSE(child1->has_render_surface());
   EXPECT_TRUE(child2->has_render_surface());
   EXPECT_FALSE(child3->has_render_surface());
 }
 
 TEST_F(LayerTreeHostCommonTest, CanRenderToSeparateSurface) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
 
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
   std::unique_ptr<LayerImpl> child1 =
       LayerImpl::Create(host_impl.active_tree(), 123456);
   std::unique_ptr<LayerImpl> child2 =
       LayerImpl::Create(host_impl.active_tree(), 1234567);
   std::unique_ptr<LayerImpl> child3 =
       LayerImpl::Create(host_impl.active_tree(), 12345678);
 
-  gfx::Transform identity_matrix;
-  gfx::Point3F transform_origin;
-  gfx::PointF position;
   gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(root.get(), identity_matrix, transform_origin,
-                               position, bounds, true, false, true);
+
+  root->SetBounds(bounds);
   root->SetDrawsContent(true);
 
   // This layer structure normally forces render surface due to preserves3d
   // behavior.
-  SetLayerPropertiesForTesting(child1.get(), identity_matrix, transform_origin,
-                               position, bounds, false, true, false);
+  child1->SetBounds(bounds);
   child1->SetDrawsContent(true);
-  SetLayerPropertiesForTesting(child2.get(), identity_matrix, transform_origin,
-                               position, bounds, true, false, true);
+  child1->Set3dSortingContextId(1);
+  child1->test_properties()->should_flatten_transform = false;
+  child2->SetBounds(bounds);
   child2->SetDrawsContent(true);
-  SetLayerPropertiesForTesting(child3.get(), identity_matrix, transform_origin,
-                               position, bounds, true, false, false);
+  child2->Set3dSortingContextId(1);
+  child3->SetBounds(bounds);
   child3->SetDrawsContent(true);
-
-  child2->Set3dSortingContextId(1);
   child3->Set3dSortingContextId(1);
 
   child2->test_properties()->AddChild(std::move(child3));
   child1->test_properties()->AddChild(std::move(child2));
   root->test_properties()->AddChild(std::move(child1));
   LayerImpl* root_layer = root.get();
   root_layer->layer_tree_impl()->SetRootLayerForTesting(std::move(root));
 
   {
     LayerImplList render_surface_layer_list;
@@ skipping 59 matching lines @@
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleSurfaces) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* back_facing = AddChild<LayerImpl>(root);
   LayerImpl* render_surface1 = AddChild<LayerImpl>(back_facing);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(back_facing);
   LayerImpl* child1 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* child2 = AddChild<LayerImpl>(render_surface2);
+
   child1->SetDrawsContent(true);
   child2->SetDrawsContent(true);
 
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(back_facing, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
-  SetLayerPropertiesForTesting(render_surface1, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               false, true, true);
-  SetLayerPropertiesForTesting(render_surface2, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               false, true, true);
-  SetLayerPropertiesForTesting(child1, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false,
-                               false);
-  SetLayerPropertiesForTesting(child2, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false,
-                               false);
-
+  root->SetBounds(gfx::Size(50, 50));
+  root->Set3dSortingContextId(1);
   root->test_properties()->should_flatten_transform = false;
-  root->Set3dSortingContextId(1);
+  back_facing->SetBounds(gfx::Size(50, 50));
   back_facing->Set3dSortingContextId(1);
   back_facing->test_properties()->should_flatten_transform = false;
+  render_surface1->SetBounds(gfx::Size(30, 30));
+  render_surface1->Set3dSortingContextId(1);
+  render_surface1->test_properties()->should_flatten_transform = false;
+  render_surface1->test_properties()->force_render_surface = true;
   render_surface1->test_properties()->double_sided = false;
+  render_surface2->SetBounds(gfx::Size(30, 30));
+  // Different context from the rest.
   render_surface2->Set3dSortingContextId(2);
+  render_surface2->test_properties()->should_flatten_transform = false;
+  render_surface2->test_properties()->force_render_surface = true;
   render_surface2->test_properties()->double_sided = false;
+  child1->SetBounds(gfx::Size(20, 20));
+  child2->SetBounds(gfx::Size(20, 20));
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(render_surface1->sorting_context_id(), root->sorting_context_id());
   EXPECT_NE(render_surface2->sorting_context_id(), root->sorting_context_id());
   EXPECT_EQ(3u, render_surface_layer_list_impl()->size());
   EXPECT_EQ(2u, render_surface_layer_list_impl()
                     ->at(0)
                     ->render_surface()
                     ->layer_list()
                     .size());
   EXPECT_EQ(1u, render_surface_layer_list_impl()
                     ->at(1)
                     ->render_surface()
                     ->layer_list()
                     .size());
 
-  gfx::Transform rotation_transform = identity_transform;
+  gfx::Transform rotation_transform;
   rotation_transform.RotateAboutXAxis(180.0);
 
   back_facing->SetTransform(rotation_transform);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
 
   // render_surface1 is in the same 3d rendering context as back_facing and is
   // not double sided, so it should not be in RSLL. render_surface2 is also not
   // double-sided, but will still be in RSLL as it's in a different 3d rendering
   // context.
   EXPECT_EQ(2u, render_surface_layer_list_impl()->size());
   EXPECT_EQ(1u, render_surface_layer_list_impl()
                     ->at(0)
                     ->render_surface()
                     ->layer_list()
                     .size());
 }
 
 TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleLayers) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
+
+  root->SetBounds(gfx::Size(50, 50));
+  root->test_properties()->should_flatten_transform = false;
+  child->SetBounds(gfx::Size(30, 30));
+  child->test_properties()->double_sided = false;
+  child->test_properties()->should_flatten_transform = false;
+  grand_child->SetBounds(gfx::Size(20, 20));
   grand_child->SetDrawsContent(true);
-
-  child->test_properties()->double_sided = false;
   grand_child->SetUseParentBackfaceVisibility(true);
-
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), false, false,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), false, false,
-                               false);
-  SetLayerPropertiesForTesting(grand_child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), false, false,
-                               false);
-
+  grand_child->test_properties()->should_flatten_transform = false;
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(1u, render_surface_layer_list_impl()->size());
   EXPECT_EQ(grand_child, render_surface_layer_list_impl()
                              ->at(0)
                              ->render_surface()
                              ->layer_list()[0]);
 
   // As all layers have identity transform, we shouldn't check for backface
   // visibility.
   EXPECT_FALSE(root->should_check_backface_visibility());
   EXPECT_FALSE(child->should_check_backface_visibility());
   EXPECT_FALSE(grand_child->should_check_backface_visibility());
   // As there are no 3d rendering contexts, all layers should use their local
   // transform for backface visibility.
   EXPECT_TRUE(root->use_local_transform_for_backface_visibility());
   EXPECT_TRUE(child->use_local_transform_for_backface_visibility());
   EXPECT_TRUE(grand_child->use_local_transform_for_backface_visibility());
 
-  gfx::Transform rotation_transform = identity_transform;
+  gfx::Transform rotation_transform;
   rotation_transform.RotateAboutXAxis(180.0);
 
   child->SetTransform(rotation_transform);
   child->Set3dSortingContextId(1);
   grand_child->Set3dSortingContextId(1);
   child->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(1u, render_surface_layer_list_impl()->size());
   EXPECT_EQ(0u, render_surface_layer_list_impl()
@@ skipping 40 matching lines @@
   EXPECT_TRUE(child->use_local_transform_for_backface_visibility());
   EXPECT_FALSE(grand_child->use_local_transform_for_backface_visibility());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformAnimationUpdatesBackfaceVisibility) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* back_facing = AddChild<LayerImpl>(root);
   LayerImpl* render_surface1 = AddChild<LayerImpl>(back_facing);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(back_facing);
 
-  gfx::Transform identity_transform;
   gfx::Transform rotate_about_y;
   rotate_about_y.RotateAboutYAxis(180.0);
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), false, true,
-                               true);
-  SetLayerPropertiesForTesting(back_facing, rotate_about_y, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), false, true,
-                               false);
-  SetLayerPropertiesForTesting(render_surface1, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               false, true, true);
-  SetLayerPropertiesForTesting(render_surface2, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               false, true, true);
 
+  root->SetBounds(gfx::Size(50, 50));
+  root->Set3dSortingContextId(1);
+  root->test_properties()->should_flatten_transform = false;
+  back_facing->SetTransform(rotate_about_y);
+  back_facing->SetBounds(gfx::Size(50, 50));
+  back_facing->Set3dSortingContextId(1);
+  back_facing->test_properties()->should_flatten_transform = false;
+  render_surface1->SetBounds(gfx::Size(30, 30));
+  render_surface1->Set3dSortingContextId(1);
+  render_surface1->test_properties()->should_flatten_transform = false;
   render_surface1->test_properties()->double_sided = false;
+  render_surface1->test_properties()->force_render_surface = true;
+  render_surface2->SetBounds(gfx::Size(30, 30));
+  render_surface2->Set3dSortingContextId(1);
+  render_surface2->test_properties()->should_flatten_transform = false;
   render_surface2->test_properties()->double_sided = false;
-
+  render_surface2->test_properties()->force_render_surface = true;
   ExecuteCalculateDrawProperties(root);
 
   const EffectTree& tree =
       root->layer_tree_impl()->property_trees()->effect_tree;
   EXPECT_TRUE(tree.Node(render_surface1->effect_tree_index())
                   ->hidden_by_backface_visibility);
   EXPECT_TRUE(tree.Node(render_surface2->effect_tree_index())
                   ->hidden_by_backface_visibility);
 
-  back_facing->OnTransformAnimated(identity_transform);
+  back_facing->OnTransformAnimated(gfx::Transform());
   render_surface2->OnTransformAnimated(rotate_about_y);
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(tree.Node(render_surface1->effect_tree_index())
                    ->hidden_by_backface_visibility);
   EXPECT_TRUE(tree.Node(render_surface2->effect_tree_index())
                   ->hidden_by_backface_visibility);
 
   render_surface1->OnTransformAnimated(rotate_about_y);
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRUE(tree.Node(render_surface1->effect_tree_index())
@@ skipping 16 matching lines @@
   LayerImpl* scroll_parent_border = AddChildToRoot<LayerImpl>();
   LayerImpl* scroll_parent_clip = AddChild<LayerImpl>(scroll_parent_border);
   LayerImpl* scroll_parent = AddChild<LayerImpl>(scroll_parent_clip);
   LayerImpl* scroll_child = AddChild<LayerImpl>(root);
 
   scroll_parent->SetDrawsContent(true);
   scroll_child->SetDrawsContent(true);
   scroll_parent_clip->SetMasksToBounds(true);
 
   scroll_child->test_properties()->scroll_parent = scroll_parent;
-  std::unique_ptr<std::set<LayerImpl*>> scroll_children(
-      new std::set<LayerImpl*>);
-  scroll_children->insert(scroll_child);
-  scroll_parent->test_properties()->scroll_children.reset(
-      scroll_children.release());
+  scroll_parent->test_properties()->scroll_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  scroll_parent->test_properties()->scroll_children->insert(scroll_child);
 
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(scroll_parent_border, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_parent_clip, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_parent, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
-
+  root->SetBounds(gfx::Size(50, 50));
+  scroll_parent_border->SetBounds(gfx::Size(40, 40));
+  scroll_parent_clip->SetBounds(gfx::Size(30, 30));
+  scroll_parent->SetBounds(gfx::Size(50, 50));
+  scroll_child->SetBounds(gfx::Size(50, 50));
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30), scroll_child->clip_rect());
   EXPECT_TRUE(scroll_child->is_clipped());
 }
 
 TEST_F(LayerTreeHostCommonTest, ScrollChildAndScrollParentDifferentTargets) {
   // Tests the computation of draw transform for the scroll child when its
   // target is different from its scroll parent's target.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* scroll_child_target = AddChildToRoot<LayerImpl>();
   LayerImpl* scroll_child = AddChild<LayerImpl>(scroll_child_target);
   LayerImpl* scroll_parent_target = AddChild<LayerImpl>(scroll_child_target);
   LayerImpl* scroll_parent = AddChild<LayerImpl>(scroll_parent_target);
 
   scroll_parent->SetDrawsContent(true);
   scroll_child->SetDrawsContent(true);
 
   scroll_child->test_properties()->scroll_parent = scroll_parent;
-  std::unique_ptr<std::set<LayerImpl*>> scroll_children(
-      new std::set<LayerImpl*>);
-  scroll_children->insert(scroll_child);
-  scroll_parent->test_properties()->scroll_children.reset(
-      scroll_children.release());
+  scroll_parent->test_properties()->scroll_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  scroll_parent->test_properties()->scroll_children->insert(scroll_child);
 
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(scroll_child_target, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
-                               true, false, true);
-  SetLayerPropertiesForTesting(scroll_child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
-  SetLayerPropertiesForTesting(scroll_parent_target, identity_transform,
-                               gfx::Point3F(), gfx::PointF(10, 10),
-                               gfx::Size(50, 50), true, false, true);
-  SetLayerPropertiesForTesting(scroll_parent, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
-                               true, false, false);
+  root->SetBounds(gfx::Size(50, 50));
+  scroll_child_target->SetBounds(gfx::Size(50, 50));
+  scroll_child_target->test_properties()->force_render_surface = true;
+  scroll_child->SetBounds(gfx::Size(50, 50));
+  scroll_parent_target->SetPosition(gfx::PointF(10, 10));
+  scroll_parent_target->SetBounds(gfx::Size(50, 50));
   scroll_parent_target->SetMasksToBounds(true);
+  scroll_parent_target->test_properties()->force_render_surface = true;
+  scroll_parent->SetBounds(gfx::Size(50, 50));
 
   float device_scale_factor = 1.5f;
   LayerImplList render_surface_layer_list_impl;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root, root->bounds(), identity_transform,
-      &render_surface_layer_list_impl);
+      root, root->bounds(), gfx::Transform(), &render_surface_layer_list_impl);
   inputs.device_scale_factor = device_scale_factor;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   EXPECT_EQ(scroll_child->effect_tree_index(),
             scroll_child_target->effect_tree_index());
   EXPECT_EQ(scroll_child->visible_layer_rect(), gfx::Rect(10, 10, 40, 40));
   EXPECT_EQ(scroll_child->clip_rect(), gfx::Rect(15, 15, 75, 75));
   gfx::Transform scale;
   scale.Scale(1.5f, 1.5f);
   EXPECT_TRANSFORMATION_MATRIX_EQ(scroll_child->DrawTransform(), scale);
 }
 
 TEST_F(LayerTreeHostCommonTest, SingularTransformSubtreesDoNotDraw) {
   LayerImpl* root = root_layer_for_testing();
+  LayerImpl* parent = AddChildToRoot<LayerImpl>();
+  LayerImpl* child = AddChild<LayerImpl>(parent);
+
+  root->SetBounds(gfx::Size(50, 50));
   root->SetDrawsContent(true);
-  LayerImpl* parent = AddChildToRoot<LayerImpl>();
+  root->Set3dSortingContextId(1);
+  parent->SetBounds(gfx::Size(30, 30));
   parent->SetDrawsContent(true);
-  LayerImpl* child = AddChild<LayerImpl>(parent);
+  parent->Set3dSortingContextId(1);
+  parent->test_properties()->force_render_surface = true;
+  child->SetBounds(gfx::Size(20, 20));
   child->SetDrawsContent(true);
-
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, true,
-                               true);
-  SetLayerPropertiesForTesting(parent, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, true,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, true,
-                               true);
-
+  child->Set3dSortingContextId(1);
+  child->test_properties()->force_render_surface = true;
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(3u, render_surface_layer_list_impl()->size());
 
   gfx::Transform singular_transform;
   singular_transform.Scale3d(
       SkDoubleToMScalar(1.0), SkDoubleToMScalar(1.0), SkDoubleToMScalar(0.0));
 
   child->SetTransform(singular_transform);
 
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(2u, render_surface_layer_list_impl()->size());
 
   // Ensure that the entire subtree under a layer with singular transform does
   // not get rendered.
   parent->SetTransform(singular_transform);
-  child->SetTransform(identity_transform);
+  child->SetTransform(gfx::Transform());
 
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(1u, render_surface_layer_list_impl()->size());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClippedByOutOfOrderScrollParent) {
   // Checks that clipping by a scroll parent that follows you in paint order
   // still results in correct clipping.
   //
   // + root
   //   + scroll_parent_border
   //     + scroll_parent_clip
   //       + scroll_parent
   //   + scroll_child
   //
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* scroll_parent_border = AddChild<LayerImpl>(root);
   LayerImpl* scroll_parent_clip = AddChild<LayerImpl>(scroll_parent_border);
   LayerImpl* scroll_parent = AddChild<LayerImpl>(scroll_parent_clip);
   LayerImpl* scroll_child = AddChild<LayerImpl>(root);
 
   scroll_parent->SetDrawsContent(true);
   scroll_child->SetDrawsContent(true);
 
+  root->SetBounds(gfx::Size(50, 50));
+  scroll_parent_border->SetBounds(gfx::Size(40, 40));
+  scroll_parent_clip->SetBounds(gfx::Size(30, 30));
   scroll_parent_clip->SetMasksToBounds(true);
+  scroll_parent->SetBounds(gfx::Size(50, 50));
+  scroll_child->SetBounds(gfx::Size(50, 50));
 
   scroll_child->test_properties()->scroll_parent = scroll_parent;
-  std::unique_ptr<std::set<LayerImpl*>> scroll_children(
-      new std::set<LayerImpl*>);
-  scroll_children->insert(scroll_child);
-  scroll_parent->test_properties()->scroll_children.reset(
-      scroll_children.release());
-
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(scroll_parent_border, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_parent_clip, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_parent, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
+  scroll_parent->test_properties()->scroll_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  scroll_parent->test_properties()->scroll_children->insert(scroll_child);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30), scroll_child->clip_rect());
   EXPECT_TRUE(scroll_child->is_clipped());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClippedByOutOfOrderScrollGrandparent) {
@@ skipping 20 matching lines @@
   LayerImpl* scroll_grandparent = AddChild<LayerImpl>(scroll_grandparent_clip);
 
   scroll_parent->SetDrawsContent(true);
   scroll_grandparent->SetDrawsContent(true);
   scroll_child->SetDrawsContent(true);
 
   scroll_parent_clip->SetMasksToBounds(true);
   scroll_grandparent_clip->SetMasksToBounds(true);
 
   scroll_child->test_properties()->scroll_parent = scroll_parent;
-  std::unique_ptr<std::set<LayerImpl*>> scroll_children(
-      new std::set<LayerImpl*>);
-  scroll_children->insert(scroll_child);
-  scroll_parent->test_properties()->scroll_children.reset(
-      scroll_children.release());
+  scroll_parent->test_properties()->scroll_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  scroll_parent->test_properties()->scroll_children->insert(scroll_child);
 
   scroll_parent_border->test_properties()->scroll_parent = scroll_grandparent;
-  scroll_children.reset(new std::set<LayerImpl*>);
-  scroll_children->insert(scroll_parent_border);
-  scroll_grandparent->test_properties()->scroll_children.reset(
-      scroll_children.release());
+  scroll_grandparent->test_properties()->scroll_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  scroll_grandparent->test_properties()->scroll_children->insert(
+      scroll_parent_border);
 
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(scroll_grandparent_border, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_grandparent_clip, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(20, 20),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_grandparent, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_parent_border, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_parent_clip, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_parent, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
+  root->SetBounds(gfx::Size(50, 50));
+  scroll_grandparent_border->SetBounds(gfx::Size(40, 40));
+  scroll_grandparent_clip->SetBounds(gfx::Size(20, 20));
+  scroll_grandparent->SetBounds(gfx::Size(50, 50));
+  scroll_parent_border->SetBounds(gfx::Size(40, 40));
+  scroll_parent_clip->SetBounds(gfx::Size(30, 30));
+  scroll_parent->SetBounds(gfx::Size(50, 50));
+  scroll_child->SetBounds(gfx::Size(50, 50));
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20), scroll_child->clip_rect());
   EXPECT_TRUE(scroll_child->is_clipped());
 
   // Despite the fact that we visited the above layers out of order to get the
   // correct clip, the layer lists should be unaffected.
@@ skipping 35 matching lines @@
 
   scroll_parent->SetDrawsContent(true);
   render_surface1->SetDrawsContent(true);
   scroll_grandparent->SetDrawsContent(true);
   render_surface2->SetDrawsContent(true);
 
   scroll_parent_clip->SetMasksToBounds(true);
   scroll_grandparent_clip->SetMasksToBounds(true);
 
   scroll_child->test_properties()->scroll_parent = scroll_parent;
-  std::unique_ptr<std::set<LayerImpl*>> scroll_children(
-      new std::set<LayerImpl*>);
-  scroll_children->insert(scroll_child);
-  scroll_parent->test_properties()->scroll_children.reset(
-      scroll_children.release());
+  scroll_parent->test_properties()->scroll_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  scroll_parent->test_properties()->scroll_children->insert(scroll_child);
 
   scroll_parent_border->test_properties()->scroll_parent = scroll_grandparent;
-  scroll_children.reset(new std::set<LayerImpl*>);
-  scroll_children->insert(scroll_parent_border);
-  scroll_grandparent->test_properties()->scroll_children.reset(
-      scroll_children.release());
+  scroll_grandparent->test_properties()->scroll_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  scroll_grandparent->test_properties()->scroll_children->insert(
+      scroll_parent_border);
 
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(scroll_grandparent_border, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_grandparent_clip, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(20, 20),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_grandparent, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
-                               true, false, false);
-  SetLayerPropertiesForTesting(render_surface1, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
-                               true, false, true);
-  SetLayerPropertiesForTesting(scroll_parent_border, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_parent_clip, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroll_parent, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
-                               true, false, false);
-  SetLayerPropertiesForTesting(render_surface2, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
-                               true, false, true);
-  SetLayerPropertiesForTesting(scroll_child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
+  root->SetBounds(gfx::Size(50, 50));
+  scroll_grandparent_border->SetBounds(gfx::Size(40, 40));
+  scroll_grandparent_clip->SetBounds(gfx::Size(20, 20));
+  scroll_grandparent->SetBounds(gfx::Size(50, 50));
+  render_surface1->SetBounds(gfx::Size(50, 50));
+  render_surface1->test_properties()->force_render_surface = true;
+  scroll_parent_border->SetBounds(gfx::Size(40, 40));
+  scroll_parent_clip->SetBounds(gfx::Size(30, 30));
+  scroll_parent->SetBounds(gfx::Size(50, 50));
+  render_surface2->SetBounds(gfx::Size(50, 50));
+  render_surface2->test_properties()->force_render_surface = true;
+  scroll_child->SetBounds(gfx::Size(50, 50));
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20), scroll_child->clip_rect());
   EXPECT_TRUE(scroll_child->is_clipped());
 
   // Despite the fact that we had to process the layers out of order to get the
   // right clip, our render_surface_layer_list's order should be unaffected.
@@ skipping 15 matching lines @@
   // + root
   //   + render_surface
   //     + fixed
   //       + child
   //
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChild<LayerImpl>(root);
   LayerImpl* fixed = AddChild<LayerImpl>(render_surface);
   LayerImpl* child = AddChild<LayerImpl>(fixed);
 
-  render_surface->SetDrawsContent(true);
-  fixed->SetDrawsContent(true);
-  child->SetDrawsContent(true);
-
   render_surface->test_properties()->force_render_surface = true;
   root->test_properties()->is_container_for_fixed_position_layers = true;
 
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
   fixed->test_properties()->position_constraint = constraint;
 
-  SetLayerPropertiesForTesting(root, gfx::Transform(), gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false);
-  SetLayerPropertiesForTesting(render_surface, gfx::Transform(), gfx::Point3F(),
-                               gfx::PointF(7.f, 9.f), gfx::Size(50, 50), true,
-                               false);
-  SetLayerPropertiesForTesting(fixed, gfx::Transform(), gfx::Point3F(),
-                               gfx::PointF(10.f, 15.f), gfx::Size(50, 50), true,
-                               false);
-  SetLayerPropertiesForTesting(child, gfx::Transform(), gfx::Point3F(),
-                               gfx::PointF(1.f, 2.f), gfx::Size(50, 50), true,
-                               false);
-
+  root->SetBounds(gfx::Size(50, 50));
+  render_surface->SetPosition(gfx::PointF(7.f, 9.f));
+  render_surface->SetBounds(gfx::Size(50, 50));
+  render_surface->SetDrawsContent(true);
+  fixed->SetPosition(gfx::PointF(10.f, 15.f));
+  fixed->SetBounds(gfx::Size(50, 50));
+  fixed->SetDrawsContent(true);
+  child->SetPosition(gfx::PointF(1.f, 2.f));
+  child->SetBounds(gfx::Size(50, 50));
+  child->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
   TransformTree& transform_tree =
       host_impl()->active_tree()->property_trees()->transform_tree;
   EffectTree& effect_tree =
       host_impl()->active_tree()->property_trees()->effect_tree;
 
   gfx::Transform expected_fixed_draw_transform;
   expected_fixed_draw_transform.Translate(10.f, 15.f);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
@@ skipping 48 matching lines @@
   LayerImpl* fixed_layer = fixed.get();
 
   container->test_properties()->is_container_for_fixed_position_layers = true;
 
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
   fixed->test_properties()->position_constraint = constraint;
 
   scroller->SetScrollClipLayer(container->id());
 
-  gfx::Transform identity_transform;
   gfx::Transform container_transform;
   container_transform.Translate3d(10.0, 20.0, 0.0);
   gfx::Vector2dF container_offset = container_transform.To2dTranslation();
 
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(container.get(), container_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
-                               true, false, false);
-  SetLayerPropertiesForTesting(scroller.get(), identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               true, false, false);
-  SetLayerPropertiesForTesting(fixed.get(), identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
+  root->SetBounds(gfx::Size(50, 50));
+  container->SetTransform(container_transform);
+  container->SetBounds(gfx::Size(40, 40));
+  container->SetDrawsContent(true);
+  scroller->SetBounds(gfx::Size(30, 30));
+  scroller->SetDrawsContent(true);
+  fixed->SetBounds(gfx::Size(50, 50));
+  fixed->SetDrawsContent(true);
 
-  root->SetDrawsContent(true);
-  container->SetDrawsContent(true);
-  scroller->SetDrawsContent(true);
-  fixed->SetDrawsContent(true);
   scroller->test_properties()->AddChild(std::move(fixed));
   container->test_properties()->AddChild(std::move(scroller));
   root->test_properties()->AddChild(std::move(container));
   root->layer_tree_impl()->SetRootLayerForTesting(std::move(root_ptr));
   root->layer_tree_impl()->BuildPropertyTreesForTesting();
 
   // Rounded to integers already.
   {
     gfx::Vector2dF scroll_delta(3.0, 5.0);
     SetScrollOffsetDelta(scroll_layer, scroll_delta);
@@ skipping 77 matching lines @@
   //   + animated layer
   //     + surface
   //       + container
   //         + scroller
   //
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* animated_layer = AddChildToRoot<FakePictureLayerImpl>();
   LayerImpl* surface = AddChild<LayerImpl>(animated_layer);
   LayerImpl* container = AddChild<LayerImpl>(surface);
   LayerImpl* scroller = AddChild<LayerImpl>(container);
+
+  gfx::Transform start_scale;
+  start_scale.Scale(1.5f, 1.5f);
+
+  root->SetBounds(gfx::Size(50, 50));
+  animated_layer->SetTransform(start_scale);
+  animated_layer->SetBounds(gfx::Size(50, 50));
+  surface->SetBounds(gfx::Size(50, 50));
+  surface->test_properties()->force_render_surface = true;
+  container->SetBounds(gfx::Size(50, 50));
+  scroller->SetBounds(gfx::Size(100, 100));
   scroller->SetScrollClipLayer(container->id());
   scroller->SetDrawsContent(true);
 
-  gfx::Transform identity_transform;
-  gfx::Transform start_scale;
-  start_scale.Scale(1.5f, 1.5f);
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(animated_layer, start_scale, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
-  SetLayerPropertiesForTesting(surface, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(container, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
-  SetLayerPropertiesForTesting(scroller, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-
   gfx::Transform end_scale;
   end_scale.Scale(2.f, 2.f);
   TransformOperations start_operations;
   start_operations.AppendMatrix(start_scale);
   TransformOperations end_operations;
   end_operations.AppendMatrix(end_scale);
   SetElementIdsForTesting();
 
   AddAnimatedTransformToElementWithPlayer(animated_layer->element_id(),
                                           timeline_impl(), 1.0,
@@ skipping 28 matching lines @@
 };
 
 TEST_F(LayerTreeHostCommonTest, MaximumAnimationScaleFactor) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   LayerTreeSettings settings = host()->settings();
   settings.layer_transforms_should_scale_layer_contents = true;
   FakeLayerTreeHostImpl host_impl(settings, &task_runner_provider,
                                   &shared_bitmap_manager, &task_graph_runner);
-  gfx::Transform identity_matrix;
   std::unique_ptr<AnimationScaleFactorTrackingLayerImpl> grand_parent =
       AnimationScaleFactorTrackingLayerImpl::Create(host_impl.active_tree(), 1);
   std::unique_ptr<AnimationScaleFactorTrackingLayerImpl> parent =
       AnimationScaleFactorTrackingLayerImpl::Create(host_impl.active_tree(), 2);
   std::unique_ptr<AnimationScaleFactorTrackingLayerImpl> child =
       AnimationScaleFactorTrackingLayerImpl::Create(host_impl.active_tree(), 3);
   std::unique_ptr<AnimationScaleFactorTrackingLayerImpl> grand_child =
       AnimationScaleFactorTrackingLayerImpl::Create(host_impl.active_tree(), 4);
 
   AnimationScaleFactorTrackingLayerImpl* parent_raw = parent.get();
   AnimationScaleFactorTrackingLayerImpl* child_raw = child.get();
   AnimationScaleFactorTrackingLayerImpl* grand_child_raw = grand_child.get();
   AnimationScaleFactorTrackingLayerImpl* grand_parent_raw = grand_parent.get();
 
+  grand_parent->SetBounds(gfx::Size(1, 2));
+  parent->SetBounds(gfx::Size(1, 2));
+  child->SetBounds(gfx::Size(1, 2));
+  grand_child->SetBounds(gfx::Size(1, 2));
+
   child->test_properties()->AddChild(std::move(grand_child));
   parent->test_properties()->AddChild(std::move(child));
   grand_parent->test_properties()->AddChild(std::move(parent));
-
-  SetLayerPropertiesForTesting(grand_parent_raw, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
-                               true, false, true);
-  SetLayerPropertiesForTesting(parent_raw, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1, 2), true, false,
-                               false);
-  SetLayerPropertiesForTesting(child_raw, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1, 2), true, false,
-                               false);
-
-  SetLayerPropertiesForTesting(grand_child_raw, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1, 2), true, false,
-                               false);
-
   host_impl.active_tree()->SetRootLayerForTesting(std::move(grand_parent));
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // No layers have animations.
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
@@ skipping 157 matching lines @@
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 
-  parent_raw->SetTransform(identity_matrix);
-  child_raw->SetTransform(identity_matrix);
+  parent_raw->SetTransform(gfx::Transform());
+  child_raw->SetTransform(gfx::Transform());
   grand_parent_raw->SetTransform(perspective_matrix);
   grand_parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |grand_parent| has a transform that's neither a translation nor a scale.
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
@@ skipping 22 matching lines @@
       drawn_layers->insert(layer->render_surface()->ReplicaMaskLayer());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceLayerListMembership) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
-  gfx::Transform identity_matrix;
 
   std::unique_ptr<LayerImpl> grand_parent =
       LayerImpl::Create(host_impl.active_tree(), 1);
   std::unique_ptr<LayerImpl> parent =
       LayerImpl::Create(host_impl.active_tree(), 3);
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl.active_tree(), 5);
   std::unique_ptr<LayerImpl> grand_child1 =
       LayerImpl::Create(host_impl.active_tree(), 7);
   std::unique_ptr<LayerImpl> grand_child2 =
       LayerImpl::Create(host_impl.active_tree(), 9);
 
   LayerImpl* grand_parent_raw = grand_parent.get();
   LayerImpl* parent_raw = parent.get();
   LayerImpl* child_raw = child.get();
   LayerImpl* grand_child1_raw = grand_child1.get();
   LayerImpl* grand_child2_raw = grand_child2.get();
 
+  grand_parent->SetBounds(gfx::Size(1, 2));
+  parent->SetBounds(gfx::Size(1, 2));
+  child->SetBounds(gfx::Size(1, 2));
+  grand_child1->SetBounds(gfx::Size(1, 2));
+  grand_child2->SetBounds(gfx::Size(1, 2));
+
   child->test_properties()->AddChild(std::move(grand_child1));
   child->test_properties()->AddChild(std::move(grand_child2));
   parent->test_properties()->AddChild(std::move(child));
   grand_parent->test_properties()->AddChild(std::move(parent));
   host_impl.active_tree()->SetRootLayerForTesting(std::move(grand_parent));
 
-  SetLayerPropertiesForTesting(grand_parent_raw, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
-                               true, false, true);
-  SetLayerPropertiesForTesting(parent_raw, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1, 2), true, false,
-                               false);
-
-  SetLayerPropertiesForTesting(child_raw, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1, 2), true, false,
-                               false);
-
-  SetLayerPropertiesForTesting(grand_child1_raw, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
-                               true, false, false);
-
-  SetLayerPropertiesForTesting(grand_child2_raw, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
-                               true, false, false);
-
   // Start with nothing being drawn.
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   std::set<LayerImpl*> expected;
@@ skipping 204 matching lines @@
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 1);
   LayerImpl* root_layer = root.get();
   std::unique_ptr<LayerImpl> child1 =
       LayerImpl::Create(host_impl.active_tree(), 2);
   LayerImpl* child1_layer = child1.get();
   std::unique_ptr<LayerImpl> child2 =
       LayerImpl::Create(host_impl.active_tree(), 3);
   LayerImpl* child2_layer = child2.get();
 
-  root->test_properties()->AddChild(std::move(child1));
-  root->test_properties()->AddChild(std::move(child2));
-  root->test_properties()->force_render_surface = true;
-  root->SetDrawsContent(true);
-  host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
-
-  host_impl.active_tree()->SetElementIdsForTesting();
-
-  gfx::Transform identity_matrix, scale_transform_child1,
-      scale_transform_child2;
+  gfx::Transform scale_transform_child1, scale_transform_child2;
   scale_transform_child1.Scale(2, 3);
   scale_transform_child2.Scale(4, 5);
 
-  SetLayerPropertiesForTesting(root_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1, 1), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child1_layer, scale_transform_child1,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(1, 1),
-                               true, false, false);
+  root->SetBounds(gfx::Size(1, 1));
+  root->SetDrawsContent(true);
+  child1_layer->SetTransform(scale_transform_child1);
+  child1_layer->SetBounds(gfx::Size(1, 1));
+  child1_layer->SetDrawsContent(true);
 
   child1_layer->test_properties()->SetMaskLayer(
       LayerImpl::Create(host_impl.active_tree(), 4));
-  child1_layer->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> replica_layer =
       LayerImpl::Create(host_impl.active_tree(), 5);
   replica_layer->test_properties()->SetMaskLayer(
       LayerImpl::Create(host_impl.active_tree(), 6));
   child1_layer->test_properties()->SetReplicaLayer(std::move(replica_layer));
-  child1_layer->SetHasRenderSurface(true);
+
+  root->test_properties()->AddChild(std::move(child1));
+  root->test_properties()->AddChild(std::move(child2));
+  host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
+  host_impl.active_tree()->SetElementIdsForTesting();
 
   ExecuteCalculateDrawProperties(root_layer);
 
   TransformOperations scale;
   scale.AppendScale(5.f, 8.f, 3.f);
 
   scoped_refptr<AnimationTimeline> timeline =
       AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
-  SetLayerPropertiesForTesting(child2_layer, scale_transform_child2,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(1, 1),
-                               true, false, false);
+  child2_layer->SetTransform(scale_transform_child2);
+  child2_layer->SetBounds(gfx::Size(1, 1));
   child2_layer->SetDrawsContent(true);
-
   AddAnimatedTransformToElementWithPlayer(child2_layer->element_id(), timeline,
                                           1.0, TransformOperations(), scale);
 
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_layer);
 
   EXPECT_FLOAT_EQ(1.f, root_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(3.f, child1_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(
       3.f,
@@ skipping 77 matching lines @@
   std::unique_ptr<LayerImpl> child2 =
       LayerImpl::Create(host_impl.active_tree(), 3);
   LayerImpl* child2_layer = child2.get();
 
   root->test_properties()->AddChild(std::move(child1));
   child1_layer->test_properties()->AddChild(std::move(child2));
   host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
 
   host_impl.active_tree()->SetElementIdsForTesting();
 
-  gfx::Transform identity_matrix, scale_transform_child1,
-      scale_transform_child2;
+  gfx::Transform scale_transform_child1, scale_transform_child2;
   scale_transform_child1.Scale(2, 3);
   scale_transform_child2.Scale(4, 5);
 
-  SetLayerPropertiesForTesting(root_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1, 1), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child1_layer, scale_transform_child1,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(1, 1),
-                               true, false, false);
+  root_layer->SetBounds(gfx::Size(1, 1));
+  child1_layer->SetTransform(scale_transform_child1);
+  child1_layer->SetBounds(gfx::Size(1, 1));
+  child2_layer->SetTransform(scale_transform_child2);
+  child2_layer->SetBounds(gfx::Size(1, 1));
 
   TransformOperations scale;
   scale.AppendScale(5.f, 8.f, 3.f);
 
   scoped_refptr<AnimationTimeline> timeline =
       AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
   AddAnimatedTransformToElementWithPlayer(child2_layer->element_id(), timeline,
                                           1.0, TransformOperations(), scale);
 
-  SetLayerPropertiesForTesting(child2_layer, scale_transform_child2,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(1, 1),
-                               true, false, false);
-
   // Correctly computes animation scale when rebuilding property trees.
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_layer);
 
   EXPECT_FLOAT_EQ(0.f, GetMaximumAnimationScale(root_layer));
   EXPECT_FLOAT_EQ(0.f, GetMaximumAnimationScale(child1_layer));
   EXPECT_FLOAT_EQ(24.f, GetMaximumAnimationScale(child2_layer));
 
   EXPECT_FLOAT_EQ(0.f, GetStartingAnimationScale(root_layer));
   EXPECT_FLOAT_EQ(0.f, GetStartingAnimationScale(child1_layer));
   EXPECT_FLOAT_EQ(3.f, GetStartingAnimationScale(child2_layer));
 
   // Correctly updates animation scale when layer property changes.
-  child1_layer->SetTransform(identity_matrix);
+  child1_layer->SetTransform(gfx::Transform());
   child1_layer->UpdatePropertyTreeTransform();
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = false;
   ExecuteCalculateDrawProperties(root_layer);
   EXPECT_FLOAT_EQ(8.f, GetMaximumAnimationScale(child2_layer));
   EXPECT_FLOAT_EQ(1.f, GetStartingAnimationScale(child2_layer));
 
   // Do not update animation scale if already updated.
   host_impl.active_tree()->property_trees()->SetAnimationScalesForTesting(
       child2_layer->transform_tree_index(), 100.f, 100.f);
   EXPECT_FLOAT_EQ(100.f, GetMaximumAnimationScale(child2_layer));
@@ skipping 17 matching lines @@
   LayerImpl* root_layer = root.get();
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl.active_tree(), 2);
   LayerImpl* child_layer = child.get();
 
   root->test_properties()->AddChild(std::move(child));
   host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
 
   host_impl.active_tree()->SetElementIdsForTesting();
 
-  gfx::Transform identity_matrix, scale_transform_child;
+  gfx::Transform scale_transform_child;
   scale_transform_child.Scale(4, 5);
 
-  SetLayerPropertiesForTesting(root_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1, 1), true, false,
-                               true);
+  root_layer->SetBounds(gfx::Size(1, 1));
+  child_layer->SetTransform(scale_transform_child);
+  child_layer->SetBounds(gfx::Size(1, 1));
+
   TransformOperations scale;
   scale.AppendScale(5.f, 8.f, 3.f);
 
   scoped_refptr<AnimationTimeline> timeline =
       AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
   AddAnimatedTransformToElementWithPlayer(child_layer->element_id(), timeline,
                                           1.0, TransformOperations(), scale);
 
-  SetLayerPropertiesForTesting(child_layer, scale_transform_child,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(1, 1),
-                               true, false, false);
-
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_layer);
 
   EXPECT_FLOAT_EQ(0.f, GetMaximumAnimationScale(root_layer));
   EXPECT_FLOAT_EQ(0.f, GetMaximumAnimationScale(child_layer));
 
   EXPECT_FLOAT_EQ(0.f, GetStartingAnimationScale(root_layer));
   EXPECT_FLOAT_EQ(0.f, GetStartingAnimationScale(child_layer));
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectInChildRenderSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip = AddChild<LayerImpl>(root);
   LayerImpl* content = AddChild<LayerImpl>(clip);
 
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(768 / 2, 3000), true,
-                               false, true);
-  SetLayerPropertiesForTesting(clip, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(768 / 2, 10000), true,
-                               false, false);
-  SetLayerPropertiesForTesting(content, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(768 / 2, 10000), true,
-                               false, true);
+  root->SetBounds(gfx::Size(768 / 2, 3000));
   root->SetDrawsContent(true);
+  clip->SetBounds(gfx::Size(768 / 2, 10000));
   clip->SetMasksToBounds(true);
+  content->SetBounds(gfx::Size(768 / 2, 10000));
   content->SetDrawsContent(true);
+  content->test_properties()->force_render_surface = true;
 
   gfx::Size device_viewport_size(768, 582);
   LayerImplList render_surface_layer_list_impl;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root, device_viewport_size, identity_matrix,
+      root, device_viewport_size, gfx::Transform(),
       &render_surface_layer_list_impl);
   inputs.device_scale_factor = 2.f;
   inputs.page_scale_factor = 1.f;
   inputs.page_scale_layer = NULL;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // Layers in the root render surface have their visible content rect clipped
   // by the viewport.
   EXPECT_EQ(gfx::Rect(768 / 2, 582 / 2), root->visible_layer_rect());
 
@@ skipping 12 matching lines @@
   // Set two layers: the root layer clips it's child,
   // the child draws its content.
 
   gfx::Size root_size = gfx::Size(300, 500);
 
   // Sublayer should be bigger than the root enlarged by bounds_delta.
   gfx::Size sublayer_size = gfx::Size(300, 1000);
 
   // Device viewport accomidated the root and the top controls.
   gfx::Size device_viewport_size = gfx::Size(300, 600);
-  gfx::Transform identity_matrix;
 
   host_impl.SetViewportSize(device_viewport_size);
   host_impl.active_tree()->SetRootLayerForTesting(
       LayerImpl::Create(host_impl.active_tree(), 1));
 
   LayerImpl* root = host_impl.active_tree()->root_layer_for_testing();
-  SetLayerPropertiesForTesting(root,
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               root_size,
-                               false,
-                               false,
-                               true);
+  root->SetBounds(root_size);
   root->SetMasksToBounds(true);
 
   root->test_properties()->AddChild(
       LayerImpl::Create(host_impl.active_tree(), 2));
 
   LayerImpl* sublayer = root->test_properties()->children[0];
-  SetLayerPropertiesForTesting(sublayer,
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               sublayer_size,
-                               false,
-                               false,
-                               false);
+  sublayer->SetBounds(sublayer_size);
   sublayer->SetDrawsContent(true);
 
   host_impl.active_tree()->BuildPropertyTreesForTesting();
 
   LayerImplList layer_impl_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root, device_viewport_size, &layer_impl_list);
 
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
   EXPECT_EQ(gfx::Rect(root_size), sublayer->visible_layer_rect());
@@ skipping 58 matching lines @@
   EXPECT_TRUE(transform_tree.HasNodesAffectedByOuterViewportBoundsDelta());
 
   fixed_to_outer->SetPositionConstraint(fixed_to_left);
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_FALSE(transform_tree.HasNodesAffectedByInnerViewportBoundsDelta());
   EXPECT_FALSE(transform_tree.HasNodesAffectedByOuterViewportBoundsDelta());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectForAnimatedLayer) {
-  const gfx::Transform identity_matrix;
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> animated =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   root->AddChild(animated);
-
   host()->SetRootLayer(root);
-
   host()->SetElementIdsForTesting();
 
-  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(animated.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false);
-
+  root->SetBounds(gfx::Size(100, 100));
   root->SetMasksToBounds(true);
   root->SetForceRenderSurfaceForTesting(true);
   animated->SetOpacity(0.f);
+  animated->SetBounds(gfx::Size(20, 20));
 
   AddOpacityTransitionToElementWithPlayer(animated->element_id(), timeline(),
                                           10.0, 0.f, 1.f, false);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   EXPECT_FALSE(animated->visible_layer_rect_for_testing().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleContentRectForAnimatedLayerWithSingularTransform) {
-  const gfx::Transform identity_matrix;
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> clip = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> animated =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> surface =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> descendant_of_animation =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   root->AddChild(clip);
   clip->AddChild(animated);
   animated->AddChild(surface);
   surface->AddChild(descendant_of_animation);
 
-  clip->SetMasksToBounds(true);
-  surface->SetForceRenderSurfaceForTesting(true);
-
   host()->SetRootLayer(root);
-
   host()->SetElementIdsForTesting();
 
   gfx::Transform uninvertible_matrix;
   uninvertible_matrix.Scale3d(6.f, 6.f, 0.f);
 
-  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(clip.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false);
-  SetLayerPropertiesForTesting(animated.get(), uninvertible_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(120, 120), true, false);
-  SetLayerPropertiesForTesting(surface.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(descendant_of_animation.get(), identity_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(200, 200), true, false);
+  root->SetBounds(gfx::Size(100, 100));
+  clip->SetBounds(gfx::Size(10, 10));
+  clip->SetMasksToBounds(true);
+  animated->SetTransform(uninvertible_matrix);
+  animated->SetBounds(gfx::Size(120, 120));
+  surface->SetBounds(gfx::Size(100, 100));
+  surface->SetForceRenderSurfaceForTesting(true);
+  descendant_of_animation->SetBounds(gfx::Size(200, 200));
 
   TransformOperations start_transform_operations;
   start_transform_operations.AppendMatrix(uninvertible_matrix);
   TransformOperations end_transform_operations;
 
   SetElementIdsForTesting();
   AddAnimatedTransformToElementWithPlayer(animated->element_id(), timeline(),
                                           10.0, start_transform_operations,
                                           end_transform_operations);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   // The animated layer has a singular transform and maps to a non-empty rect in
   // clipped target space, so is treated as fully visible.
   EXPECT_EQ(gfx::Rect(120, 120), animated->visible_layer_rect_for_testing());
 
   // The singular transform on |animated| is flattened when inherited by
   // |surface|, and this happens to make it invertible.
   EXPECT_EQ(gfx::Rect(2, 2), surface->visible_layer_rect_for_testing());
   EXPECT_EQ(gfx::Rect(2, 2),
             descendant_of_animation->visible_layer_rect_for_testing());
 
   gfx::Transform zero_matrix;
   zero_matrix.Scale3d(0.f, 0.f, 0.f);
-  SetLayerPropertiesForTesting(animated.get(), zero_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(120, 120), true, false);
-
+  animated->SetTransform(zero_matrix);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   // The animated layer maps to the empty rect in clipped target space, so is
   // treated as having an empty visible rect.
   EXPECT_EQ(gfx::Rect(), animated->visible_layer_rect_for_testing());
 
   // This time, flattening does not make |animated|'s transform invertible. This
   // means the clip cannot be projected into |surface|'s space, so we treat
   // |surface| and layers that draw into it as having empty visible rect.
   EXPECT_EQ(gfx::Rect(), surface->visible_layer_rect_for_testing());
   EXPECT_EQ(gfx::Rect(),
             descendant_of_animation->visible_layer_rect_for_testing());
 }
 
 // Verify that having animated opacity but current opacity 1 still creates
 // a render surface.
 TEST_F(LayerTreeHostCommonTest, AnimatedOpacityCreatesRenderSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grandchild = AddChild<LayerImpl>(child);
+
+  root->SetBounds(gfx::Size(50, 50));
+  child->SetBounds(gfx::Size(50, 50));
   child->SetDrawsContent(true);
+  grandchild->SetBounds(gfx::Size(50, 50));
   grandchild->SetDrawsContent(true);
 
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false);
-  SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false);
-  SetLayerPropertiesForTesting(grandchild, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false);
-
   SetElementIdsForTesting();
   AddOpacityTransitionToElementWithPlayer(child->element_id(), timeline_impl(),
                                           10.0, 1.f, 0.2f, false);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(1.f, child->Opacity());
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_TRUE(child->has_render_surface());
   EXPECT_FALSE(grandchild->has_render_surface());
 }
 
 // Verify that having an animated filter (but no current filter, as these
 // are mutually exclusive) correctly creates a render surface.
 TEST_F(LayerTreeHostCommonTest, AnimatedFilterCreatesRenderSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grandchild = AddChild<LayerImpl>(child);
 
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false);
-  SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false);
-  SetLayerPropertiesForTesting(grandchild, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false);
+  root->SetBounds(gfx::Size(50, 50));
+  child->SetBounds(gfx::Size(50, 50));
+  grandchild->SetBounds(gfx::Size(50, 50));
 
   SetElementIdsForTesting();
   AddAnimatedFilterToElementWithPlayer(child->element_id(), timeline_impl(),
                                        10.0, 0.1f, 0.2f);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_TRUE(child->has_render_surface());
   EXPECT_FALSE(grandchild->has_render_surface());
 
   EXPECT_TRUE(root->render_surface()->Filters().IsEmpty());
   EXPECT_TRUE(child->render_surface()->Filters().IsEmpty());
 
   EXPECT_FALSE(root->FilterIsAnimating());
   EXPECT_TRUE(child->FilterIsAnimating());
   EXPECT_FALSE(grandchild->FilterIsAnimating());
 }
 
 // Verify that having a filter animation with a delayed start time creates a
 // render surface.
 TEST_F(LayerTreeHostCommonTest, DelayedFilterAnimationCreatesRenderSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grandchild = AddChild<LayerImpl>(child);
 
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false);
-  SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false);
-  SetLayerPropertiesForTesting(grandchild, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false);
+  root->SetBounds(gfx::Size(50, 50));
+  child->SetBounds(gfx::Size(50, 50));
+  grandchild->SetBounds(gfx::Size(50, 50));
 
   SetElementIdsForTesting();
 
   std::unique_ptr<KeyframedFilterAnimationCurve> curve(
       KeyframedFilterAnimationCurve::Create());
   FilterOperations start_filters;
   start_filters.Append(FilterOperation::CreateBrightnessFilter(0.1f));
   FilterOperations end_filters;
   end_filters.Append(FilterOperation::CreateBrightnessFilter(0.3f));
   curve->AddKeyframe(
@@ skipping 24 matching lines @@
   EXPECT_FALSE(grandchild->HasPotentiallyRunningFilterAnimation());
 }
 
 // Ensures that the property tree code accounts for offsets between fixed
 // position layers and their respective containers.
 TEST_F(LayerTreeHostCommonTest, PropertyTreesAccountForFixedParentOffset) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grandchild = AddChild<LayerImpl>(child);
 
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(1000, 1000), gfx::Size(50, 50), true,
-                               false, false);
-  SetLayerPropertiesForTesting(grandchild, identity_transform, gfx::Point3F(),
-                               gfx::PointF(-1000, -1000), gfx::Size(50, 50),
-                               true, false, false);
-
+  root->SetBounds(gfx::Size(50, 50));
   root->SetMasksToBounds(true);
   root->test_properties()->is_container_for_fixed_position_layers = true;
+  child->SetPosition(gfx::PointF(1000, 1000));
+  child->SetBounds(gfx::Size(50, 50));
+  grandchild->SetPosition(gfx::PointF(-1000, -1000));
+  grandchild->SetBounds(gfx::Size(50, 50));
+  grandchild->SetDrawsContent(true);
+
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
   grandchild->test_properties()->position_constraint = constraint;
-  grandchild->SetDrawsContent(true);
-
-  root->test_properties()->is_container_for_fixed_position_layers = true;
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), grandchild->visible_layer_rect());
 }
 
 // Ensures that the property tree code accounts for offsets between fixed
 // position containers and their transform tree parents, when a fixed position
 // layer's container is its layer tree parent, but this parent doesn't have its
 // own transform tree node.
 TEST_F(LayerTreeHostCommonTest,
        PropertyTreesAccountForFixedParentOffsetWhenContainerIsParent) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grandchild = AddChild<LayerImpl>(child);
 
-  gfx::Transform identity_transform;
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
-                               gfx::PointF(1000, 1000), gfx::Size(50, 50), true,
-                               false, false);
-  SetLayerPropertiesForTesting(grandchild, identity_transform, gfx::Point3F(),
-                               gfx::PointF(-1000, -1000), gfx::Size(50, 50),
-                               true, false, false);
+  root->SetBounds(gfx::Size(50, 50));
+  root->SetMasksToBounds(true);
+  root->test_properties()->is_container_for_fixed_position_layers = true;
+  child->SetPosition(gfx::PointF(1000, 1000));
+  child->SetBounds(gfx::Size(50, 50));
+  child->test_properties()->is_container_for_fixed_position_layers = true;
+  grandchild->SetPosition(gfx::PointF(-1000, -1000));
+  grandchild->SetBounds(gfx::Size(50, 50));
+  grandchild->SetDrawsContent(true);
 
-  root->SetMasksToBounds(true);
-  child->test_properties()->is_container_for_fixed_position_layers = true;
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
   grandchild->test_properties()->position_constraint = constraint;
-  grandchild->SetDrawsContent(true);
-
-  root->test_properties()->is_container_for_fixed_position_layers = true;
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), grandchild->visible_layer_rect());
 }
 
-TEST_F(LayerTreeHostCommonTest, CombineClipsUsingContentTarget) {
-  // In the following layer tree, the layer |box|'s render target is |surface|.
-  // |surface| also creates a transform node. We want to combine clips for |box|
-  // in the space of its target (i.e., |surface|), not its target's target. This
-  // test ensures that happens.
-
-  gfx::Transform rotate;
-  rotate.Rotate(5);
-  gfx::Transform identity;
-
-  scoped_refptr<Layer> root = Layer::Create();
-  SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(2500, 1500), true,
-                               false);
-
-  scoped_refptr<Layer> frame_clip = Layer::Create();
-  SetLayerPropertiesForTesting(frame_clip.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(2500, 1500), true,
-                               false);
-  frame_clip->SetMasksToBounds(true);
-
-  scoped_refptr<Layer> rotated = Layer::Create();
-  SetLayerPropertiesForTesting(rotated.get(), rotate,
-                               gfx::Point3F(1250, 250, 0), gfx::PointF(),
-                               gfx::Size(2500, 500), true, false);
-
-  scoped_refptr<Layer> surface = Layer::Create();
-  SetLayerPropertiesForTesting(surface.get(), rotate, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(2500, 500), true,
-                               false);
-  surface->SetOpacity(0.5);
-
-  scoped_refptr<LayerWithForcedDrawsContent> container =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
-  SetLayerPropertiesForTesting(container.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(300, 300), true, false);
-
-  scoped_refptr<LayerWithForcedDrawsContent> box =
-      make_scoped_refptr(new LayerWithForcedDrawsContent());
-  SetLayerPropertiesForTesting(box.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-
-  root->AddChild(frame_clip);
-  frame_clip->AddChild(rotated);
-  rotated->AddChild(surface);
-  surface->AddChild(container);
-  surface->AddChild(box);
-
-  host()->SetRootLayer(root);
-
-  ExecuteCalculateDrawProperties(root.get());
-}
-
 TEST_F(LayerTreeHostCommonTest, OnlyApplyFixedPositioningOnce) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* frame_clip = AddChild<LayerImpl>(root);
   LayerImpl* fixed = AddChild<LayerImpl>(frame_clip);
-  gfx::Transform identity;
   gfx::Transform translate_z;
   translate_z.Translate3d(0, 0, 10);
 
-  SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(800, 800), true, false, true);
+  root->SetBounds(gfx::Size(800, 800));
   root->test_properties()->is_container_for_fixed_position_layers = true;
 
-  SetLayerPropertiesForTesting(frame_clip, translate_z, gfx::Point3F(),
-                               gfx::PointF(500, 100), gfx::Size(100, 100), true,
-                               false, false);
+  frame_clip->SetPosition(gfx::PointF(500, 100));
+  frame_clip->SetBounds(gfx::Size(100, 100));
   frame_clip->SetMasksToBounds(true);
 
-  SetLayerPropertiesForTesting(fixed, identity, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(1000, 1000), true, false, false);
+  fixed->SetBounds(gfx::Size(1000, 1000));
+  fixed->SetDrawsContent(true);
 
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
   fixed->test_properties()->position_constraint = constraint;
-  fixed->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(root);
 
   gfx::Rect expected(0, 0, 100, 100);
   EXPECT_EQ(expected, fixed->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, FixedClipsShouldBeAssociatedWithTheRightNode) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* frame_clip = AddChild<LayerImpl>(root);
   LayerImpl* scroller = AddChild<LayerImpl>(frame_clip);
   LayerImpl* fixed = AddChild<LayerImpl>(scroller);
 
-  gfx::Transform identity;
-  SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(800, 800), true, false, true);
-  SetLayerPropertiesForTesting(frame_clip, identity, gfx::Point3F(),
-                               gfx::PointF(500, 100), gfx::Size(100, 100), true,
-                               false, false);
-  SetLayerPropertiesForTesting(scroller, identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1000, 1000), true,
-                               false, false);
-  SetLayerPropertiesForTesting(fixed, identity, gfx::Point3F(),
-                               gfx::PointF(100, 100), gfx::Size(50, 50), true,
-                               false, true);
-
+  root->SetBounds(gfx::Size(800, 800));
+  root->SetDrawsContent(true);
   root->test_properties()->is_container_for_fixed_position_layers = true;
-  root->SetDrawsContent(true);
-
+  frame_clip->SetPosition(gfx::PointF(500, 100));
+  frame_clip->SetBounds(gfx::Size(100, 100));
   frame_clip->SetMasksToBounds(true);
   frame_clip->SetDrawsContent(true);
-
+  scroller->SetBounds(gfx::Size(1000, 1000));
   scroller->SetCurrentScrollOffset(gfx::ScrollOffset(100, 100));
   scroller->SetScrollClipLayer(frame_clip->id());
   scroller->SetDrawsContent(true);
+  fixed->SetPosition(gfx::PointF(100, 100));
+  fixed->SetBounds(gfx::Size(50, 50));
+  fixed->SetMasksToBounds(true);
+  fixed->SetDrawsContent(true);
+  fixed->test_properties()->force_render_surface = true;
 
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
   fixed->test_properties()->position_constraint = constraint;
-  fixed->SetMasksToBounds(true);
-  fixed->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(root);
 
   gfx::Rect expected(0, 0, 50, 50);
   EXPECT_EQ(expected, fixed->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, ChangingAxisAlignmentTriggersRebuild) {
-  gfx::Transform identity;
   gfx::Transform translate;
   gfx::Transform rotate;
 
   translate.Translate(10, 10);
   rotate.Rotate(45);
 
   scoped_refptr<Layer> root = Layer::Create();
-  SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(800, 800), true, false);
+  root->SetBounds(gfx::Size(800, 800));
   root->SetIsContainerForFixedPositionLayers(true);
 
   host()->SetRootLayer(root);
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_FALSE(host()->property_trees()->needs_rebuild);
 
   root->SetTransform(translate);
   EXPECT_FALSE(host()->property_trees()->needs_rebuild);
 
   root->SetTransform(rotate);
   EXPECT_TRUE(host()->property_trees()->needs_rebuild);
 }
 
 TEST_F(LayerTreeHostCommonTest, ChangeTransformOrigin) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
 
-  gfx::Transform identity_matrix;
   gfx::Transform scale_matrix;
   scale_matrix.Scale(2.f, 2.f);
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, scale_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
 
+  root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
+  child->SetTransform(scale_matrix);
+  child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(10, 10), child->visible_layer_rect());
 
   child->test_properties()->transform_origin = gfx::Point3F(10.f, 10.f, 10.f);
 
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(5, 5, 5, 5), child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, UpdateScrollChildPosition) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* scroll_parent = AddChild<LayerImpl>(root);
   LayerImpl* scroll_child = AddChild<LayerImpl>(scroll_parent);
 
+  gfx::Transform scale;
+  scale.Scale(2.f, 2.f);
+
+  root->SetBounds(gfx::Size(50, 50));
+  scroll_child->SetTransform(scale);
+  scroll_child->SetBounds(gfx::Size(40, 40));
   scroll_child->SetDrawsContent(true);
-  scroll_child->test_properties()->scroll_parent = scroll_parent;
-  std::unique_ptr<std::set<LayerImpl*>> scroll_children(
-      new std::set<LayerImpl*>);
-  scroll_children->insert(scroll_child);
-  scroll_parent->test_properties()->scroll_children.reset(
-      scroll_children.release());
+  scroll_parent->SetBounds(gfx::Size(30, 30));
   scroll_parent->SetDrawsContent(true);
 
-  gfx::Transform identity_transform;
-  gfx::Transform scale;
-  scale.Scale(2.f, 2.f);
-  SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(scroll_child, scale, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(40, 40), true, false,
-                               false);
-  SetLayerPropertiesForTesting(scroll_parent, identity_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               true, false, false);
+  scroll_child->test_properties()->scroll_parent = scroll_parent;
+  scroll_parent->test_properties()->scroll_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  scroll_parent->test_properties()->scroll_children->insert(scroll_child);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(25, 25), scroll_child->visible_layer_rect());
 
   scroll_child->SetPosition(gfx::PointF(0, -10.f));
   scroll_parent->SetCurrentScrollOffset(gfx::ScrollOffset(0.f, 10.f));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 5, 25, 25), scroll_child->visible_layer_rect());
 }
@@ skipping 28 matching lines @@
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   EXPECT_EQ(root->num_copy_requests_in_target_subtree(), 2);
   EXPECT_EQ(child1->num_copy_requests_in_target_subtree(), 2);
   EXPECT_EQ(child2->num_copy_requests_in_target_subtree(), 0);
   EXPECT_EQ(grandchild->num_copy_requests_in_target_subtree(), 2);
   EXPECT_EQ(greatgrandchild->num_copy_requests_in_target_subtree(), 1);
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingSubtreeMain) {
-  gfx::Transform identity;
   scoped_refptr<Layer> root = Layer::Create();
   FakeContentLayerClient client;
   client.set_bounds(root->bounds());
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> grandchild =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<FakePictureLayer> greatgrandchild(
       FakePictureLayer::Create(&client));
-  SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(child.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false);
-  SetLayerPropertiesForTesting(grandchild.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false);
-  SetLayerPropertiesForTesting(greatgrandchild.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false);
+
+  root->SetBounds(gfx::Size(100, 100));
+  child->SetBounds(gfx::Size(10, 10));
+  grandchild->SetBounds(gfx::Size(10, 10));
+  greatgrandchild->SetBounds(gfx::Size(10, 10));
 
   root->AddChild(child);
   child->AddChild(grandchild);
   grandchild->AddChild(greatgrandchild);
-
   host()->SetRootLayer(root);
-
   host()->SetElementIdsForTesting();
 
   // Check the non-skipped case.
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_layer_rect_for_testing());
 
   // Now we will reset the visible rect from property trees for the grandchild,
   // and we will configure |child| in several ways that should force the subtree
   // to be skipped. The visible content rect for |grandchild| should, therefore,
   // remain empty.
   grandchild->set_visible_layer_rect(gfx::Rect());
   gfx::Transform singular;
   singular.matrix().set(0, 0, 0);
 
   child->SetTransform(singular);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(0, 0), grandchild->visible_layer_rect_for_testing());
-  child->SetTransform(identity);
+  child->SetTransform(gfx::Transform());
 
   child->SetHideLayerAndSubtree(true);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(0, 0), grandchild->visible_layer_rect_for_testing());
   child->SetHideLayerAndSubtree(false);
 
   gfx::Transform zero_z_scale;
   zero_z_scale.Scale3d(1, 1, 0);
   child->SetTransform(zero_z_scale);
 
   // Add a transform animation with a start delay. Now, even though |child| has
   // a singular transform, the subtree should still get processed.
   int animation_id = 0;
   std::unique_ptr<Animation> animation = Animation::Create(
       std::unique_ptr<AnimationCurve>(new FakeTransformTransition(1.0)),
       animation_id, 1, TargetProperty::TRANSFORM);
   animation->set_fill_mode(Animation::FillMode::NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
   AddAnimationToElementWithPlayer(child->element_id(), timeline(),
                                   std::move(animation));
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_layer_rect_for_testing());
   grandchild->set_visible_layer_rect(gfx::Rect());
 
   RemoveAnimationFromElementWithExistingPlayer(child->element_id(), timeline(),
                                                animation_id);
-  child->SetTransform(identity);
+  child->SetTransform(gfx::Transform());
   child->SetOpacity(0.f);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(0, 0), grandchild->visible_layer_rect_for_testing());
 
   // Now, even though child has zero opacity, we will configure |grandchild| and
   // |greatgrandchild| in several ways that should force the subtree to be
   // processed anyhow.
   grandchild->RequestCopyOfOutput(
       CopyOutputRequest::CreateBitmapRequest(base::Bind(&CopyOutputCallback)));
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
@@ skipping 13 matching lines @@
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_layer_rect_for_testing());
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingLayerImpl) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
 
-  gfx::Transform identity;
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 1);
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl.active_tree(), 2);
   std::unique_ptr<LayerImpl> grandchild =
       LayerImpl::Create(host_impl.active_tree(), 3);
 
   std::unique_ptr<FakePictureLayerImpl> greatgrandchild(
       FakePictureLayerImpl::Create(host_impl.active_tree(), 4));
 
+  root->SetBounds(gfx::Size(100, 100));
+  child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
+  grandchild->SetBounds(gfx::Size(10, 10));
   grandchild->SetDrawsContent(true);
   greatgrandchild->SetDrawsContent(true);
 
-  SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-  SetLayerPropertiesForTesting(grandchild.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-
   LayerImpl* root_ptr = root.get();
   LayerImpl* child_ptr = child.get();
   LayerImpl* grandchild_ptr = grandchild.get();
 
   child->test_properties()->AddChild(std::move(grandchild));
   root->test_properties()->AddChild(std::move(child));
   host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
 
   host_impl.active_tree()->SetElementIdsForTesting();
 
@@ skipping 17 matching lines @@
   rotate.Rotate(90);
 
   gfx::Transform rotate_back_and_translate;
   rotate_back_and_translate.RotateAboutYAxis(180);
   rotate_back_and_translate.Translate(-10, 0);
 
   child_ptr->SetTransform(singular);
   host_impl.active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
-  child_ptr->SetTransform(identity);
+  child_ptr->SetTransform(gfx::Transform());
 
   child_ptr->test_properties()->hide_layer_and_subtree = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   child_ptr->test_properties()->hide_layer_and_subtree = false;
 
   child_ptr->OnOpacityAnimated(0.f);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   child_ptr->test_properties()->opacity = 1.f;
 
   root_ptr->SetTransform(singular);
   // Force transform tree to have a node for child, so that ancestor's
   // invertible transform can be tested.
   child_ptr->SetTransform(rotate);
   host_impl.active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
-  root_ptr->SetTransform(identity);
-  child_ptr->SetTransform(identity);
+  root_ptr->SetTransform(gfx::Transform());
+  child_ptr->SetTransform(gfx::Transform());
 
   root_ptr->test_properties()->opacity = 0.f;
   child_ptr->test_properties()->opacity = 0.7f;
   host_impl.active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   root_ptr->test_properties()->opacity = 1.f;
 
   child_ptr->test_properties()->opacity = 0.f;
   // Now, even though child has zero opacity, we will configure |grandchild| and
   // |greatgrandchild| in several ways that should force the subtree to be
   // processed anyhow.
   grandchild_ptr->test_properties()->copy_requests.push_back(
       CopyOutputRequest::CreateEmptyRequest());
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   host_impl.active_tree()->property_trees()->effect_tree.ClearCopyRequests();
   child_ptr->test_properties()->opacity = 1.f;
 
   // A double sided render surface with backface visible should not be skipped
   grandchild_ptr->set_visible_layer_rect(gfx::Rect());
   child_ptr->SetHasRenderSurface(true);
   child_ptr->test_properties()->double_sided = true;
   child_ptr->SetTransform(rotate_back_and_translate);
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
-  child_ptr->SetTransform(identity);
+  child_ptr->SetTransform(gfx::Transform());
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve(
       KeyframedTransformAnimationCurve::Create());
   TransformOperations start;
   start.AppendTranslate(1.f, 2.f, 3.f);
   gfx::Transform transform;
   transform.Scale3d(1.0, 2.0, 3.0);
   TransformOperations operation;
   operation.AppendMatrix(transform);
   curve->AddKeyframe(
@@ skipping 19 matching lines @@
 
   host_impl.active_tree()->animation_host()->UnregisterPlayerForElement(
       root_ptr->element_id(), player.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerSkippingInSubtreeOfSingularTransform) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
-  gfx::Transform identity;
-  SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(10, 10), true, false, true);
-  SetLayerPropertiesForTesting(child, identity, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(10, 10), true, false, false);
-  SetLayerPropertiesForTesting(grand_child, identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
   SetElementIdsForTesting();
 
   gfx::Transform singular;
   singular.matrix().set(0, 0, 0);
   singular.matrix().set(0, 1, 1);
 
+  root->SetBounds(gfx::Size(10, 10));
   child->SetTransform(singular);
+  child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
+  grand_child->SetBounds(gfx::Size(10, 10));
   grand_child->SetDrawsContent(true);
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve(
       KeyframedTransformAnimationCurve::Create());
   TransformOperations start;
   start.AppendTranslate(1.f, 2.f, 3.f);
   gfx::Transform transform;
   transform.Scale3d(1.0, 2.0, 3.0);
   TransformOperations operation;
   operation.AppendMatrix(transform);
@@ skipping 20 matching lines @@
       grand_child->element_id(), player.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingPendingLayerImpl) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
 
-  gfx::Transform identity;
   host_impl.CreatePendingTree();
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.pending_tree(), 1);
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl.pending_tree(), 2);
   std::unique_ptr<LayerImpl> grandchild =
       LayerImpl::Create(host_impl.pending_tree(), 3);
 
   std::unique_ptr<FakePictureLayerImpl> greatgrandchild(
       FakePictureLayerImpl::Create(host_impl.pending_tree(), 4));
 
+  root->SetBounds(gfx::Size(100, 100));
+  child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
+  grandchild->SetBounds(gfx::Size(10, 10));
   grandchild->SetDrawsContent(true);
   greatgrandchild->SetDrawsContent(true);
 
-  SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-  SetLayerPropertiesForTesting(grandchild.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-
   LayerImpl* root_ptr = root.get();
   LayerImpl* grandchild_ptr = grandchild.get();
 
   child->test_properties()->AddChild(std::move(grandchild));
   root->test_properties()->AddChild(std::move(child));
 
   host_impl.pending_tree()->SetRootLayerForTesting(std::move(root));
   host_impl.pending_tree()->SetElementIdsForTesting();
 
   // Check the non-skipped case.
@@ skipping 22 matching lines @@
   grandchild_ptr->set_visible_layer_rect(gfx::Rect());
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   host_impl.active_tree()->animation_host()->UnregisterPlayerForElement(
       root_ptr->element_id(), player.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingLayer) {
-  gfx::Transform identity;
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
 
-  SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false, true);
-  SetLayerPropertiesForTesting(child, identity, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(10, 10), true, false, false);
+  root->SetBounds(gfx::Size(100, 100));
+  child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(10, 10), child->visible_layer_rect());
   child->set_visible_layer_rect(gfx::Rect());
 
   child->test_properties()->hide_layer_and_subtree = true;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
   child->test_properties()->hide_layer_and_subtree = false;
 
   child->SetBounds(gfx::Size());
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
   child->SetBounds(gfx::Size(10, 10));
 
   gfx::Transform rotate;
   child->test_properties()->double_sided = false;
   rotate.RotateAboutXAxis(180.f);
   child->SetTransform(rotate);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
   child->test_properties()->double_sided = true;
-  child->SetTransform(identity);
+  child->SetTransform(gfx::Transform());
 
   child->test_properties()->opacity = 0.f;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerTreeRebuildTest) {
   // Ensure that the treewalk in LayerTreeHostCommom::
   // PreCalculateMetaInformation happens when its required.
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
 
+  root->SetBounds(gfx::Size(100, 100));
+  parent->SetBounds(gfx::Size(100, 100));
+  child->SetBounds(gfx::Size(100, 100));
+  child->SetClipParent(root.get());
+
   root->AddChild(parent);
   parent->AddChild(child);
-
-  child->SetClipParent(root.get());
-
-  gfx::Transform identity;
-
-  SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(parent.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(child.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-
   host()->SetRootLayer(root);
 
   child->RequestCopyOfOutput(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(parent->num_unclipped_descendants(), 1u);
 
   EXPECT_GT(root->num_copy_requests_in_target_subtree(), 0);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_GT(root->num_copy_requests_in_target_subtree(), 0);
 }
 
 TEST_F(LayerTreeHostCommonTest, ResetPropertyTreeIndices) {
-  gfx::Transform identity;
+  scoped_refptr<Layer> root = Layer::Create();
+  root->SetBounds(gfx::Size(800, 800));
+
   gfx::Transform translate_z;
   translate_z.Translate3d(0, 0, 10);
 
-  scoped_refptr<Layer> root = Layer::Create();
-  SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(800, 800), true, false);
-
   scoped_refptr<Layer> child = Layer::Create();
-  SetLayerPropertiesForTesting(child.get(), translate_z, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
+  child->SetTransform(translate_z);
+  child->SetBounds(gfx::Size(100, 100));
 
   root->AddChild(child);
 
   host()->SetRootLayer(root);
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_NE(-1, child->transform_tree_index());
 
   child->RemoveFromParent();
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(-1, child->transform_tree_index());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceClipsSubtree) {
   // Ensure that a Clip Node is added when a render surface applies clip.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* significant_transform = AddChildToRoot<LayerImpl>();
   LayerImpl* layer_clips_subtree = AddChild<LayerImpl>(significant_transform);
   LayerImpl* render_surface = AddChild<LayerImpl>(layer_clips_subtree);
   LayerImpl* test_layer = AddChild<LayerImpl>(render_surface);
 
-  const gfx::Transform identity_matrix;
   // This transform should be a significant one so that a transform node is
   // formed for it.
   gfx::Transform transform1;
   transform1.RotateAboutYAxis(45);
   transform1.RotateAboutXAxis(30);
   // This transform should be a 3d transform as we want the render surface
   // to flatten the transform
   gfx::Transform transform2;
   transform2.Translate3d(10, 10, 10);
 
+  root->SetBounds(gfx::Size(30, 30));
+  significant_transform->SetTransform(transform1);
+  significant_transform->SetBounds(gfx::Size(30, 30));
+  layer_clips_subtree->SetBounds(gfx::Size(30, 30));
   layer_clips_subtree->SetMasksToBounds(true);
+  layer_clips_subtree->test_properties()->force_render_surface = true;
+  render_surface->SetTransform(transform2);
+  render_surface->SetBounds(gfx::Size(30, 30));
+  render_surface->test_properties()->force_render_surface = true;
+  test_layer->SetBounds(gfx::Size(30, 30));
   test_layer->SetDrawsContent(true);
 
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false);
-  SetLayerPropertiesForTesting(significant_transform, transform1,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               true, false);
-  SetLayerPropertiesForTesting(layer_clips_subtree, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               true, false);
-  SetLayerPropertiesForTesting(render_surface, transform2, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false);
-  SetLayerPropertiesForTesting(test_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false);
-
-  root->test_properties()->force_render_surface = true;
-  significant_transform->test_properties()->force_render_surface = false;
-  layer_clips_subtree->test_properties()->force_render_surface = true;
-  render_surface->test_properties()->force_render_surface = true;
-  test_layer->test_properties()->force_render_surface = false;
   ExecuteCalculateDrawProperties(root);
 
   TransformTree& transform_tree =
       root->layer_tree_impl()->property_trees()->transform_tree;
   TransformNode* transform_node =
       transform_tree.Node(significant_transform->transform_tree_index());
   EXPECT_EQ(transform_node->owner_id, significant_transform->id());
 
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_FALSE(significant_transform->has_render_surface());
   EXPECT_TRUE(layer_clips_subtree->has_render_surface());
   EXPECT_TRUE(render_surface->has_render_surface());
   EXPECT_FALSE(test_layer->has_render_surface());
 
   ClipTree& clip_tree = root->layer_tree_impl()->property_trees()->clip_tree;
   ClipNode* clip_node = clip_tree.Node(render_surface->clip_tree_index());
   EXPECT_FALSE(clip_node->applies_local_clip);
   EXPECT_EQ(gfx::Rect(20, 20), test_layer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformOfParentClipNodeAncestorOfTarget) {
   // Ensure that when parent clip node's transform is an ancestor of current
   // clip node's target, clip is 'projected' from parent space to current
   // target space and visible rects are calculated correctly.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_layer = AddChild<LayerImpl>(root);
   LayerImpl* target_layer = AddChild<LayerImpl>(clip_layer);
   LayerImpl* test_layer = AddChild<LayerImpl>(target_layer);
 
-  const gfx::Transform identity_matrix;
   gfx::Transform transform;
   transform.RotateAboutYAxis(45);
+
+  root->SetBounds(gfx::Size(30, 30));
+  clip_layer->SetTransform(transform);
+  clip_layer->SetBounds(gfx::Size(30, 30));
   clip_layer->SetMasksToBounds(true);
+  target_layer->SetTransform(transform);
+  target_layer->SetBounds(gfx::Size(30, 30));
   target_layer->SetMasksToBounds(true);
+  test_layer->SetBounds(gfx::Size(30, 30));
   test_layer->SetDrawsContent(true);
 
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_layer, transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               false);
-  SetLayerPropertiesForTesting(target_layer, transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
-  SetLayerPropertiesForTesting(test_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               false);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(30, 30), test_layer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceWithUnclippedDescendantsClipsSubtree) {
   // Ensure clip rect is calculated correctly when render surface has unclipped
   // descendants.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* between_clip_parent_and_child = AddChild<LayerImpl>(clip_parent);
   LayerImpl* render_surface =
       AddChild<LayerImpl>(between_clip_parent_and_child);
   LayerImpl* test_layer = AddChild<LayerImpl>(render_surface);
 
-  const gfx::Transform identity_matrix;
   gfx::Transform translate;
   translate.Translate(2.0, 2.0);
 
+  root->SetBounds(gfx::Size(30, 30));
+  clip_parent->SetTransform(translate);
+  clip_parent->SetBounds(gfx::Size(30, 30));
   clip_parent->SetMasksToBounds(true);
+  between_clip_parent_and_child->SetTransform(translate);
+  between_clip_parent_and_child->SetBounds(gfx::Size(30, 30));
+  render_surface->SetBounds(gfx::Size(30, 30));
+  render_surface->test_properties()->force_render_surface = true;
+  test_layer->SetBounds(gfx::Size(30, 30));
   test_layer->SetDrawsContent(true);
+
   render_surface->test_properties()->clip_parent = clip_parent;
-  std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
-  clip_children->insert(render_surface);
-  clip_parent->test_properties()->clip_children.reset(clip_children.release());
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_parent, translate, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               false);
-  SetLayerPropertiesForTesting(between_clip_parent_and_child, translate,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               true, false, false);
-  SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
-  SetLayerPropertiesForTesting(test_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               false);
+  clip_parent->test_properties()->clip_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  clip_parent->test_properties()->clip_children->insert(render_surface);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(test_layer->is_clipped());
   EXPECT_FALSE(test_layer->render_target()->is_clipped());
   EXPECT_EQ(gfx::Rect(-2, -2, 30, 30), test_layer->clip_rect());
   EXPECT_EQ(gfx::Rect(28, 28), test_layer->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceWithUnclippedDescendantsButDoesntApplyOwnClip) {
   // Ensure that the visible layer rect of a descendant of a surface with
   // unclipped descendants is computed correctly, when the surface doesn't apply
   // a clip.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface);
   LayerImpl* child = AddChild<LayerImpl>(render_surface);
 
-  const gfx::Transform identity_matrix;
+  root->SetBounds(gfx::Size(30, 10));
+  clip_parent->SetBounds(gfx::Size(30, 30));
+  render_surface->SetBounds(gfx::Size(10, 15));
+  render_surface->test_properties()->force_render_surface = true;
+  clip_child->SetBounds(gfx::Size(10, 10));
+  clip_child->SetDrawsContent(true);
+  child->SetBounds(gfx::Size(40, 40));
+  child->SetDrawsContent(true);
 
-  clip_child->SetDrawsContent(true);
-  child->SetDrawsContent(true);
   clip_child->test_properties()->clip_parent = clip_parent;
-  std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
-  clip_children->insert(clip_child);
-  clip_parent->test_properties()->clip_children.reset(clip_children.release());
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 10), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               false);
-  SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 15), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(40, 40), true, false,
-                               false);
+  clip_parent->test_properties()->clip_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(40, 40), child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceClipsSubtreeAndHasUnclippedDescendants) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* test_layer1 = AddChild<LayerImpl>(render_surface);
   LayerImpl* clip_child = AddChild<LayerImpl>(test_layer1);
   LayerImpl* test_layer2 = AddChild<LayerImpl>(clip_child);
 
-  const gfx::Transform identity_matrix;
+  root->SetBounds(gfx::Size(30, 30));
   root->SetMasksToBounds(true);
+  clip_parent->SetBounds(gfx::Size(30, 30));
+  render_surface->SetBounds(gfx::Size(50, 50));
   render_surface->SetMasksToBounds(true);
   render_surface->SetDrawsContent(true);
+  render_surface->test_properties()->force_render_surface = true;
+  test_layer1->SetBounds(gfx::Size(50, 50));
+  test_layer1->SetDrawsContent(true);
+  clip_child->SetBounds(gfx::Size(50, 50));
   clip_child->SetDrawsContent(true);
-  test_layer1->SetDrawsContent(true);
+  test_layer2->SetBounds(gfx::Size(50, 50));
   test_layer2->SetDrawsContent(true);
+
   clip_child->test_properties()->clip_parent = clip_parent;
-  std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
-  clip_children->insert(clip_child);
-  clip_parent->test_properties()->clip_children.reset(clip_children.release());
-
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               false);
-  SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(test_layer1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
-  SetLayerPropertiesForTesting(clip_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
-  SetLayerPropertiesForTesting(test_layer2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
+  clip_parent->test_properties()->clip_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(30, 30), render_surface->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(30, 30), test_layer1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(30, 30), clip_child->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(30, 30), test_layer2->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, UnclippedClipParent) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface);
 
-  const gfx::Transform identity_matrix;
+  root->SetBounds(gfx::Size(50, 50));
+  clip_parent->SetBounds(gfx::Size(50, 50));
   clip_parent->SetDrawsContent(true);
+  render_surface->SetBounds(gfx::Size(30, 30));
+  render_surface->test_properties()->force_render_surface = true;
   render_surface->SetMasksToBounds(true);
   render_surface->SetDrawsContent(true);
+  clip_child->SetBounds(gfx::Size(50, 50));
   clip_child->SetDrawsContent(true);
 
   clip_child->test_properties()->clip_parent = clip_parent;
-  std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
-  clip_children->insert(clip_child);
-  clip_parent->test_properties()->clip_children.reset(clip_children.release());
-
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
-  SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
+  clip_parent->test_properties()->clip_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
 
   // The clip child should inherit its clip parent's clipping state, not its
   // tree parent's clipping state.
   EXPECT_FALSE(clip_parent->is_clipped());
   EXPECT_TRUE(render_surface->is_clipped());
   EXPECT_FALSE(clip_child->is_clipped());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceContentRectWithMultipleSurfaces) {
   // Tests the value of render surface content rect when we have multiple types
   // of surfaces : unclipped surfaces, surfaces with unclipped surfaces and
   // clipped surfaces.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* unclipped_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* clip_parent = AddChild<LayerImpl>(unclipped_surface);
   LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* unclipped_desc_surface2 =
       AddChild<LayerImpl>(unclipped_desc_surface);
   LayerImpl* clip_child = AddChild<LayerImpl>(unclipped_desc_surface2);
   LayerImpl* clipped_surface = AddChild<LayerImpl>(clip_child);
 
+  root->SetBounds(gfx::Size(80, 80));
+  unclipped_surface->SetBounds(gfx::Size(50, 50));
+  unclipped_surface->SetMasksToBounds(true);
   unclipped_surface->SetDrawsContent(true);
+  unclipped_surface->test_properties()->force_render_surface = true;
+  clip_parent->SetBounds(gfx::Size(50, 50));
+  clip_parent->SetMasksToBounds(true);
+  unclipped_desc_surface->SetBounds(gfx::Size(100, 100));
+  unclipped_desc_surface->SetMasksToBounds(true);
   unclipped_desc_surface->SetDrawsContent(true);
+  unclipped_desc_surface->test_properties()->force_render_surface = true;
+  unclipped_desc_surface2->SetBounds(gfx::Size(60, 60));
   unclipped_desc_surface2->SetDrawsContent(true);
+  unclipped_desc_surface2->test_properties()->force_render_surface = true;
+  clip_child->SetBounds(gfx::Size(100, 100));
+  clipped_surface->SetBounds(gfx::Size(70, 70));
   clipped_surface->SetDrawsContent(true);
+  clipped_surface->test_properties()->force_render_surface = true;
+
   clip_child->test_properties()->clip_parent = clip_parent;
-  std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
-  clip_children->insert(clip_child);
-  clip_parent->test_properties()->clip_children.reset(clip_children.release());
-
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(80, 80), true, false,
-                               true);
-  SetLayerPropertiesForTesting(unclipped_surface, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
-                               true, false, true);
-  SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
-  SetLayerPropertiesForTesting(unclipped_desc_surface, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false, true);
-  SetLayerPropertiesForTesting(unclipped_desc_surface2, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(60, 60),
-                               true, false, true);
-  SetLayerPropertiesForTesting(clip_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-  SetLayerPropertiesForTesting(clipped_surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(70, 70), true, false,
-                               true);
-  clip_parent->SetMasksToBounds(true);
-  unclipped_surface->SetMasksToBounds(true);
-  unclipped_desc_surface->SetMasksToBounds(true);
+  clip_parent->test_properties()->clip_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(50, 50),
             unclipped_surface->render_surface()->content_rect());
   EXPECT_EQ(gfx::Rect(50, 50),
             unclipped_desc_surface->render_surface()->content_rect());
   EXPECT_EQ(gfx::Rect(50, 50),
             unclipped_desc_surface2->render_surface()->content_rect());
   EXPECT_EQ(gfx::Rect(50, 50),
             clipped_surface->render_surface()->content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipBetweenClipChildTargetAndClipParentTarget) {
   // Tests the value of render surface content rect when we have a layer that
   // clips between the clip parent's target and clip child's target.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* surface = AddChildToRoot<LayerImpl>();
   LayerImpl* clip_layer = AddChild<LayerImpl>(surface);
   LayerImpl* clip_parent = AddChild<LayerImpl>(clip_layer);
   LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(unclipped_desc_surface);
 
-  clip_child->SetDrawsContent(true);
-  unclipped_desc_surface->SetDrawsContent(true);
-  clip_child->test_properties()->clip_parent = clip_parent;
-  std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
-  clip_children->insert(clip_child);
-  clip_parent->test_properties()->clip_children.reset(clip_children.release());
-
-  gfx::Transform identity_matrix;
   gfx::Transform translate;
   translate.Translate(10, 10);
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false,
-                               false);
-  SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
-  SetLayerPropertiesForTesting(unclipped_desc_surface, translate,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false, true);
-  SetLayerPropertiesForTesting(clip_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
+
+  root->SetBounds(gfx::Size(100, 100));
+  surface->SetBounds(gfx::Size(100, 100));
   surface->SetMasksToBounds(true);
+  surface->test_properties()->force_render_surface = true;
+  clip_layer->SetBounds(gfx::Size(20, 20));
   clip_layer->SetMasksToBounds(true);
+  clip_parent->SetBounds(gfx::Size(50, 50));
+  unclipped_desc_surface->SetTransform(translate);
+  unclipped_desc_surface->SetBounds(gfx::Size(100, 100));
+  unclipped_desc_surface->SetDrawsContent(true);
+  unclipped_desc_surface->test_properties()->force_render_surface = true;
+  clip_child->SetBounds(gfx::Size(100, 100));
+  clip_child->SetDrawsContent(true);
+
+  clip_child->test_properties()->clip_parent = clip_parent;
+  clip_parent->test_properties()->clip_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(10, 10),
             unclipped_desc_surface->render_surface()->content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleRectForDescendantOfScaledSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* surface = AddChildToRoot<LayerImpl>();
   LayerImpl* clip_layer = AddChild<LayerImpl>(surface);
   LayerImpl* clip_parent = AddChild<LayerImpl>(clip_layer);
   LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(unclipped_desc_surface);
 
-  clip_child->SetDrawsContent(true);
-  unclipped_desc_surface->SetDrawsContent(true);
-  clip_child->test_properties()->clip_parent = clip_parent;
-  std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
-  clip_children->insert(clip_child);
-  clip_parent->test_properties()->clip_children.reset(clip_children.release());
 
-  gfx::Transform identity_matrix;
   gfx::Transform scale;
   scale.Scale(2, 2);
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(surface, scale, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false, true);
-  SetLayerPropertiesForTesting(clip_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false,
-                               false);
-  SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
-  SetLayerPropertiesForTesting(unclipped_desc_surface, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false, true);
-  SetLayerPropertiesForTesting(clip_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
+
+  root->SetBounds(gfx::Size(100, 100));
+  surface->SetTransform(scale);
+  surface->SetBounds(gfx::Size(100, 100));
   surface->SetMasksToBounds(true);
+  surface->test_properties()->force_render_surface = true;
+  clip_layer->SetBounds(gfx::Size(20, 20));
   clip_layer->SetMasksToBounds(true);
+  clip_parent->SetBounds(gfx::Size(50, 50));
+  unclipped_desc_surface->SetBounds(gfx::Size(100, 100));
+  unclipped_desc_surface->SetDrawsContent(true);
+  unclipped_desc_surface->test_properties()->force_render_surface = true;
+  clip_child->SetBounds(gfx::Size(100, 100));
+  clip_child->SetDrawsContent(true);
+
+  clip_child->test_properties()->clip_parent = clip_parent;
+  clip_parent->test_properties()->clip_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(20, 20), clip_child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerWithInputHandlerAndZeroOpacity) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChild<LayerImpl>(root);
   LayerImpl* test_layer = AddChild<LayerImpl>(render_surface);
 
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
-  SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
   gfx::Transform translation;
   translation.Translate(10, 10);
-  SetLayerPropertiesForTesting(test_layer, translation, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false,
-                               false);
 
+  root->SetBounds(gfx::Size(30, 30));
+  render_surface->SetBounds(gfx::Size(30, 30));
   render_surface->SetMasksToBounds(true);
+  render_surface->test_properties()->force_render_surface = true;
+  test_layer->SetTransform(translation);
+  test_layer->SetBounds(gfx::Size(20, 20));
   test_layer->SetDrawsContent(true);
+  test_layer->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 20, 20));
   test_layer->test_properties()->opacity = 0.f;
-  test_layer->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 20, 20));
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(translation,
                                   test_layer->ScreenSpaceTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipChildVisibleRect) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface);
 
-  const gfx::Transform identity_matrix;
+  root->SetBounds(gfx::Size(30, 30));
+  clip_parent->SetBounds(gfx::Size(40, 40));
   clip_parent->SetMasksToBounds(true);
+  render_surface->SetBounds(gfx::Size(50, 50));
   render_surface->SetMasksToBounds(true);
   render_surface->SetDrawsContent(true);
+  render_surface->test_properties()->force_render_surface = true;
+  clip_child->SetBounds(gfx::Size(50, 50));
   clip_child->SetDrawsContent(true);
+
   clip_child->test_properties()->clip_parent = clip_parent;
-  std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
-  clip_children->insert(clip_child);
-  clip_parent->test_properties()->clip_children.reset(clip_children.release());
-
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(10.f, 10.f), gfx::Size(40, 40), true,
-                               false, false);
-  SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
+  clip_parent->test_properties()->clip_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(40, 40), clip_child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        LayerClipRectLargerThanClippingRenderSurfaceRect) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChild<LayerImpl>(root);
   LayerImpl* test_layer = AddChild<LayerImpl>(render_surface);
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
-  SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(test_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
+
+  root->SetBounds(gfx::Size(30, 30));
   root->SetMasksToBounds(true);
   root->SetDrawsContent(true);
+  render_surface->SetBounds(gfx::Size(50, 50));
   render_surface->SetMasksToBounds(true);
   render_surface->SetDrawsContent(true);
+  render_surface->test_properties()->force_render_surface = true;
+  test_layer->SetBounds(gfx::Size(50, 50));
   test_layer->SetMasksToBounds(true);
   test_layer->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(30, 30), root->clip_rect());
   EXPECT_EQ(gfx::Rect(50, 50), render_surface->clip_rect());
   EXPECT_EQ(gfx::Rect(50, 50), test_layer->clip_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, SubtreeIsHiddenTest) {
   // Tests that subtree is hidden is updated.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* hidden = AddChild<LayerImpl>(root);
   LayerImpl* test = AddChild<LayerImpl>(hidden);
 
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
-  SetLayerPropertiesForTesting(hidden, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(10, 10), gfx::Size(30, 30), true,
-                               false, true);
-  SetLayerPropertiesForTesting(test, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
+  root->SetBounds(gfx::Size(30, 30));
+  hidden->SetBounds(gfx::Size(30, 30));
+  hidden->test_properties()->force_render_surface = true;
+  hidden->test_properties()->hide_layer_and_subtree = true;
+  test->SetBounds(gfx::Size(30, 30));
+  test->test_properties()->force_render_surface = true;
 
-  hidden->test_properties()->hide_layer_and_subtree = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRUE(test->IsHidden());
 
   hidden->test_properties()->hide_layer_and_subtree = false;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(test->IsHidden());
 }
 
 TEST_F(LayerTreeHostCommonTest, TwoUnclippedRenderSurfaces) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface2);
 
-  const gfx::Transform identity_matrix;
+  root->SetBounds(gfx::Size(30, 30));
+  root->SetMasksToBounds(true);
+  render_surface1->SetPosition(gfx::PointF(10, 10));
+  render_surface1->SetBounds(gfx::Size(30, 30));
+  render_surface1->SetDrawsContent(true);
+  render_surface1->test_properties()->force_render_surface = true;
+  render_surface2->SetBounds(gfx::Size(30, 30));
+  render_surface2->SetDrawsContent(true);
+  render_surface2->test_properties()->force_render_surface = true;
+  clip_child->SetBounds(gfx::Size(30, 30));
+
   clip_child->test_properties()->clip_parent = root;
-  std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
-  clip_children->insert(clip_child);
-  root->test_properties()->clip_children.reset(clip_children.release());
-  root->SetMasksToBounds(true);
-  render_surface1->SetDrawsContent(true);
-  render_surface2->SetDrawsContent(true);
+  root->test_properties()->clip_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  root->test_properties()->clip_children->insert(clip_child);
 
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
-  SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(10, 10), gfx::Size(30, 30), true,
-                               false, true);
-  SetLayerPropertiesForTesting(render_surface2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               false);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(-10, -10, 30, 30), render_surface2->clip_rect());
   // A clip node is created for every render surface and for layers that have
   // local clip. So, here it should be craeted for every layer.
   EXPECT_EQ(root->layer_tree_impl()->property_trees()->clip_tree.size(), 5u);
 }
 
 TEST_F(LayerTreeHostCommonTest, MaskLayerDrawProperties) {
   // Tests that a mask layer's draw properties are computed correctly.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   child->test_properties()->SetMaskLayer(
       LayerImpl::Create(root->layer_tree_impl(), 100));
   LayerImpl* mask = child->test_properties()->mask_layer;
 
-  const gfx::Transform identity_matrix;
   gfx::Transform transform;
   transform.Translate(10, 10);
 
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(40, 40), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, transform, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(30, 30), true, false, false);
-  SetLayerPropertiesForTesting(mask, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false,
-                               false);
+  root->SetBounds(gfx::Size(40, 40));
   root->SetDrawsContent(true);
+  child->SetTransform(transform);
+  child->SetBounds(gfx::Size(30, 30));
   child->SetDrawsContent(false);
+  mask->SetBounds(gfx::Size(20, 20));
   ExecuteCalculateDrawProperties(root);
 
   // The render surface created for the mask has no contributing content, so the
   // mask isn't a drawn RSLL member. This means it has an empty visible rect,
   // but its screen space transform can still be computed correctly on-demand.
   EXPECT_FALSE(mask->is_drawn_render_surface_layer_list_member());
   EXPECT_EQ(gfx::Rect(), mask->visible_layer_rect());
   EXPECT_TRANSFORMATION_MATRIX_EQ(transform, mask->ScreenSpaceTransform());
 
   // Make the child's render surface have contributing content.
@@ skipping 17 matching lines @@
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   child->test_properties()->SetReplicaLayer(
       LayerImpl::Create(root->layer_tree_impl(), 100));
   LayerImpl* replica = child->test_properties()->replica_layer;
   replica->test_properties()->parent = child;
   replica->test_properties()->SetMaskLayer(
       LayerImpl::Create(root->layer_tree_impl(), 200));
   LayerImpl* replica_mask = replica->test_properties()->mask_layer;
 
-  const gfx::Transform identity_matrix;
   gfx::Transform transform;
   transform.Translate(10, 10);
 
   gfx::PointF replica_position(3.f, 3.f);
 
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(40, 40), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, transform, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(30, 30), true, false, false);
-  SetLayerPropertiesForTesting(replica, identity_matrix, gfx::Point3F(),
-                               replica_position, gfx::Size(30, 30), true, false,
-                               false);
-  SetLayerPropertiesForTesting(replica_mask, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false,
-                               false);
+  root->SetBounds(gfx::Size(40, 40));
   root->SetDrawsContent(true);
-  child->SetDrawsContent(false);
+  child->SetTransform(transform);
+  child->SetBounds(gfx::Size(30, 30));
+  replica->SetPosition(replica_position);
+  replica_mask->SetBounds(gfx::Size(20, 20));
+
   ExecuteCalculateDrawProperties(root);
 
   // The render surface created for the replica has no contributing content, so
   // the replica's mask isn't a drawn RSLL member. This means it has an empty
   // visible rect, but its screen space transform can still be computed
   // correctly on-demand.
   EXPECT_FALSE(replica_mask->is_drawn_render_surface_layer_list_member());
   EXPECT_EQ(gfx::Rect(), replica_mask->visible_layer_rect());
 
   gfx::Transform expected_screen_space_transform = transform;
@@ skipping 13 matching lines @@
                                   replica_mask->ScreenSpaceTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        SublayerScaleWithTransformNodeBetweenTwoTargets) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
   LayerImpl* between_targets = AddChild<LayerImpl>(render_surface1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(between_targets);
   LayerImpl* test_layer = AddChild<LayerImpl>(render_surface2);
-  const gfx::Transform identity_matrix;
-  test_layer->SetDrawsContent(true);
 
   gfx::Transform scale;
   scale.Scale(2.f, 2.f);
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
-  SetLayerPropertiesForTesting(render_surface1, scale, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
-  SetLayerPropertiesForTesting(between_targets, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               false);
-  SetLayerPropertiesForTesting(render_surface2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
-  SetLayerPropertiesForTesting(test_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               false);
+
+  root->SetBounds(gfx::Size(30, 30));
+  render_surface1->SetTransform(scale);
+  render_surface1->SetBounds(gfx::Size(30, 30));
+  render_surface1->test_properties()->force_render_surface = true;
+  between_targets->SetBounds(gfx::Size(30, 30));
+  render_surface2->SetBounds(gfx::Size(30, 30));
+  render_surface2->test_properties()->force_render_surface = true;
+  test_layer->SetBounds(gfx::Size(30, 30));
+  test_layer->SetDrawsContent(true);
+
   // We want layer between the two targets to create a clip node and transform
   // node but it shouldn't create a render surface.
   between_targets->SetMasksToBounds(true);
   between_targets->Set3dSortingContextId(2);
 
   ExecuteCalculateDrawProperties(root);
 
   TransformTree& tree =
       root->layer_tree_impl()->property_trees()->transform_tree;
   TransformNode* node = tree.Node(render_surface1->transform_tree_index());
   EXPECT_EQ(node->surface_contents_scale, gfx::Vector2dF(2.f, 2.f));
 
   node = tree.Node(between_targets->transform_tree_index());
   EXPECT_EQ(node->surface_contents_scale, gfx::Vector2dF(1.f, 1.f));
 
   node = tree.Node(render_surface2->transform_tree_index());
   EXPECT_EQ(node->surface_contents_scale, gfx::Vector2dF(2.f, 2.f));
 
   EXPECT_EQ(gfx::Rect(15, 15), test_layer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, LargeTransformTest) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(render_surface1);
 
-  const gfx::Transform identity_matrix;
   child->SetDrawsContent(true);
   child->SetMasksToBounds(true);
 
   gfx::Transform large_transform;
   large_transform.Scale(99999999999999999999.f, 99999999999999999999.f);
   large_transform.Scale(9999999999999999999.f, 9999999999999999999.f);
   EXPECT_TRUE(std::isinf(large_transform.matrix().get(0, 0)));
   EXPECT_TRUE(std::isinf(large_transform.matrix().get(1, 1)));
 
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
-  SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
+  root->SetBounds(gfx::Size(30, 30));
+  render_surface1->SetBounds(gfx::Size(30, 30));
+  render_surface1->test_properties()->force_render_surface = true;
+
   // TODO(sunxd): we make child have no render surface, because if the
   // child has one, the large transform applied to child will result in NaNs in
   // the draw_transform of the render_surface, thus make draw property updates
   // skip the child layer. We need further investigation into this to know
   // what exactly happens here.
-  SetLayerPropertiesForTesting(child, large_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               false);
+  child->SetTransform(large_transform);
+  child->SetBounds(gfx::Size(30, 30));
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::RectF(),
             render_surface1->render_surface()->DrawableContentRect());
 
   bool is_inf_or_nan = std::isinf(child->DrawTransform().matrix().get(0, 0)) ||
                        std::isnan(child->DrawTransform().matrix().get(0, 0));
   EXPECT_TRUE(is_inf_or_nan);
 
   is_inf_or_nan = std::isinf(child->DrawTransform().matrix().get(1, 1)) ||
                   std::isnan(child->DrawTransform().matrix().get(1, 1));
   EXPECT_TRUE(is_inf_or_nan);
 
   std::vector<LayerImpl*>* rsll = render_surface_layer_list_impl();
   bool root_in_rsll =
       std::find(rsll->begin(), rsll->end(), root) != rsll->end();
   EXPECT_TRUE(root_in_rsll);
 }
 
 TEST_F(LayerTreeHostCommonTest, PropertyTreesRebuildWithOpacityChanges) {
-  const gfx::Transform identity_matrix;
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(child);
-
   host()->SetRootLayer(root);
 
-  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false);
-
+  root->SetBounds(gfx::Size(100, 100));
+  child->SetBounds(gfx::Size(20, 20));
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
 
   // Changing the opacity from 1 to non-1 value should trigger rebuild of
   // property trees as a new effect node will be created.
   child->SetOpacity(0.5f);
   PropertyTrees* property_trees = host()->property_trees();
   EXPECT_TRUE(property_trees->needs_rebuild);
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_NE(property_trees->effect_id_to_index_map.find(child->id()),
@@ skipping 14 matching lines @@
   child->SetOpacity(1.f);
   property_trees = host()->property_trees();
   EXPECT_TRUE(property_trees->needs_rebuild);
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(property_trees->effect_id_to_index_map.find(child->id()),
             property_trees->effect_id_to_index_map.end());
 }
 
 TEST_F(LayerTreeHostCommonTest, OpacityAnimationsTrackingTest) {
-  const gfx::Transform identity_matrix;
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> animated =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(animated);
-
   host()->SetRootLayer(root);
-
   host()->SetElementIdsForTesting();
 
-  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(animated.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false);
-
+  root->SetBounds(gfx::Size(100, 100));
   root->SetForceRenderSurfaceForTesting(true);
+  animated->SetBounds(gfx::Size(20, 20));
   animated->SetOpacity(0.f);
 
   scoped_refptr<AnimationPlayer> player =
       AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
   timeline()->AttachPlayer(player);
 
   player->AttachElement(animated->element_id());
 
   int animation_id = 0;
   std::unique_ptr<Animation> animation = Animation::Create(
@@ skipping 19 matching lines @@
   EXPECT_TRUE(node->is_currently_animating_opacity);
   EXPECT_TRUE(node->has_potential_opacity_animation);
 
   player->AbortAnimations(TargetProperty::OPACITY, false /*needs_completion*/);
   node = tree.Node(animated->effect_tree_index());
   EXPECT_FALSE(node->is_currently_animating_opacity);
   EXPECT_FALSE(node->has_potential_opacity_animation);
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformAnimationsTrackingTest) {
-  const gfx::Transform identity_matrix;
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> animated =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(animated);
-
   host()->SetRootLayer(root);
-
   host()->SetElementIdsForTesting();
 
-  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(animated.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false);
-
+  root->SetBounds(gfx::Size(100, 100));
   root->SetForceRenderSurfaceForTesting(true);
+  animated->SetBounds(gfx::Size(20, 20));
 
   scoped_refptr<AnimationPlayer> player =
       AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
   timeline()->AttachPlayer(player);
   player->AttachElement(animated->element_id());
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve(
       KeyframedTransformAnimationCurve::Create());
   TransformOperations start;
   start.AppendTranslate(1.f, 2.f, 3.f);
@@ skipping 259 matching lines @@
   EXPECT_EQ(scroll_child6.id, grand_child10->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent3->scroll_tree_index());
   EXPECT_EQ(scroll_child7.id, child8->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent4->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, child9->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, grand_child12->scroll_tree_index());
 }
 
 }  // namespace
 }  // namespace cc