cc: Use setter methods on layer instead of SetLayerPropertiesForTesting

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 110 matching lines @@
     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;
 
-    SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
-                                 gfx::Size(500, 500), true, false, true);
-    SetLayerPropertiesForTesting(target, identity, gfx::Point3F(),
-                                 gfx::PointF(target_rect.origin()),
-                                 target_rect.size(), true, false, true);
-    SetLayerPropertiesForTesting(drawing_layer, layer_transform, gfx::Point3F(),
-                                 gfx::PointF(layer_rect.origin()),
-                                 layer_rect.size(), true, false, false);
+    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;
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(), true, false);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(), true, false);
+  parent->SetBounds(gfx::Size(100, 100));
 
   ExecuteCalculateDrawProperties(parent);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
                                   child->ScreenSpaceTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
                                   grand_child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
                                   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;
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(10, 10), gfx::Size(100, 100), true,
-                               false);
+  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);
 
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1, 2), true, false);
-
   TransformTree& transform_tree =
       host_impl()->active_tree()->property_trees()->transform_tree;
   EffectTree& effect_tree =
       host_impl()->active_tree()->property_trees()->effect_tree;
 
-  // Case 2: Setting the bounds of the layer should not affect either the draw
+  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.
-  gfx::Transform translation_to_center;
-  translation_to_center.Translate(5.0, 6.0);
-  SetLayerPropertiesForTesting(layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 12), true, false);
+  layer->SetBounds(gfx::Size(10, 12));
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       identity_matrix,
       draw_property_utils::DrawTransform(layer, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       identity_matrix,
       draw_property_utils::ScreenSpaceTransform(layer, transform_tree));
 
-  // Case 3: The anchor point by itself (without a layer transform) should have
+  // Case 2: The anchor point by itself (without a layer transform) should have
   // no effect on the transforms.
-  SetLayerPropertiesForTesting(layer, identity_matrix,
-                               gfx::Point3F(2.5f, 3.0f, 0.f), gfx::PointF(),
-                               gfx::Size(10, 12), true, false);
+  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,
       draw_property_utils::DrawTransform(layer, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       identity_matrix,
       draw_property_utils::ScreenSpaceTransform(layer, transform_tree));
 
-  // Case 4: A change in actual position affects both the draw transform and
+  // 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);
-  SetLayerPropertiesForTesting(
-      layer, identity_matrix, gfx::Point3F(2.5f, 3.0f, 0.f),
-      gfx::PointF(0.f, 1.2f), gfx::Size(10, 12), true, false);
+  layer->SetPosition(gfx::PointF(0.f, 1.2f));
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       position_transform,
       draw_property_utils::DrawTransform(layer, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       position_transform,
       draw_property_utils::ScreenSpaceTransform(layer, transform_tree));
 
-  // Case 5: In the correct sequence of transforms, the layer transform should
-  // pre-multiply the translation_to_center. This is easily tested by using a
+  // Case 4: In the correct sequence of transforms, the layer transform should
+  // pre-multiply the translation-to-center. This is easily tested by using a
   // scale transform, because scale and translation are not commutative.
   gfx::Transform layer_transform;
   layer_transform.Scale3d(2.0, 2.0, 1.0);
-  SetLayerPropertiesForTesting(layer, layer_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 12), true, false);
+  layer->SetTransform(layer_transform);
+  layer->test_properties()->transform_origin = gfx::Point3F();
+  layer->SetPosition(gfx::PointF());
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       layer_transform,
       draw_property_utils::DrawTransform(layer, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       layer_transform,
       draw_property_utils::ScreenSpaceTransform(layer, transform_tree));
 
-  // Case 6: The layer transform should occur with respect to the anchor point.
+  // Case 5: The layer transform should occur with respect to the anchor point.
   gfx::Transform translation_to_anchor;
   translation_to_anchor.Translate(5.0, 0.0);
   gfx::Transform expected_result =
       translation_to_anchor * layer_transform * Inverse(translation_to_anchor);
-  SetLayerPropertiesForTesting(layer, layer_transform,
-                               gfx::Point3F(5.0f, 0.f, 0.f), gfx::PointF(),
-                               gfx::Size(10, 12), true, false);
+  layer->test_properties()->transform_origin = gfx::Point3F(5.f, 0.f, 0.f);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_result,
       draw_property_utils::DrawTransform(layer, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_result,
       draw_property_utils::ScreenSpaceTransform(layer, transform_tree));
 
-  // Case 7: Verify that position pre-multiplies the layer transform.  The
+  // Case 6: Verify that position pre-multiplies the layer transform.  The
   // current implementation of CalculateDrawProperties does this implicitly, but
   // it is still worth testing to detect accidental regressions.
   expected_result = position_transform * translation_to_anchor *
                     layer_transform * Inverse(translation_to_anchor);
-  SetLayerPropertiesForTesting(
-      layer, layer_transform, gfx::Point3F(5.0f, 0.f, 0.f),
-      gfx::PointF(0.f, 1.2f), gfx::Size(10, 12), true, false);
+  layer->SetPosition(gfx::PointF(0.f, 1.2f));
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_result,
       draw_property_utils::DrawTransform(layer, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_result,
       draw_property_utils::ScreenSpaceTransform(layer, transform_tree));
 }
 
@@ skipping 10 matching lines @@
   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);
-  SetLayerPropertiesForTesting(sublayer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(500, 500), true, false,
-                               false);
+  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();
-  SetLayerPropertiesForTesting(scroll_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 20), true, false,
-                               false);
+  scroll_layer->SetBounds(gfx::Size(10, 20));
   std::unique_ptr<LayerImpl> clip_layer_scoped_ptr(
       LayerImpl::Create(host_impl.active_tree(), 4));
   LayerImpl* clip_layer = clip_layer_scoped_ptr.get();
 
   scroll_layer->SetScrollClipLayer(clip_layer->id());
   clip_layer->SetBounds(
       gfx::Size(scroll_layer->bounds().width() + kMaxScrollOffset.x(),
                 scroll_layer->bounds().height() + kMaxScrollOffset.y()));
   scroll_layer->SetScrollClipLayer(clip_layer->id());
   SetScrollOffsetDelta(scroll_layer, kScrollDelta);
   gfx::Transform impl_transform;
   scroll_layer->test_properties()->AddChild(std::move(sublayer_scoped_ptr));
   LayerImpl* scroll_layer_raw_ptr = scroll_layer_scoped_ptr.get();
   clip_layer->test_properties()->AddChild(std::move(scroll_layer_scoped_ptr));
   scroll_layer_raw_ptr->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(scroll_layer_raw_ptr->id(),
                                                      kScrollOffset);
 
   std::unique_ptr<LayerImpl> root(
       LayerImpl::Create(host_impl.active_tree(), 3));
-  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(3, 4), true, false,
-                               false);
+  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::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,
                                   sublayer->ScreenSpaceTransform());
 
   gfx::Transform arbitrary_translate;
   const float kTranslateX = 10.6f;
   const float kTranslateY = 20.6f;
   arbitrary_translate.Translate(kTranslateX, kTranslateY);
-  SetLayerPropertiesForTesting(scroll_layer, arbitrary_translate,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(10, 20),
-                               true, false, false);
+  scroll_layer->SetTransform(arbitrary_translate);
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_layer, kDeviceScale, page_scale,
                                  scroll_layer->test_properties()->parent);
   expected_transform.MakeIdentity();
   expected_transform.Translate(
       MathUtil::Round(kTranslateX * page_scale * kDeviceScale +
                       sub_layer_screen_position.x() * page_scale *
                           kDeviceScale),
       MathUtil::Round(kTranslateY * page_scale * kDeviceScale +
                       sub_layer_screen_position.y() * page_scale *
@@ skipping 28 matching lines @@
 }
 
 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
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1, 2), true, false);
+  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.
-  SetLayerPropertiesForTesting(parent, identity_matrix,
-                               gfx::Point3F(2.5f, 3.0f, 0.f), gfx::PointF(),
-                               gfx::Size(10, 12), true, false);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(16, 18), true, false);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(76, 78), true, false);
+  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,
       draw_property_utils::DrawTransform(child, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       identity_matrix,
       draw_property_utils::ScreenSpaceTransform(child, transform_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       identity_matrix, draw_property_utils::DrawTransform(
                            grand_child, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       identity_matrix,
       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);
-  SetLayerPropertiesForTesting(
-      parent, identity_matrix, gfx::Point3F(2.5f, 3.0f, 0.f),
-      gfx::PointF(0.f, 1.2f), gfx::Size(10, 12), true, false);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(16, 18), true, false);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(76, 78), true, false);
+  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,
       draw_property_utils::DrawTransform(child, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_position_transform,
       draw_property_utils::ScreenSpaceTransform(child, transform_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_position_transform, draw_property_utils::DrawTransform(
                                      grand_child, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_position_transform,
       draw_property_utils::ScreenSpaceTransform(grand_child, transform_tree));
 
   // Case 3: parent's local transform affects child and grandchild
   gfx::Transform parent_layer_transform;
   parent_layer_transform.Scale3d(2.0, 2.0, 1.0);
   gfx::Transform parent_translation_to_anchor;
   parent_translation_to_anchor.Translate(2.5, 3.0);
   gfx::Transform parent_composite_transform =
       parent_translation_to_anchor * parent_layer_transform *
       Inverse(parent_translation_to_anchor);
-  SetLayerPropertiesForTesting(parent, parent_layer_transform,
-                               gfx::Point3F(2.5f, 3.0f, 0.f), gfx::PointF(),
-                               gfx::Size(10, 12), true, false);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(16, 18), true, false);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(76, 78), true, false);
+  parent->SetTransform(parent_layer_transform);
+  parent->SetPosition(gfx::PointF());
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_composite_transform,
       draw_property_utils::DrawTransform(child, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_composite_transform,
       draw_property_utils::ScreenSpaceTransform(child, transform_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_composite_transform,
       draw_property_utils::DrawTransform(grand_child, transform_tree,
                                          effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_composite_transform,
       draw_property_utils::ScreenSpaceTransform(grand_child, transform_tree));
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForSingleRenderSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
-  grand_child->SetDrawsContent(true);
-
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1, 2), true, false,
-                               true);
-
-  // Child is set up so that a new render surface should be created.
-  child->test_properties()->opacity = 0.5f;
-  child->SetDrawsContent(true);
 
   gfx::Transform parent_layer_transform;
   parent_layer_transform.Scale3d(1.f, 0.9f, 1.f);
   gfx::Transform parent_translation_to_anchor;
   parent_translation_to_anchor.Translate(25.0, 30.0);
 
   gfx::Transform parent_composite_transform =
       parent_translation_to_anchor * parent_layer_transform *
       Inverse(parent_translation_to_anchor);
   gfx::Vector2dF parent_composite_scale =
       MathUtil::ComputeTransform2dScaleComponents(parent_composite_transform,
                                                   1.f);
   gfx::Transform surface_sublayer_transform;
   surface_sublayer_transform.Scale(parent_composite_scale.x(),
                                    parent_composite_scale.y());
   gfx::Transform surface_sublayer_composite_transform =
       parent_composite_transform * Inverse(surface_sublayer_transform);
 
-  SetLayerPropertiesForTesting(parent, parent_layer_transform,
-                               gfx::Point3F(25.0f, 30.0f, 0.f), gfx::PointF(),
-                               gfx::Size(100, 120), true, false, false);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(16, 18), true, false,
-                               true);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(8, 10), true, false,
-                               false);
+  root->SetBounds(gfx::Size(1, 2));
+  parent->SetTransform(parent_layer_transform);
+  parent->test_properties()->transform_origin = gfx::Point3F(2.5f, 30.f, 0.f);
+  parent->SetBounds(gfx::Size(100, 120));
+  child->SetBounds(gfx::Size(16, 18));
+  child->test_properties()->force_render_surface = true;
+  grand_child->SetBounds(gfx::Size(8, 10));
+  grand_child->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
   // Render surface should have been created now.
   ASSERT_TRUE(child->render_surface());
   ASSERT_EQ(child->render_surface(), child->render_target());
 
   // The child layer's draw transform should refer to its new render surface.
   // The screen-space transform, however, should still refer to the root.
   EXPECT_TRANSFORMATION_MATRIX_EQ(surface_sublayer_transform,
                                   child->DrawTransform());
@@ skipping 11 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       surface_sublayer_composite_transform,
       child->render_target()->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsWhenCannotRenderToSeparateSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
-  grand_child->SetDrawsContent(true);
-
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
 
   gfx::Transform parent_transform;
   parent_transform.Translate(10.0, 10.0);
 
   gfx::Transform child_transform;
   child_transform.Rotate(45.0);
 
-  // child gets a render surface when surfaces are enabled.
-  SetLayerPropertiesForTesting(parent, parent_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-  SetLayerPropertiesForTesting(child, child_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               true);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(2.0, 2.0), gfx::Size(20, 20), true,
-                               false, false);
+  root->SetBounds(gfx::Size(100, 100));
+  parent->SetTransform(parent_transform);
+  parent->SetBounds(gfx::Size(10, 10));
+  child->SetTransform(child_transform);
+  child->SetBounds(gfx::Size(10, 10));
+  child->test_properties()->force_render_surface = true;
+  grand_child->SetPosition(gfx::PointF(2.f, 2.f));
+  grand_child->SetBounds(gfx::Size(20, 20));
+  grand_child->SetDrawsContent(true);
 
   gfx::Transform expected_grand_child_screen_space_transform;
   expected_grand_child_screen_space_transform.Translate(10.0, 10.0);
   expected_grand_child_screen_space_transform.Rotate(45.0);
   expected_grand_child_screen_space_transform.Translate(2.0, 2.0);
 
   // First compute draw properties with separate surfaces enabled.
   ExecuteCalculateDrawProperties(root);
 
   // The grand child's draw transform should be its offset wrt the child.
@@ skipping 12 matching lines @@
                                   grand_child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform,
                                   grand_child->ScreenSpaceTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForReplica) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
-  grand_child->SetDrawsContent(true);
   std::unique_ptr<LayerImpl> child_replica =
       LayerImpl::Create(host_impl()->active_tree(), 100);
 
-  // One-time setup of root layer
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1, 2), true, false,
-                               true);
-
-  // Child is set up so that a new render surface should be created.
-  child->test_properties()->opacity = 0.5f;
-
   gfx::Transform parent_layer_transform;
   parent_layer_transform.Scale3d(2.0, 2.0, 1.0);
   gfx::Transform parent_translation_to_anchor;
   parent_translation_to_anchor.Translate(2.5, 3.0);
   gfx::Transform parent_composite_transform =
       parent_translation_to_anchor * parent_layer_transform *
       Inverse(parent_translation_to_anchor);
   gfx::Transform replica_layer_transform;
   replica_layer_transform.Scale3d(3.0, 3.0, 1.0);
   gfx::Vector2dF parent_composite_scale =
       MathUtil::ComputeTransform2dScaleComponents(parent_composite_transform,
                                                   1.f);
   gfx::Transform surface_sublayer_transform;
   surface_sublayer_transform.Scale(parent_composite_scale.x(),
                                    parent_composite_scale.y());
   gfx::Transform replica_composite_transform =
       parent_composite_transform * replica_layer_transform *
       Inverse(surface_sublayer_transform);
-  child_replica->SetDrawsContent(true);
-  // Child's render surface should not exist yet.
-  ASSERT_FALSE(child->render_surface());
 
-  SetLayerPropertiesForTesting(parent, parent_layer_transform,
-                               gfx::Point3F(2.5f, 3.0f, 0.f), gfx::PointF(),
-                               gfx::Size(10, 12), true, false, false);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(16, 18), true, false,
-                               true);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(-0.5f, -0.5f), gfx::Size(1, 1), true,
-                               false, false);
-  SetLayerPropertiesForTesting(child_replica.get(), replica_layer_transform,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(), true,
-                               false, false);
+  root->SetBounds(gfx::Size(1, 2));
+  parent->test_properties()->transform_origin = gfx::Point3F(2.5f, 3.0f, 0.f);
+  parent->SetTransform(parent_layer_transform);
+  parent->SetBounds(gfx::Size(10, 12));
+  child->SetBounds(gfx::Size(16, 18));
+  child->test_properties()->force_render_surface = true;
+  grand_child->SetPosition(gfx::PointF(-0.5f, -0.5f));
+  grand_child->SetBounds(gfx::Size(1, 1));
+
+  child_replica->SetTransform(replica_layer_transform);
   child->test_properties()->SetReplicaLayer(std::move(child_replica));
 
   ExecuteCalculateDrawProperties(root);
 
   // Render surface should have been created now.
   ASSERT_TRUE(child->render_surface());
   ASSERT_EQ(child->render_surface(), child->render_target());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       replica_composite_transform,
@@ skipping 40 matching lines @@
   std::unique_ptr<LayerImpl> replica_of_rs1 =
       LayerImpl::Create(host_impl()->active_tree(), 101);
   std::unique_ptr<LayerImpl> replica_of_rs2 =
       LayerImpl::Create(host_impl()->active_tree(), 102);
 
   // In combination with descendant draws content, opacity != 1 forces the layer
   // to have a new render surface.
   render_surface1->test_properties()->opacity = 0.5f;
   render_surface2->test_properties()->opacity = 0.33f;
 
-  // One-time setup of root layer
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1, 2), true, false,
-                               true);
-
   // All layers in the tree are initialized with an anchor at .25 and a size of
   // (10,10).  matrix "A" is the composite layer transform used in all layers,
   // Matrix "R" is the composite replica transform used in all replica layers.
   gfx::Transform translation_to_anchor;
   translation_to_anchor.Translate(2.5, 0.0);
   gfx::Transform layer_transform;
   layer_transform.Translate(1.0, 1.0);
   gfx::Transform replica_layer_transform;
   replica_layer_transform.Scale3d(-2.0, 5.0, 1.0);
 
@@ skipping 19 matching lines @@
   gfx::Transform surface2_sublayer_transform;
   surface2_sublayer_transform.Scale(surface2_parent_transform_scale.x(),
                                     surface2_parent_transform_scale.y());
 
   // SS2 = transform given to the subtree of render_surface2
   gfx::Transform SS2 = surface2_sublayer_transform;
   // S2 = transform to move from render_surface2 pixels to the layer space of
   // the owning layer
   gfx::Transform S2 = Inverse(surface2_sublayer_transform);
 
-  SetLayerPropertiesForTesting(parent, layer_transform,
-                               gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
-                               gfx::Size(10, 10), true, false, false);
-  SetLayerPropertiesForTesting(render_surface1, layer_transform,
-                               gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
-                               gfx::Size(10, 10), true, false, true);
-  SetLayerPropertiesForTesting(render_surface2, layer_transform,
-                               gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
-                               gfx::Size(10, 10), true, false, true);
-  SetLayerPropertiesForTesting(child_of_root, layer_transform,
-                               gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
-                               gfx::Size(10, 10), true, false, false);
-  SetLayerPropertiesForTesting(child_of_rs1, layer_transform,
-                               gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
-                               gfx::Size(10, 10), true, false, false);
-  SetLayerPropertiesForTesting(child_of_rs2, layer_transform,
-                               gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
-                               gfx::Size(10, 10), true, false, false);
-  SetLayerPropertiesForTesting(grand_child_of_root, layer_transform,
-                               gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
-                               gfx::Size(10, 10), true, false, false);
-  SetLayerPropertiesForTesting(grand_child_of_rs1, layer_transform,
-                               gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
-                               gfx::Size(10, 10), true, false, false);
-  SetLayerPropertiesForTesting(grand_child_of_rs2, layer_transform,
-                               gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
-                               gfx::Size(10, 10), true, false, false);
-  SetLayerPropertiesForTesting(replica_of_rs1.get(), replica_layer_transform,
-                               gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
-                               gfx::Size(), true, false, false);
-  SetLayerPropertiesForTesting(replica_of_rs2.get(), replica_layer_transform,
-                               gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
-                               gfx::Size(), true, false, false);
+  root->SetBounds(gfx::Size(1, 2));
+  parent->test_properties()->transform_origin = gfx::Point3F(2.5f, 0.f, 0.f);
+  parent->SetTransform(layer_transform);
+  parent->SetBounds(gfx::Size(10, 10));
+  render_surface1->test_properties()->transform_origin =
+      gfx::Point3F(2.5f, 0.f, 0.f);
+  render_surface1->SetTransform(layer_transform);
+  render_surface1->SetBounds(gfx::Size(10, 10));
+  render_surface1->test_properties()->force_render_surface = true;
+  render_surface2->test_properties()->transform_origin =
+      gfx::Point3F(2.5f, 0.f, 0.f);
+  render_surface2->SetTransform(layer_transform);
+  render_surface2->SetBounds(gfx::Size(10, 10));
+  render_surface2->test_properties()->force_render_surface = true;
+  child_of_root->test_properties()->transform_origin =
+      gfx::Point3F(2.5f, 0.f, 0.f);
+  child_of_root->SetTransform(layer_transform);
+  child_of_root->SetBounds(gfx::Size(10, 10));
+  child_of_rs1->test_properties()->transform_origin =
+      gfx::Point3F(2.5f, 0.f, 0.f);
+  child_of_rs1->SetTransform(layer_transform);
+  child_of_rs1->SetBounds(gfx::Size(10, 10));
+  child_of_rs2->test_properties()->transform_origin =
+      gfx::Point3F(2.5f, 0.f, 0.f);
+  child_of_rs2->SetTransform(layer_transform);
+  child_of_rs2->SetBounds(gfx::Size(10, 10));
+  grand_child_of_root->test_properties()->transform_origin =
+      gfx::Point3F(2.5f, 0.f, 0.f);
+  grand_child_of_root->SetTransform(layer_transform);
+  grand_child_of_root->SetBounds(gfx::Size(10, 10));
+  grand_child_of_rs1->test_properties()->transform_origin =
+      gfx::Point3F(2.5f, 0.f, 0.f);
+  grand_child_of_rs1->SetTransform(layer_transform);
+  grand_child_of_rs1->SetBounds(gfx::Size(10, 10));
+  grand_child_of_rs2->test_properties()->transform_origin =
+      gfx::Point3F(2.5f, 0.f, 0.f);
+  grand_child_of_rs2->SetTransform(layer_transform);
+  grand_child_of_rs2->SetBounds(gfx::Size(10, 10));
+  replica_of_rs1->test_properties()->transform_origin =
+      gfx::Point3F(2.5f, 0.f, 0.f);
+  replica_of_rs1->SetTransform(replica_layer_transform);
+  replica_of_rs2->test_properties()->transform_origin =
+      gfx::Point3F(2.5f, 0.f, 0.f);
+  replica_of_rs2->SetTransform(replica_layer_transform);
 
   // We need to set parent on replica layers for property tree building.
   replica_of_rs1->test_properties()->parent = render_surface1;
   replica_of_rs2->test_properties()->parent = render_surface2;
   render_surface1->test_properties()->SetReplicaLayer(
       std::move(replica_of_rs1));
   render_surface2->test_properties()->SetReplicaLayer(
       std::move(replica_of_rs2));
   ExecuteCalculateDrawProperties(root);
 
@@ skipping 125 matching lines @@
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   child->SetDrawsContent(true);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   grand_child->SetDrawsContent(true);
   LayerImpl* great_grand_child = AddChild<LayerImpl>(grand_child);
   great_grand_child->SetDrawsContent(true);
 
   gfx::Transform rotation_about_y_axis;
   rotation_about_y_axis.RotateAboutYAxis(30.0);
 
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, rotation_about_y_axis, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               true);
-  SetLayerPropertiesForTesting(grand_child, rotation_about_y_axis,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
-                               true, false, false);
-  SetLayerPropertiesForTesting(great_grand_child, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
-                               true, false, false);
+  root->SetBounds(gfx::Size(100, 100));
+  child->SetTransform(rotation_about_y_axis);
+  child->SetBounds(gfx::Size(10, 10));
+  child->test_properties()->force_render_surface = true;
+  grand_child->SetTransform(rotation_about_y_axis);
+  grand_child->SetBounds(gfx::Size(10, 10));
+  great_grand_child->SetBounds(gfx::Size(10, 10));
 
   // No layers in this test should preserve 3d.
   ASSERT_TRUE(root->test_properties()->should_flatten_transform);
   ASSERT_TRUE(child->test_properties()->should_flatten_transform);
   ASSERT_TRUE(grand_child->test_properties()->should_flatten_transform);
   ASSERT_TRUE(great_grand_child->test_properties()->should_flatten_transform);
 
   gfx::Transform expected_child_draw_transform = rotation_about_y_axis;
   gfx::Transform expected_child_screen_space_transform = rotation_about_y_axis;
   gfx::Transform expected_grand_child_draw_transform =
       rotation_about_y_axis;  // draws onto child's render surface
   gfx::Transform flattened_rotation_about_y = rotation_about_y_axis;
   flattened_rotation_about_y.FlattenTo2d();
   gfx::Transform expected_grand_child_screen_space_transform =
       flattened_rotation_about_y * rotation_about_y_axis;
   gfx::Transform expected_great_grand_child_draw_transform =
       flattened_rotation_about_y;
   gfx::Transform expected_great_grand_child_screen_space_transform =
       flattened_rotation_about_y * flattened_rotation_about_y;
 
   ExecuteCalculateDrawProperties(root);
 
   // The child's draw transform should have been taken by its surface.
   ASSERT_TRUE(child->render_surface());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_draw_transform,
                                   child->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_child_screen_space_transform,
       child->render_surface()->screen_space_transform());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->DrawTransform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(), child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_screen_space_transform,
                                   child->ScreenSpaceTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_draw_transform,
                                   grand_child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform,
                                   grand_child->ScreenSpaceTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_draw_transform,
                                   great_grand_child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_great_grand_child_screen_space_transform,
       great_grand_child->ScreenSpaceTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerFullyContainedWithinClipInTargetSpace) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   gfx::Transform child_transform;
   child_transform.Translate(50.0, 50.0);
   child_transform.RotateAboutZAxis(30.0);
 
   gfx::Transform grand_child_transform;
   grand_child_transform.RotateAboutYAxis(90.0);
 
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(200, 200), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, child_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-  SetLayerPropertiesForTesting(grand_child, grand_child_transform,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false, false);
-
+  root->SetBounds(gfx::Size(200, 200));
+  child->SetTransform(child_transform);
+  child->SetBounds(gfx::Size(10, 10));
+  grand_child->SetTransform(grand_child_transform);
+  grand_child->SetBounds(gfx::Size(100, 100));
   grand_child->test_properties()->should_flatten_transform = false;
   grand_child->SetDrawsContent(true);
-
   ExecuteCalculateDrawProperties(root);
 
   // Mapping grand_child's bounds to target space produces a non-empty rect
   // that is fully contained within the target's bounds, so grand_child should
   // be considered fully visible.
   EXPECT_EQ(gfx::Rect(grand_child->bounds()),
             grand_child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForDegenerateIntermediateLayer) {
   // A layer that is empty in one axis, but not the other, was accidentally
   // skipping a necessary translation.  Without that translation, the coordinate
   // space of the layer's draw transform is incorrect.
   //
   // Normally this isn't a problem, because the layer wouldn't be drawn anyway,
   // but if that layer becomes a render surface, then its draw transform is
   // implicitly inherited by the rest of the subtree, which then is positioned
   // incorrectly as a result.
 
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   grand_child->SetDrawsContent(true);
 
+  root->SetBounds(gfx::Size(100, 100));
   // The child height is zero, but has non-zero width that should be accounted
   // for while computing draw transforms.
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 0), true, false,
-                               true);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-
+  child->SetBounds(gfx::Size(10, 0));
+  child->test_properties()->force_render_surface = true;
+  grand_child->SetBounds(gfx::Size(10, 10));
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(child->has_render_surface());
   // This is the real test, the rest are sanity checks.
-  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
+  EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                   child->render_surface()->draw_transform());
-  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(),
                                   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);
 
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
   gfx::Transform translate;
   translate.Translate3d(5, 5, 5);
-  SetLayerPropertiesForTesting(render_surface, translate, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, translate, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false, false);
-  SetLayerPropertiesForTesting(grand_child, translate, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
+
+  root->SetBounds(gfx::Size(100, 100));
+  render_surface->SetTransform(translate);
+  render_surface->SetBounds(gfx::Size(100, 100));
+  render_surface->test_properties()->force_render_surface = true;
+  child->SetTransform(translate);
+  child->SetBounds(gfx::Size(100, 100));
+  grand_child->SetTransform(translate);
+  grand_child->SetBounds(gfx::Size(100, 100));
   grand_child->SetDrawsContent(true);
 
   // render_surface will have a sublayer scale because of device scale factor.
   float device_scale_factor = 2.0f;
   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);
 
   // 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);
-  LayerImpl* child = AddChild<LayerImpl>(root);
+  root->SetBounds(gfx::Size(20, 20));
   child->SetDrawsContent(true);
-
   child->SetScrollClipLayer(root->id());
-
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false,
-                               false);
+  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(
@@ skipping 112 matching lines @@
         compositeSquared, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         compositeSquared, child->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
                                     root->render_surface()->draw_transform());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceListForRenderSurfaceWithClippedLayer) {
-  LayerImpl* parent = root_layer_for_testing();
-  parent->SetMasksToBounds(true);
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
   LayerImpl* child = AddChild<LayerImpl>(render_surface1);
+
+  root->SetBounds(gfx::Size(10, 10));
+  root->SetMasksToBounds(true);
+  render_surface1->SetBounds(gfx::Size(10, 10));
+  render_surface1->test_properties()->force_render_surface = true;
   child->SetDrawsContent(true);
+  child->SetPosition(gfx::PointF(30.f, 30.f));
+  child->SetBounds(gfx::Size(10, 10));
+  ExecuteCalculateDrawProperties(root);
 
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               true);
-  SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(30.f, 30.f), gfx::Size(10, 10), true,
-                               false, false);
-
-  ExecuteCalculateDrawProperties(parent);
-
-  // The child layer's content is entirely outside the parent's clip rect, so
+  // The child layer's content is entirely outside the root's clip rect, so
   // the intermediate render surface should not be listed here, even if it was
   // forced to be created. Render surfaces without children or visible content
   // are unexpected at draw time (e.g. we might try to create a content texture
   // of size 0).
-  ASSERT_TRUE(parent->render_surface());
+  ASSERT_TRUE(root->render_surface());
   EXPECT_EQ(1U, render_surface_layer_list_impl()->size());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceListForTransparentChild) {
-  LayerImpl* parent = root_layer_for_testing();
-  LayerImpl* render_surface1 = AddChild<LayerImpl>(parent);
+  LayerImpl* root = root_layer_for_testing();
+  LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(render_surface1);
+
+  render_surface1->SetBounds(gfx::Size(10, 10));
+  render_surface1->test_properties()->force_render_surface = true;
+  render_surface1->test_properties()->opacity = 0.f;
+  child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
 
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-  render_surface1->test_properties()->opacity = 0.f;
-
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      parent, parent->bounds(), &render_surface_layer_list);
+      root, root->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // Since the layer is transparent, render_surface1->render_surface() should
   // not have gotten added anywhere.  Also, the drawable content rect should not
   // have been extended by the children.
-  ASSERT_TRUE(parent->render_surface());
-  EXPECT_EQ(0U, parent->render_surface()->layer_list().size());
+  ASSERT_TRUE(root->render_surface());
+  EXPECT_EQ(0U, root->render_surface()->layer_list().size());
   EXPECT_EQ(1U, render_surface_layer_list.size());
-  EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
-  EXPECT_EQ(gfx::Rect(), parent->drawable_content_rect());
+  EXPECT_EQ(root->id(), render_surface_layer_list.at(0)->id());
+  EXPECT_EQ(gfx::Rect(), root->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceListForTransparentChildWithBackgroundFilter) {
-  LayerImpl* parent = root_layer_for_testing();
-  LayerImpl* render_surface1 = AddChild<LayerImpl>(parent);
+  LayerImpl* root = root_layer_for_testing();
+  LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(render_surface1);
-  child->SetDrawsContent(true);
 
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               true);
-  SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
+  root->SetBounds(gfx::Size(10, 10));
+  render_surface1->SetBounds(gfx::Size(10, 10));
+  render_surface1->test_properties()->force_render_surface = true;
   render_surface1->test_properties()->opacity = 0.f;
   render_surface1->SetDrawsContent(true);
-  child->SetDrawsContent(true);
   FilterOperations filters;
   filters.Append(FilterOperation::CreateBlurFilter(1.5f));
   render_surface1->test_properties()->background_filters = filters;
+  child->SetBounds(gfx::Size(10, 10));
+  child->SetDrawsContent(true);
 
   {
     LayerImplList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        parent, parent->bounds(), &render_surface_layer_list);
+        root, root->bounds(), &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     EXPECT_EQ(2U, render_surface_layer_list.size());
   }
   // The layer is fully transparent, but has a background filter, so it
   // shouldn't be skipped and should be drawn.
-  ASSERT_TRUE(parent->render_surface());
-  EXPECT_EQ(1U, parent->render_surface()->layer_list().size());
+  ASSERT_TRUE(root->render_surface());
+  EXPECT_EQ(1U, root->render_surface()->layer_list().size());
   EXPECT_EQ(gfx::RectF(0, 0, 10, 10),
-            parent->render_surface()->DrawableContentRect());
+            root->render_surface()->DrawableContentRect());
   EffectTree& effect_tree =
-      parent->layer_tree_impl()->property_trees()->effect_tree;
+      root->layer_tree_impl()->property_trees()->effect_tree;
   EffectNode* node = effect_tree.Node(render_surface1->effect_tree_index());
   EXPECT_TRUE(node->is_drawn);
 
-  // When parent is transparent, the layer should not be drawn.
-  parent->OnOpacityAnimated(0.f);
+  // When root is transparent, the layer should not be drawn.
+  root->OnOpacityAnimated(0.f);
   render_surface1->OnOpacityAnimated(1.f);
   render_surface1->set_visible_layer_rect(gfx::Rect());
   {
     LayerImplList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        parent, parent->bounds(), &render_surface_layer_list);
+        root, root->bounds(), &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
   }
 
   node = effect_tree.Node(render_surface1->effect_tree_index());
   EXPECT_FALSE(node->is_drawn);
   EXPECT_EQ(gfx::Rect(), render_surface1->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceListForFilter) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child1 = AddChild<LayerImpl>(parent);
   LayerImpl* child2 = AddChild<LayerImpl>(parent);
-  child1->SetDrawsContent(true);
-  child2->SetDrawsContent(true);
 
-  const gfx::Transform identity_matrix;
   gfx::Transform scale_matrix;
   scale_matrix.Scale(2.0f, 2.0f);
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(parent, scale_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(), true, false, true);
-  SetLayerPropertiesForTesting(child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(0, 0), gfx::Size(25, 25), true,
-                               false, true);
-  SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(25, 25), gfx::Size(25, 25), true,
-                               false, true);
+
+  root->SetBounds(gfx::Size(100, 100));
+  parent->SetTransform(scale_matrix);
   FilterOperations filters;
   filters.Append(FilterOperation::CreateBlurFilter(10.0f));
   parent->test_properties()->filters = filters;
+  parent->test_properties()->force_render_surface = true;
+  child1->SetBounds(gfx::Size(25, 25));
+  child1->SetDrawsContent(true);
+  child1->test_properties()->force_render_surface = true;
+  child2->SetPosition(gfx::PointF(25, 25));
+  child2->SetBounds(gfx::Size(25, 25));
+  child2->SetDrawsContent(true);
+  child2->test_properties()->force_render_surface = true;
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root, root->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   ASSERT_TRUE(parent->render_surface());
   EXPECT_EQ(2U, parent->render_surface()->layer_list().size());
   EXPECT_EQ(4U, render_surface_layer_list.size());
 
   // The rectangle enclosing child1 and child2 (0,0 50x50), expanded for the
   // blur (-30,-30 110x110), and then scaled by the scale matrix
   // (-60,-60 220x220).
   EXPECT_EQ(gfx::RectF(-60, -60, 220, 220),
             parent->render_surface()->DrawableContentRect());
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawableContentRectForReferenceFilter) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
+
+  root->SetBounds(gfx::Size(100, 100));
+  child->SetBounds(gfx::Size(25, 25));
   child->SetDrawsContent(true);
-
-  SetLayerPropertiesForTesting(root, gfx::Transform(), gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, gfx::Transform(), gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(25, 25), true, false,
-                               true);
-
+  child->test_properties()->force_render_surface = true;
   FilterOperations filters;
   filters.Append(FilterOperation::CreateReferenceFilter(
       SkOffsetImageFilter::Make(50, 50, nullptr)));
   child->test_properties()->filters = filters;
-
   ExecuteCalculateDrawProperties(root);
 
   // The render surface's size should be unaffected by the offset image filter;
   // it need only have a drawable content rect large enough to contain the
   // contents (at the new offset).
   ASSERT_TRUE(child->render_surface());
   EXPECT_EQ(gfx::RectF(50, 50, 25, 25),
             child->render_surface()->DrawableContentRect());
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawableContentRectForReferenceFilterHighDpi) {
   const float device_scale_factor = 2.0f;
 
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
+
+  root->SetBounds(gfx::Size(100, 100));
+  child->SetBounds(gfx::Size(25, 25));
   child->SetDrawsContent(true);
-
-  SetLayerPropertiesForTesting(root, gfx::Transform(), gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, gfx::Transform(), gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(25, 25), true, false,
-                               true);
+  child->test_properties()->force_render_surface = true;
 
   FilterOperations filters;
   filters.Append(FilterOperation::CreateReferenceFilter(
       SkOffsetImageFilter::Make(50, 50, nullptr)));
   child->test_properties()->filters = filters;
 
   ExecuteCalculateDrawProperties(root, device_scale_factor);
 
   // The render surface's size should be unaffected by the offset image filter;
   // it need only have a drawable content rect large enough to contain the
   // contents (at the new offset). All coordinates should be scaled by 2,
   // corresponding to the device scale factor.
   ASSERT_TRUE(child->render_surface());
   EXPECT_EQ(gfx::RectF(100, 100, 50, 50),
             child->render_surface()->DrawableContentRect());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceForBlendMode) {
-  LayerImpl* parent = root_layer_for_testing();
-  LayerImpl* child = AddChild<LayerImpl>(parent);
+  LayerImpl* root = root_layer_for_testing();
+  LayerImpl* child = AddChild<LayerImpl>(root);
+
+  root->SetBounds(gfx::Size(10, 10));
+  child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
-
-  const gfx::Transform identity_matrix;
-  const SkXfermode::Mode blend_mode = SkXfermode::kMultiply_Mode;
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               true);
-
-  child->SetBlendMode(blend_mode);
+  child->SetBlendMode(SkXfermode::kMultiply_Mode);
   child->test_properties()->opacity = 0.5f;
-
-  ExecuteCalculateDrawProperties(parent);
+  child->test_properties()->force_render_surface = true;
+  ExecuteCalculateDrawProperties(root);
 
   // Since the child layer has a blend mode other than normal, it should get
   // its own render surface. Also, layer's draw_properties should contain the
   // default blend mode, since the render surface becomes responsible for
   // applying the blend mode.
   ASSERT_TRUE(child->render_surface());
   EXPECT_EQ(1.0f, child->draw_opacity());
   EXPECT_EQ(0.5f, child->render_surface()->draw_opacity());
   EXPECT_EQ(SkXfermode::kSrcOver_Mode, child->draw_blend_mode());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceDrawOpacity) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* surface1 = AddChildToRoot<LayerImpl>();
   LayerImpl* not_surface = AddChild<LayerImpl>(surface1);
   LayerImpl* surface2 = AddChild<LayerImpl>(not_surface);
 
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               true);
-  SetLayerPropertiesForTesting(surface1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               true);
-  SetLayerPropertiesForTesting(not_surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-  SetLayerPropertiesForTesting(surface2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               true);
+  root->SetBounds(gfx::Size(10, 10));
+  surface1->SetBounds(gfx::Size(10, 10));
   surface1->SetDrawsContent(true);
+  surface1->test_properties()->opacity = 0.5f;
+  surface1->test_properties()->force_render_surface = true;
+  not_surface->SetBounds(gfx::Size(10, 10));
+  not_surface->test_properties()->opacity = 0.5f;
+  surface2->SetBounds(gfx::Size(10, 10));
   surface2->SetDrawsContent(true);
-
-  surface1->test_properties()->opacity = 0.5f;
-  not_surface->test_properties()->opacity = 0.5f;
   surface2->test_properties()->opacity = 0.5f;
-
+  surface2->test_properties()->force_render_surface = true;
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(surface1->render_surface());
   ASSERT_FALSE(not_surface->render_surface());
   ASSERT_TRUE(surface2->render_surface());
   EXPECT_EQ(0.5f, surface1->render_surface()->draw_opacity());
   // surface2's draw opacity should include the opacity of not-surface and
   // itself, but not the opacity of surface1.
   EXPECT_EQ(0.25f, surface2->render_surface()->draw_opacity());
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawOpacityWhenCannotRenderToSeparateSurface) {
   // Tests that when separate surfaces are disabled, a layer's draw opacity is
   // the product of all ancestor layer opacties and the layer's own opacity.
   // (Rendering will still be incorrect in situations where we really do need
   // surfaces to apply opacity, such as when we have overlapping layers with an
   // ancestor whose opacity is <1.)
   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));
   root->SetDrawsContent(true);
+  parent->SetBounds(gfx::Size(100, 100));
   parent->SetDrawsContent(true);
+  child1->SetBounds(gfx::Size(100, 100));
   child1->SetDrawsContent(true);
+  child1->test_properties()->opacity = 0.5f;
+  child1->test_properties()->force_render_surface = true;
+  child2->SetBounds(gfx::Size(100, 100));
   child2->SetDrawsContent(true);
+  grand_child->SetBounds(gfx::Size(100, 100));
   grand_child->SetDrawsContent(true);
+  grand_child->test_properties()->opacity = 0.5f;
+  grand_child->test_properties()->force_render_surface = true;
+  leaf_node1->SetBounds(gfx::Size(100, 100));
   leaf_node1->SetDrawsContent(true);
+  leaf_node1->test_properties()->opacity = 0.5f;
+  leaf_node2->SetBounds(gfx::Size(100, 100));
   leaf_node2->SetDrawsContent(true);
-
-  const gfx::Transform identity_matrix;
-
-  // child1 and grand_child get render surfaces when surfaces are enabled.
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-  SetLayerPropertiesForTesting(child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(leaf_node1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-  SetLayerPropertiesForTesting(leaf_node2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-
-  child1->test_properties()->opacity = 0.5f;
-  grand_child->test_properties()->opacity = 0.5f;
-  leaf_node1->test_properties()->opacity = 0.5f;
   leaf_node2->test_properties()->opacity = 0.5f;
 
   // With surfaces enabled, each layer's draw opacity is the product of layer
   // opacities on the path from the layer to its render target, not including
   // the opacity of the layer that owns the target surface (since that opacity
   // is applied by the surface).
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(1.f, root->draw_opacity());
   EXPECT_EQ(1.f, parent->draw_opacity());
   EXPECT_EQ(1.f, child1->draw_opacity());
   EXPECT_EQ(1.f, child2->draw_opacity());
   EXPECT_EQ(1.f, grand_child->draw_opacity());
   EXPECT_EQ(0.5f, leaf_node1->draw_opacity());
   EXPECT_EQ(0.5f, leaf_node2->draw_opacity());
 
   // With surfaces disabled, each layer's draw opacity is the product of layer
   // opacities on the path from the layer to the root.
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_EQ(1.f, root->draw_opacity());
   EXPECT_EQ(1.f, parent->draw_opacity());
   EXPECT_EQ(0.5f, child1->draw_opacity());
   EXPECT_EQ(1.f, child2->draw_opacity());
   EXPECT_EQ(0.25f, grand_child->draw_opacity());
   EXPECT_EQ(0.125f, leaf_node1->draw_opacity());
   EXPECT_EQ(0.5f, leaf_node2->draw_opacity());
 }
 
 TEST_F(LayerTreeHostCommonTest, ForceRenderSurface) {
-  LayerImpl* parent = root_layer_for_testing();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
   LayerImpl* child = AddChild<LayerImpl>(render_surface1);
 
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false);
-  SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false);
-
+  root->SetBounds(gfx::Size(10, 10));
+  render_surface1->SetBounds(gfx::Size(10, 10));
+  render_surface1->test_properties()->force_render_surface = true;
+  child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
-  render_surface1->test_properties()->force_render_surface = true;
 
   {
-    ExecuteCalculateDrawPropertiesWithPropertyTrees(parent);
+    ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
 
     // The root layer always creates a render surface
-    EXPECT_TRUE(parent->has_render_surface());
+    EXPECT_TRUE(root->has_render_surface());
     EXPECT_TRUE(render_surface1->has_render_surface());
   }
 
   {
     render_surface1->test_properties()->force_render_surface = false;
     render_surface1->layer_tree_impl()->property_trees()->needs_rebuild = true;
-    ExecuteCalculateDrawPropertiesWithPropertyTrees(parent);
-    EXPECT_TRUE(parent->has_render_surface());
+    ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
+    EXPECT_TRUE(root->has_render_surface());
     EXPECT_FALSE(render_surface1->has_render_surface());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfacesFlattenScreenSpaceTransform) {
   // Render surfaces act as a flattening point for their subtree, so should
   // always flatten the target-to-screen space transform seen by descendants.
-
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
-  child->SetDrawsContent(true);
-  grand_child->SetDrawsContent(true);
-
   gfx::Transform rotation_about_y_axis;
   rotation_about_y_axis.RotateAboutYAxis(30.0);
-  // Make |parent| have a render surface.
-  parent->test_properties()->opacity = 0.9f;
 
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(parent, rotation_about_y_axis, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-
+  root->SetBounds(gfx::Size(100, 100));
+  parent->SetTransform(rotation_about_y_axis);
+  parent->SetBounds(gfx::Size(10, 10));
+  parent->test_properties()->force_render_surface = true;
+  child->SetBounds(gfx::Size(10, 10));
+  child->SetDrawsContent(true);
+  grand_child->SetBounds(gfx::Size(10, 10));
+  grand_child->SetDrawsContent(true);
   grand_child->test_properties()->should_flatten_transform = false;
-
-  // Only grand_child should preserve 3d.
-  EXPECT_TRUE(root->test_properties()->should_flatten_transform);
-  EXPECT_TRUE(parent->test_properties()->should_flatten_transform);
-  EXPECT_TRUE(child->test_properties()->should_flatten_transform);
-  EXPECT_FALSE(grand_child->test_properties()->should_flatten_transform);
-
-  gfx::Transform flattened_rotation_about_y = rotation_about_y_axis;
-  flattened_rotation_about_y.FlattenTo2d();
-
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(parent->render_surface());
   EXPECT_FALSE(child->render_surface());
   EXPECT_FALSE(grand_child->render_surface());
 
-  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(),
                                   grand_child->DrawTransform());
 
   // The screen-space transform inherited by |child| and |grand_child| should
   // have been flattened at their render target. In particular, the fact that
   // |grand_child| happens to preserve 3d shouldn't affect this flattening.
+  gfx::Transform flattened_rotation_about_y = rotation_about_y_axis;
+  flattened_rotation_about_y.FlattenTo2d();
   EXPECT_TRANSFORMATION_MATRIX_EQ(flattened_rotation_about_y,
                                   child->ScreenSpaceTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(flattened_rotation_about_y,
                                   grand_child->ScreenSpaceTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipRectCullsRenderSurfaces) {
   // The entire subtree of layers that are outside the clip rect should be
   // culled away, and should not affect the render_surface_layer_list.
   //
   // The test tree is set up as follows:
   //  - all layers except the leaf_nodes are forced to be a new render surface
   //  that have something to draw.
   //  - parent is a large container layer.
-  //  - child has masksToBounds=true to cause clipping.
+  //  - child has MasksToBounds=true to cause clipping.
   //  - grand_child is positioned outside of the child's bounds
   //  - great_grand_child is also kept outside child's bounds.
   //
   // In this configuration, grand_child and great_grand_child are completely
   // outside the clip rect, and they should never get scheduled on the list of
   // render surfaces.
 
-  LayerImpl* parent = root_layer_for_testing();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   LayerImpl* great_grand_child = AddChild<LayerImpl>(grand_child);
 
-  // leaf_node1 ensures that parent and child are kept on the
+  // leaf_node1 ensures that root and child are kept on the
   // render_surface_layer_list, even though grand_child and great_grand_child
   // should be clipped.
   LayerImpl* leaf_node1 = AddChild<LayerImpl>(child);
+  LayerImpl* leaf_node2 = AddChild<LayerImpl>(great_grand_child);
+
+  root->SetBounds(gfx::Size(500, 500));
+  child->SetBounds(gfx::Size(20, 20));
+  child->SetMasksToBounds(true);
+  child->test_properties()->force_render_surface = true;
+  grand_child->SetPosition(gfx::PointF(45.f, 45.f));
+  grand_child->SetBounds(gfx::Size(10, 10));
+  great_grand_child->SetBounds(gfx::Size(10, 10));
+  leaf_node1->SetBounds(gfx::Size(500, 500));
   leaf_node1->SetDrawsContent(true);
-  LayerImpl* leaf_node2 = AddChild<LayerImpl>(great_grand_child);
+  leaf_node1->SetBounds(gfx::Size(20, 20));
   leaf_node2->SetDrawsContent(true);
-
-  const gfx::Transform identity_matrix;
-
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(500, 500), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false,
-                               true);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(45.f, 45.f), gfx::Size(10, 10), true,
-                               false, false);
-  SetLayerPropertiesForTesting(great_grand_child, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
-                               true, false, false);
-  SetLayerPropertiesForTesting(leaf_node1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(500, 500), true, false,
-                               false);
-  SetLayerPropertiesForTesting(leaf_node2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false,
-                               false);
-
-  child->SetMasksToBounds(true);
-  child->test_properties()->opacity = 0.4f;
-  grand_child->test_properties()->opacity = 0.5f;
-  great_grand_child->test_properties()->opacity = 0.4f;
-
-  ExecuteCalculateDrawProperties(parent);
+  ExecuteCalculateDrawProperties(root);
 
   ASSERT_EQ(2U, render_surface_layer_list_impl()->size());
-  EXPECT_EQ(parent->id(), render_surface_layer_list_impl()->at(0)->id());
+  EXPECT_EQ(root->id(), render_surface_layer_list_impl()->at(0)->id());
   EXPECT_EQ(child->id(), render_surface_layer_list_impl()->at(1)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipRectCullsSurfaceWithoutVisibleContent) {
   // When a render surface has a clip rect, it is used to clip the content rect
   // of the surface.
 
   // The test tree is set up as follows:
-  //  - parent is a container layer that masksToBounds=true to cause clipping.
+  //  - root is a container layer that masksToBounds=true to cause clipping.
   //  - child is a render surface, which has a clip rect set to the bounds of
-  //  the parent.
+  //  the root.
   //  - grand_child is a render surface, and the only visible content in child.
-  //  It is positioned outside of the clip rect from parent.
+  //  It is positioned outside of the clip rect from root.
 
   // 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* parent = root_layer_for_testing();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   LayerImpl* leaf_node = AddChild<LayerImpl>(grand_child);
-  leaf_node->SetDrawsContent(true);
 
   const gfx::Transform identity_matrix;
 
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false,
-                               true);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(200.f, 200.f), gfx::Size(10, 10),
-                               true, false, true);
-  SetLayerPropertiesForTesting(leaf_node, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-
-  parent->SetMasksToBounds(true);
-  child->test_properties()->opacity = 0.4f;
-  grand_child->test_properties()->opacity = 0.4f;
-
-  ExecuteCalculateDrawProperties(parent);
+  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);
 
   // We should cull child and grand_child from the
   // render_surface_layer_list.
   ASSERT_EQ(1U, render_surface_layer_list_impl()->size());
-  EXPECT_EQ(parent->id(), render_surface_layer_list_impl()->at(0)->id());
+  EXPECT_EQ(root->id(), render_surface_layer_list_impl()->at(0)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, IsClippedIsSetCorrectlyLayerImpl) {
   // Tests that LayerImpl's IsClipped() property is set to true when:
   //  - the layer clips its subtree, e.g. masks to bounds,
   //  - the layer is clipped by an ancestor that contributes to the same
   //    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));
   parent->SetDrawsContent(true);
-  LayerImpl* child1 = AddChild<LayerImpl>(parent);
+  child1->SetBounds(gfx::Size(100, 100));
   child1->SetDrawsContent(true);
-  LayerImpl* child2 = AddChild<LayerImpl>(parent);
+  child2->SetBounds(gfx::Size(100, 100));
   child2->SetDrawsContent(true);
-  LayerImpl* grand_child = AddChild<LayerImpl>(child1);
+  child2->test_properties()->force_render_surface = true;
+  grand_child->SetBounds(gfx::Size(100, 100));
   grand_child->SetDrawsContent(true);
-  LayerImpl* leaf_node1 = AddChild<LayerImpl>(grand_child);
+  leaf_node1->SetBounds(gfx::Size(100, 100));
   leaf_node1->SetDrawsContent(true);
-  LayerImpl* leaf_node2 = AddChild<LayerImpl>(child2);
+  leaf_node2->SetBounds(gfx::Size(100, 100));
   leaf_node2->SetDrawsContent(true);
 
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-  SetLayerPropertiesForTesting(child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-  SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-  SetLayerPropertiesForTesting(leaf_node1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-  SetLayerPropertiesForTesting(leaf_node2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-
   // Case 1: nothing is clipped except the root render surface.
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(root->render_surface());
   ASSERT_TRUE(child2->render_surface());
 
   EXPECT_FALSE(root->is_clipped());
   EXPECT_TRUE(root->render_surface()->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
   EXPECT_FALSE(child2->render_surface()->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_FALSE(leaf_node2->is_clipped());
 
-  // Case 2: parent masksToBounds, so the parent, child1, and child2's
+  // Case 2: parent MasksToBounds, so the parent, child1, and child2's
   // surface are clipped. But layers that contribute to child2's surface are
   // not clipped explicitly because child2's surface already accounts for
   // that clip.
   parent->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(root->render_surface());
   ASSERT_TRUE(child2->render_surface());
 
   EXPECT_FALSE(root->is_clipped());
   EXPECT_TRUE(root->render_surface()->is_clipped());
   EXPECT_TRUE(parent->is_clipped());
   EXPECT_TRUE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
   EXPECT_TRUE(child2->render_surface()->is_clipped());
   EXPECT_TRUE(grand_child->is_clipped());
   EXPECT_TRUE(leaf_node1->is_clipped());
   EXPECT_FALSE(leaf_node2->is_clipped());
 
   parent->SetMasksToBounds(false);
 
-  // Case 3: child2 masksToBounds. The layer and subtree are clipped, and
+  // Case 3: child2 MasksToBounds. The layer and subtree are clipped, and
   // child2's render surface is not clipped.
   child2->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(root->render_surface());
   ASSERT_TRUE(child2->render_surface());
 
   EXPECT_FALSE(root->is_clipped());
   EXPECT_TRUE(root->render_surface()->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_TRUE(child2->is_clipped());
   EXPECT_FALSE(child2->render_surface()->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_TRUE(leaf_node2->is_clipped());
 }
 
 TEST_F(LayerTreeHostCommonTest, UpdateClipRectCorrectly) {
   // Tests that when as long as layer is clipped, it's clip rect is set to
   // correct value.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(parent);
 
+  root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
+  parent->SetBounds(gfx::Size(100, 100));
   parent->SetDrawsContent(true);
+  child->SetBounds(gfx::Size(100, 100));
   child->SetDrawsContent(true);
-
-  const gfx::Transform identity_matrix;
-
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
   child->SetMasksToBounds(true);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_FALSE(root->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_TRUE(child->is_clipped());
   EXPECT_EQ(gfx::Rect(100, 100), child->clip_rect());
 
   parent->SetMasksToBounds(true);
-  child->SetPosition(gfx::PointF(100, 100));
+  child->SetPosition(gfx::PointF(100.f, 100.f));
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_FALSE(root->is_clipped());
   EXPECT_TRUE(parent->is_clipped());
   EXPECT_TRUE(child->is_clipped());
   EXPECT_EQ(gfx::Rect(), child->clip_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, IsClippedWhenCannotRenderToSeparateSurface) {
   // Tests that when separate surfaces are disabled, is_clipped is true exactly
   // when a layer or its ancestor has a clip; in particular, if a layer
   // is_clipped, so is its entire subtree (since there are no render surfaces
   // that can reset is_clipped).
   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));
   root->SetDrawsContent(true);
+  parent->SetBounds(gfx::Size(100, 100));
   parent->SetDrawsContent(true);
+  child1->SetBounds(gfx::Size(100, 100));
   child1->SetDrawsContent(true);
+  child1->test_properties()->force_render_surface = true;
+  child2->SetBounds(gfx::Size(100, 100));
   child2->SetDrawsContent(true);
+  grand_child->SetBounds(gfx::Size(100, 100));
   grand_child->SetDrawsContent(true);
+  grand_child->test_properties()->force_render_surface = true;
+  leaf_node1->SetBounds(gfx::Size(100, 100));
   leaf_node1->SetDrawsContent(true);
+  leaf_node2->SetBounds(gfx::Size(100, 100));
   leaf_node2->SetDrawsContent(true);
 
-  const gfx::Transform identity_matrix;
-
-  // child1 and grand_child get render surfaces when surfaces are enabled.
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-  SetLayerPropertiesForTesting(child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(leaf_node1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-  SetLayerPropertiesForTesting(leaf_node2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-
   // Case 1: Nothing is clipped. In this case, is_clipped is always false, with
   // or without surfaces.
-  root->SetHasRenderSurface(true);
-  child1->SetHasRenderSurface(true);
-  grand_child->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(root->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_FALSE(leaf_node2->is_clipped());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_FALSE(root->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_FALSE(leaf_node2->is_clipped());
 
   // Case 2: The root is clipped. With surfaces, this only persists until the
   // next render surface. Without surfaces, the entire tree is clipped.
   root->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
-  root->SetHasRenderSurface(true);
-  child1->SetHasRenderSurface(true);
-  grand_child->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRUE(root->is_clipped());
   EXPECT_TRUE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_TRUE(child2->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_TRUE(leaf_node2->is_clipped());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_TRUE(root->is_clipped());
   EXPECT_TRUE(parent->is_clipped());
   EXPECT_TRUE(child1->is_clipped());
   EXPECT_TRUE(child2->is_clipped());
   EXPECT_TRUE(grand_child->is_clipped());
   EXPECT_TRUE(leaf_node1->is_clipped());
   EXPECT_TRUE(leaf_node2->is_clipped());
 
   root->SetMasksToBounds(false);
 
   // Case 3: The parent is clipped. Again, with surfaces, this only persists
   // until the next render surface. Without surfaces, parent's entire subtree is
   // clipped.
   parent->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
-  root->SetHasRenderSurface(true);
-  child1->SetHasRenderSurface(true);
-  grand_child->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(root->is_clipped());
   EXPECT_TRUE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_TRUE(child2->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_TRUE(leaf_node2->is_clipped());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_FALSE(root->is_clipped());
   EXPECT_TRUE(parent->is_clipped());
   EXPECT_TRUE(child1->is_clipped());
   EXPECT_TRUE(child2->is_clipped());
   EXPECT_TRUE(grand_child->is_clipped());
   EXPECT_TRUE(leaf_node1->is_clipped());
   EXPECT_TRUE(leaf_node2->is_clipped());
 
   parent->SetMasksToBounds(false);
 
   // Case 4: child1 is clipped. With surfaces, only child1 is_clipped, since it
   // has no non-surface children. Without surfaces, child1's entire subtree is
   // clipped.
   child1->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
-  root->SetHasRenderSurface(true);
-  child1->SetHasRenderSurface(true);
-  grand_child->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(root->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_TRUE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_FALSE(leaf_node2->is_clipped());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_FALSE(root->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_TRUE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
   EXPECT_TRUE(grand_child->is_clipped());
   EXPECT_TRUE(leaf_node1->is_clipped());
   EXPECT_FALSE(leaf_node2->is_clipped());
 
   child1->SetMasksToBounds(false);
 
   // Case 5: Only the leaf nodes are clipped. The behavior with and without
   // surfaces is the same.
   leaf_node1->SetMasksToBounds(true);
   leaf_node2->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
-  root->SetHasRenderSurface(true);
-  child1->SetHasRenderSurface(true);
-  grand_child->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(root->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_TRUE(leaf_node1->is_clipped());
   EXPECT_TRUE(leaf_node2->is_clipped());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_FALSE(root->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_TRUE(leaf_node1->is_clipped());
   EXPECT_TRUE(leaf_node2->is_clipped());
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawableContentRectForLayers) {
   // Verify that layers get the appropriate DrawableContentRect when their
-  // parent masksToBounds is true.
+  // parent MasksToBounds is true.
   //
   //   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
+  //   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
+  //   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));
+  child->test_properties()->force_render_surface = true;
+  grand_child1->SetPosition(gfx::PointF(5.f, 5.f));
+  grand_child1->SetBounds(gfx::Size(10, 10));
   grand_child1->SetDrawsContent(true);
-  LayerImpl* grand_child2 = AddChild<LayerImpl>(child);
+  grand_child2->SetPosition(gfx::PointF(15.f, 15.f));
+  grand_child2->SetBounds(gfx::Size(10, 10));
   grand_child2->SetDrawsContent(true);
-  LayerImpl* grand_child3 = AddChild<LayerImpl>(child);
+  grand_child3->SetPosition(gfx::PointF(15.f, 15.f));
+  grand_child3->SetMasksToBounds(true);
+  grand_child3->SetBounds(gfx::Size(10, 10));
   grand_child3->SetDrawsContent(true);
-  LayerImpl* grand_child4 = AddChild<LayerImpl>(child);
+  grand_child4->SetPosition(gfx::PointF(45.f, 45.f));
+  grand_child4->SetBounds(gfx::Size(10, 10));
   grand_child4->SetDrawsContent(true);
-
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(500, 500), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false,
-                               true);
-  SetLayerPropertiesForTesting(grand_child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(5.f, 5.f), gfx::Size(10, 10), true,
-                               false, false);
-  SetLayerPropertiesForTesting(grand_child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(15.f, 15.f), gfx::Size(10, 10), true,
-                               false, false);
-  SetLayerPropertiesForTesting(grand_child3, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(15.f, 15.f), gfx::Size(10, 10), true,
-                               false, false);
-  SetLayerPropertiesForTesting(grand_child4, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(45.f, 45.f), gfx::Size(10, 10), true,
-                               false, false);
-
-  child->SetMasksToBounds(true);
-  grand_child3->SetMasksToBounds(true);
-
-  // Force child to be a render surface.
-  child->test_properties()->opacity = 0.4f;
-
   ExecuteCalculateDrawProperties(parent);
 
   EXPECT_EQ(gfx::Rect(5, 5, 10, 10), grand_child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(15, 15, 5, 5), grand_child3->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(15, 15, 5, 5), grand_child3->drawable_content_rect());
   EXPECT_TRUE(grand_child4->drawable_content_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipRectIsPropagatedCorrectlyToSurfaces) {
   // Verify that render surfaces (and their layers) get the appropriate
-  // clip rects when their parent masksToBounds is true.
+  // clip rects when their parent MasksToBounds is true.
   //
   // Layers that own render surfaces (at least for now) do not inherit any
   // clipping; instead the surface will enforce the clip for the entire subtree.
   // They may still have a clip rect of their own layer bounds, however, if
-  // masksToBounds was true.
+  // MasksToBounds was true.
   LayerImpl* parent = root_layer_for_testing();
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   LayerImpl* grand_child1 = AddChild<LayerImpl>(child);
   LayerImpl* grand_child2 = AddChild<LayerImpl>(child);
   LayerImpl* grand_child3 = AddChild<LayerImpl>(child);
   LayerImpl* grand_child4 = AddChild<LayerImpl>(child);
-  // the leaf nodes ensure that these grand_children become render surfaces for
+  // The leaf nodes ensure that these grand_children become render surfaces for
   // this test.
   LayerImpl* leaf_node1 = AddChild<LayerImpl>(grand_child1);
+  LayerImpl* leaf_node2 = AddChild<LayerImpl>(grand_child2);
+  LayerImpl* leaf_node3 = AddChild<LayerImpl>(grand_child3);
+  LayerImpl* leaf_node4 = AddChild<LayerImpl>(grand_child4);
+
+  parent->SetBounds(gfx::Size(500, 500));
+  child->SetBounds(gfx::Size(20, 20));
+  child->SetMasksToBounds(true);
+  child->test_properties()->force_render_surface = true;
+  grand_child1->SetPosition(gfx::PointF(5.f, 5.f));
+  grand_child1->SetBounds(gfx::Size(10, 10));
+  grand_child1->test_properties()->force_render_surface = true;
+  grand_child2->SetPosition(gfx::PointF(15.f, 15.f));
+  grand_child2->SetBounds(gfx::Size(10, 10));
+  grand_child2->test_properties()->force_render_surface = true;
+  grand_child3->SetPosition(gfx::PointF(15.f, 15.f));
+  grand_child3->SetBounds(gfx::Size(10, 10));
+  grand_child3->SetMasksToBounds(true);
+  grand_child3->test_properties()->force_render_surface = true;
+  grand_child4->SetPosition(gfx::PointF(45.f, 45.f));
+  grand_child4->SetBounds(gfx::Size(10, 10));
+  grand_child4->SetMasksToBounds(true);
+  grand_child4->test_properties()->force_render_surface = true;
+  leaf_node1->SetBounds(gfx::Size(10, 10));
   leaf_node1->SetDrawsContent(true);
-  LayerImpl* leaf_node2 = AddChild<LayerImpl>(grand_child2);
+  leaf_node2->SetBounds(gfx::Size(10, 10));
   leaf_node2->SetDrawsContent(true);
-  LayerImpl* leaf_node3 = AddChild<LayerImpl>(grand_child3);
+  leaf_node3->SetBounds(gfx::Size(10, 10));
   leaf_node3->SetDrawsContent(true);
-  LayerImpl* leaf_node4 = AddChild<LayerImpl>(grand_child4);
+  leaf_node4->SetBounds(gfx::Size(10, 10));
   leaf_node4->SetDrawsContent(true);
-
-  const gfx::Transform identity_matrix;
-
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(500, 500), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false,
-                               true);
-  SetLayerPropertiesForTesting(grand_child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(5.f, 5.f), gfx::Size(10, 10), true,
-                               false, true);
-  SetLayerPropertiesForTesting(grand_child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(15.f, 15.f), gfx::Size(10, 10), true,
-                               false, true);
-  SetLayerPropertiesForTesting(grand_child3, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(15.f, 15.f), gfx::Size(10, 10), true,
-                               false, true);
-  SetLayerPropertiesForTesting(grand_child4, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(45.f, 45.f), gfx::Size(10, 10), true,
-                               false, true);
-  SetLayerPropertiesForTesting(leaf_node1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-  SetLayerPropertiesForTesting(leaf_node2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-  SetLayerPropertiesForTesting(leaf_node3, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-  SetLayerPropertiesForTesting(leaf_node4, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-
-  child->SetMasksToBounds(true);
-  grand_child3->SetMasksToBounds(true);
-  grand_child4->SetMasksToBounds(true);
-
-  // Force everyone to be a render surface.
-  child->test_properties()->opacity = 0.4f;
-  grand_child1->test_properties()->opacity = 0.5f;
-  grand_child2->test_properties()->opacity = 0.5f;
-  grand_child3->test_properties()->opacity = 0.5f;
-  grand_child4->test_properties()->opacity = 0.5f;
-
   ExecuteCalculateDrawProperties(parent);
 
   ASSERT_TRUE(grand_child1->render_surface());
   ASSERT_TRUE(grand_child2->render_surface());
   ASSERT_TRUE(grand_child3->render_surface());
 
   // Surfaces are clipped by their parent, but un-affected by the owning layer's
-  // masksToBounds.
+  // MasksToBounds.
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20),
             grand_child1->render_surface()->clip_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20),
             grand_child2->render_surface()->clip_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20),
             grand_child3->render_surface()->clip_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipRectWhenCannotRenderToSeparateSurface) {
   // Tests that when separate surfaces are disabled, a layer's clip_rect is the
   // intersection of all ancestor clips in screen space; in particular, if a
   // layer masks to bounds, it contributes to the clip_rect of all layers in its
   // subtree (since there are no render surfaces that can reset the clip_rect).
   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->SetPosition(gfx::PointF(2.f, 2.f));
+  parent->SetBounds(gfx::Size(400, 400));
+  child1->SetPosition(gfx::PointF(4.f, 4.f));
+  child1->SetBounds(gfx::Size(800, 800));
+  child2->SetPosition(gfx::PointF(3.f, 3.f));
+  child2->SetBounds(gfx::Size(800, 800));
+  grand_child->SetPosition(gfx::PointF(8.f, 8.f));
+  grand_child->SetBounds(gfx::Size(1500, 1500));
+  leaf_node1->SetPosition(gfx::PointF(16.f, 16.f));
+  leaf_node1->SetBounds(gfx::Size(2000, 2000));
+  leaf_node2->SetPosition(gfx::PointF(9.f, 9.f));
+  leaf_node2->SetBounds(gfx::Size(2000, 2000));
+
   root->SetDrawsContent(true);
   parent->SetDrawsContent(true);
   child1->SetDrawsContent(true);
   child2->SetDrawsContent(true);
   grand_child->SetDrawsContent(true);
   leaf_node1->SetDrawsContent(true);
   leaf_node2->SetDrawsContent(true);
 
-  const gfx::Transform identity_matrix;
-
-  // child1 and grand_child get render surfaces when surfaces are enabled.
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(2.f, 2.f), gfx::Size(400, 400), true,
-                               false);
-  SetLayerPropertiesForTesting(child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(4.f, 4.f), gfx::Size(800, 800), true,
-                               false);
-  SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(3.f, 3.f), gfx::Size(800, 800), true,
-                               false);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(8.f, 8.f), gfx::Size(1500, 1500),
-                               true, false);
-  SetLayerPropertiesForTesting(leaf_node1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(16.f, 16.f), gfx::Size(2000, 2000),
-                               true, false);
-  SetLayerPropertiesForTesting(leaf_node2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(9.f, 9.f), gfx::Size(2000, 2000),
-                               true, false);
+  root->test_properties()->force_render_surface = true;
+  child1->test_properties()->force_render_surface = true;
+  grand_child->test_properties()->force_render_surface = true;
 
   // Case 1: Nothing is clipped. In this case, each layer's clip rect is its
   // bounds in target space. The only thing that changes when surfaces are
   // disabled is that target space is always screen space.
-  root->test_properties()->force_render_surface = true;
-  child1->test_properties()->force_render_surface = true;
-  grand_child->test_properties()->force_render_surface = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_FALSE(parent->has_render_surface());
   EXPECT_TRUE(child1->has_render_surface());
   EXPECT_FALSE(child2->has_render_surface());
   EXPECT_TRUE(grand_child->has_render_surface());
   EXPECT_FALSE(leaf_node1->has_render_surface());
   EXPECT_FALSE(leaf_node2->has_render_surface());
   EXPECT_FALSE(root->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
@@ skipping 120 matching lines @@
   EXPECT_EQ(gfx::Rect(2, 2, 400, 400), leaf_node2->clip_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingWhenSurfacesDisabled) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   LayerImpl* leaf_node = AddChild<LayerImpl>(grand_child);
 
+  root->SetBounds(gfx::Size(100, 100));
+  parent->SetPosition(gfx::PointF(2.f, 2.f));
+  parent->SetBounds(gfx::Size(400, 400));
+  parent->SetMasksToBounds(true);
+  child->SetPosition(gfx::PointF(4.f, 4.f));
+  child->SetBounds(gfx::Size(800, 800));
+  child->SetMasksToBounds(true);
+  child->test_properties()->force_render_surface = true;
+  grand_child->SetPosition(gfx::PointF(8.f, 8.f));
+  grand_child->SetBounds(gfx::Size(1500, 1500));
+  grand_child->test_properties()->force_render_surface = true;
+  leaf_node->SetPosition(gfx::PointF(16.f, 16.f));
+  leaf_node->SetBounds(gfx::Size(2000, 2000));
+
   root->SetDrawsContent(true);
   parent->SetDrawsContent(true);
   child->SetDrawsContent(true);
   grand_child->SetDrawsContent(true);
   leaf_node->SetDrawsContent(true);
 
-  const gfx::Transform identity_matrix;
-
-  // child and grand_child will get render surfaces if surfaces are enabled.
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(2.f, 2.f), gfx::Size(400, 400), true,
-                               false, false);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(4.f, 4.f), gfx::Size(800, 800), true,
-                               false, true);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(8.f, 8.f), gfx::Size(1500, 1500),
-                               true, false, true);
-  SetLayerPropertiesForTesting(leaf_node, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(16.f, 16.f), gfx::Size(2000, 2000),
-                               true, false, false);
-
-  parent->SetMasksToBounds(true);
-  child->SetMasksToBounds(true);
-
-  root->SetHasRenderSurface(true);
-  child->SetHasRenderSurface(true);
-  grand_child->SetHasRenderSurface(true);
-
   host_impl()->set_resourceless_software_draw_for_testing();
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   gfx::PointF test_point(90.f, 90.f);
   LayerImpl* result_layer =
       root->layer_tree_impl()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(leaf_node, result_layer);
 }
 
 TEST_F(LayerTreeHostCommonTest, SurfacesDisabledAndReEnabled) {
   // Tests that draw properties are computed correctly when we disable and then
   // re-enable separate surfaces.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   LayerImpl* leaf_node = AddChild<LayerImpl>(grand_child);
 
+  root->SetBounds(gfx::Size(100, 100));
+  parent->SetPosition(gfx::PointF(2.f, 2.f));
+  parent->SetBounds(gfx::Size(400, 400));
+  parent->SetMasksToBounds(true);
+  child->SetPosition(gfx::PointF(4.f, 4.f));
+  child->SetBounds(gfx::Size(800, 800));
+  child->SetMasksToBounds(true);
+  child->test_properties()->force_render_surface = true;
+  grand_child->SetPosition(gfx::PointF(8.f, 8.f));
+  grand_child->SetBounds(gfx::Size(1500, 1500));
+  grand_child->test_properties()->force_render_surface = true;
+  leaf_node->SetPosition(gfx::PointF(16.f, 16.f));
+  leaf_node->SetBounds(gfx::Size(2000, 2000));
+
   root->SetDrawsContent(true);
   parent->SetDrawsContent(true);
   child->SetDrawsContent(true);
   grand_child->SetDrawsContent(true);
   leaf_node->SetDrawsContent(true);
 
-  const gfx::Transform identity_matrix;
-
-  // child and grand_child get render surfaces when surfaces are enabled.
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(2.f, 2.f), gfx::Size(400, 400), true,
-                               false, false);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(4.f, 4.f), gfx::Size(800, 800), true,
-                               false, true);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(8.f, 8.f), gfx::Size(1500, 1500),
-                               true, false, true);
-  SetLayerPropertiesForTesting(leaf_node, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(16.f, 16.f), gfx::Size(2000, 2000),
-                               true, false, false);
-
-  parent->SetMasksToBounds(true);
-  child->SetMasksToBounds(true);
-
-  root->SetHasRenderSurface(true);
-  child->SetHasRenderSurface(true);
-  grand_child->SetHasRenderSurface(true);
-
   gfx::Transform expected_leaf_draw_transform_with_surfaces;
   expected_leaf_draw_transform_with_surfaces.Translate(16.0, 16.0);
 
   gfx::Transform expected_leaf_draw_transform_without_surfaces;
   expected_leaf_draw_transform_without_surfaces.Translate(30.0, 30.0);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(leaf_node->is_clipped());
   EXPECT_TRUE(leaf_node->render_target()->is_clipped());
   EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node->drawable_content_rect());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_leaf_draw_transform_with_surfaces,
                                   leaf_node->DrawTransform());
 
-  root->SetHasRenderSurface(true);
-  child->SetHasRenderSurface(true);
-  grand_child->SetHasRenderSurface(true);
-
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_TRUE(leaf_node->is_clipped());
   EXPECT_EQ(gfx::Rect(6, 6, 396, 396), leaf_node->clip_rect());
   EXPECT_EQ(gfx::Rect(30, 30, 372, 372), leaf_node->drawable_content_rect());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_leaf_draw_transform_without_surfaces,
                                   leaf_node->DrawTransform());
 
-  root->SetHasRenderSurface(true);
-  child->SetHasRenderSurface(true);
-  grand_child->SetHasRenderSurface(true);
-
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(leaf_node->is_clipped());
   EXPECT_TRUE(leaf_node->render_target()->is_clipped());
   EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node->drawable_content_rect());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_leaf_draw_transform_with_surfaces,
                                   leaf_node->DrawTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, AnimationsForRenderSurfaceHierarchy) {
-  LayerImpl* parent = root_layer_for_testing();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
   LayerImpl* child_of_rs1 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* grand_child_of_rs1 = AddChild<LayerImpl>(child_of_rs1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* child_of_rs2 = AddChild<LayerImpl>(render_surface2);
   LayerImpl* grand_child_of_rs2 = AddChild<LayerImpl>(child_of_rs2);
   LayerImpl* child_of_root = AddChildToRoot<LayerImpl>();
   LayerImpl* grand_child_of_root = AddChild<LayerImpl>(child_of_root);
 
-  parent->SetDrawsContent(true);
+  root->SetDrawsContent(true);
   render_surface1->SetDrawsContent(true);
   child_of_rs1->SetDrawsContent(true);
   grand_child_of_rs1->SetDrawsContent(true);
   render_surface2->SetDrawsContent(true);
   child_of_rs2->SetDrawsContent(true);
   grand_child_of_rs2->SetDrawsContent(true);
   child_of_root->SetDrawsContent(true);
   grand_child_of_root->SetDrawsContent(true);
 
   gfx::Transform layer_transform;
   layer_transform.Translate(1.0, 1.0);
 
-  SetLayerPropertiesForTesting(
-      parent, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
-      gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, true);
-  SetLayerPropertiesForTesting(
-      render_surface1, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
-      gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, true);
-  SetLayerPropertiesForTesting(
-      render_surface2, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
-      gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, true);
-  SetLayerPropertiesForTesting(
-      child_of_root, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
-      gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, false);
-  SetLayerPropertiesForTesting(
-      child_of_rs1, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
-      gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, false);
-  SetLayerPropertiesForTesting(
-      child_of_rs2, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
-      gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, false);
-  SetLayerPropertiesForTesting(
-      grand_child_of_root, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
-      gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, false);
-  SetLayerPropertiesForTesting(
-      grand_child_of_rs1, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
-      gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, false);
-  SetLayerPropertiesForTesting(
-      grand_child_of_rs2, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
-      gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, false);
+  root->SetTransform(layer_transform);
+  root->SetPosition(gfx::PointF(2.5f, 0.f));
+  root->SetBounds(gfx::Size(10, 10));
+  root->test_properties()->transform_origin = gfx::Point3F(0.25f, 0.f, 0.f);
+  render_surface1->SetTransform(layer_transform);
+  render_surface1->SetPosition(gfx::PointF(2.5f, 0.f));
+  render_surface1->SetBounds(gfx::Size(10, 10));
+  render_surface1->test_properties()->transform_origin =
+      gfx::Point3F(0.25f, 0.f, 0.f);
+  render_surface1->test_properties()->force_render_surface = true;
+  render_surface2->SetTransform(layer_transform);
+  render_surface2->SetPosition(gfx::PointF(2.5f, 0.f));
+  render_surface2->SetBounds(gfx::Size(10, 10));
+  render_surface2->test_properties()->transform_origin =
+      gfx::Point3F(0.25f, 0.f, 0.f);
+  render_surface2->test_properties()->force_render_surface = true;
+  child_of_root->SetTransform(layer_transform);
+  child_of_root->SetPosition(gfx::PointF(2.5f, 0.f));
+  child_of_root->SetBounds(gfx::Size(10, 10));
+  child_of_root->test_properties()->transform_origin =
+      gfx::Point3F(0.25f, 0.f, 0.f);
+  child_of_rs1->SetTransform(layer_transform);
+  child_of_rs1->SetPosition(gfx::PointF(2.5f, 0.f));
+  child_of_rs1->SetBounds(gfx::Size(10, 10));
+  child_of_rs1->test_properties()->transform_origin =
+      gfx::Point3F(0.25f, 0.f, 0.f);
+  child_of_rs2->SetTransform(layer_transform);
+  child_of_rs2->SetPosition(gfx::PointF(2.5f, 0.f));
+  child_of_rs2->SetBounds(gfx::Size(10, 10));
+  child_of_rs2->test_properties()->transform_origin =
+      gfx::Point3F(0.25f, 0.f, 0.f);
+  grand_child_of_root->SetTransform(layer_transform);
+  grand_child_of_root->SetPosition(gfx::PointF(2.5f, 0.f));
+  grand_child_of_root->SetBounds(gfx::Size(10, 10));
+  grand_child_of_root->test_properties()->transform_origin =
+      gfx::Point3F(0.25f, 0.f, 0.f);
+  grand_child_of_rs1->SetTransform(layer_transform);
+  grand_child_of_rs1->SetPosition(gfx::PointF(2.5f, 0.f));
+  grand_child_of_rs1->SetBounds(gfx::Size(10, 10));
+  grand_child_of_rs1->test_properties()->transform_origin =
+      gfx::Point3F(0.25f, 0.f, 0.f);
+  grand_child_of_rs2->SetTransform(layer_transform);
+  grand_child_of_rs2->SetPosition(gfx::PointF(2.5f, 0.f));
+  grand_child_of_rs2->SetBounds(gfx::Size(10, 10));
+  grand_child_of_rs2->test_properties()->transform_origin =
+      gfx::Point3F(0.25f, 0.f, 0.f);
 
-  parent->layer_tree_impl()->BuildLayerListAndPropertyTreesForTesting();
+  root->layer_tree_impl()->BuildLayerListAndPropertyTreesForTesting();
   SetElementIdsForTesting();
 
   // Put an animated opacity on the render surface.
   AddOpacityTransitionToElementWithPlayer(
       render_surface1->element_id(), timeline_impl(), 10.0, 1.f, 0.f, false);
 
   // Also put an animated opacity on a layer without descendants.
   AddOpacityTransitionToElementWithPlayer(grand_child_of_root->element_id(),
                                           timeline_impl(), 10.0, 1.f, 0.f,
                                           false);
 
   // Put a transform animation on the render surface.
   AddAnimatedTransformToElementWithPlayer(render_surface2->element_id(),
                                           timeline_impl(), 10.0, 30, 0);
 
   // Also put transform animations on grand_child_of_root, and
   // grand_child_of_rs2
   AddAnimatedTransformToElementWithPlayer(grand_child_of_root->element_id(),
                                           timeline_impl(), 10.0, 30, 0);
   AddAnimatedTransformToElementWithPlayer(grand_child_of_rs2->element_id(),
                                           timeline_impl(), 10.0, 30, 0);
 
-  parent->layer_tree_impl()->property_trees()->needs_rebuild = true;
-  ExecuteCalculateDrawProperties(parent);
+  root->layer_tree_impl()->property_trees()->needs_rebuild = true;
+  ExecuteCalculateDrawProperties(root);
 
   // Only layers that are associated with render surfaces should have an actual
   // RenderSurface() value.
-  ASSERT_TRUE(parent->render_surface());
+  ASSERT_TRUE(root->render_surface());
   ASSERT_FALSE(child_of_root->render_surface());
   ASSERT_FALSE(grand_child_of_root->render_surface());
 
   ASSERT_TRUE(render_surface1->render_surface());
   ASSERT_FALSE(child_of_rs1->render_surface());
   ASSERT_FALSE(grand_child_of_rs1->render_surface());
 
   ASSERT_TRUE(render_surface2->render_surface());
   ASSERT_FALSE(child_of_rs2->render_surface());
   ASSERT_FALSE(grand_child_of_rs2->render_surface());
 
   // Verify all render target accessors
-  EXPECT_EQ(parent->render_surface(), parent->render_target());
-  EXPECT_EQ(parent->render_surface(), child_of_root->render_target());
-  EXPECT_EQ(parent->render_surface(), grand_child_of_root->render_target());
+  EXPECT_EQ(root->render_surface(), root->render_target());
+  EXPECT_EQ(root->render_surface(), child_of_root->render_target());
+  EXPECT_EQ(root->render_surface(), grand_child_of_root->render_target());
 
   EXPECT_EQ(render_surface1->render_surface(),
             render_surface1->render_target());
   EXPECT_EQ(render_surface1->render_surface(), child_of_rs1->render_target());
   EXPECT_EQ(render_surface1->render_surface(),
             grand_child_of_rs1->render_target());
 
   EXPECT_EQ(render_surface2->render_surface(),
             render_surface2->render_target());
   EXPECT_EQ(render_surface2->render_surface(), child_of_rs2->render_target());
   EXPECT_EQ(render_surface2->render_surface(),
             grand_child_of_rs2->render_target());
 
   // Verify screen_space_transform_is_animating values
-  EXPECT_FALSE(parent->screen_space_transform_is_animating());
+  EXPECT_FALSE(root->screen_space_transform_is_animating());
   EXPECT_FALSE(child_of_root->screen_space_transform_is_animating());
   EXPECT_TRUE(grand_child_of_root->screen_space_transform_is_animating());
   EXPECT_FALSE(render_surface1->screen_space_transform_is_animating());
   EXPECT_FALSE(child_of_rs1->screen_space_transform_is_animating());
   EXPECT_FALSE(grand_child_of_rs1->screen_space_transform_is_animating());
   EXPECT_TRUE(render_surface2->screen_space_transform_is_animating());
   EXPECT_TRUE(child_of_rs2->screen_space_transform_is_animating());
   EXPECT_TRUE(grand_child_of_rs2->screen_space_transform_is_animating());
 
   // Sanity check. If these fail there is probably a bug in the test itself.
   // It is expected that we correctly set up transforms so that the y-component
   // of the screen-space transform encodes the "depth" of the layer in the tree.
-  EXPECT_FLOAT_EQ(1.0, parent->ScreenSpaceTransform().matrix().get(1, 3));
+  EXPECT_FLOAT_EQ(1.0, root->ScreenSpaceTransform().matrix().get(1, 3));
   EXPECT_FLOAT_EQ(2.0,
                   child_of_root->ScreenSpaceTransform().matrix().get(1, 3));
   EXPECT_FLOAT_EQ(
       3.0, grand_child_of_root->ScreenSpaceTransform().matrix().get(1, 3));
 
   EXPECT_FLOAT_EQ(2.0,
                   render_surface1->ScreenSpaceTransform().matrix().get(1, 3));
   EXPECT_FLOAT_EQ(3.0, child_of_rs1->ScreenSpaceTransform().matrix().get(1, 3));
   EXPECT_FLOAT_EQ(
       4.0, grand_child_of_rs1->ScreenSpaceTransform().matrix().get(1, 3));
 
   EXPECT_FLOAT_EQ(3.0,
                   render_surface2->ScreenSpaceTransform().matrix().get(1, 3));
   EXPECT_FLOAT_EQ(4.0, child_of_rs2->ScreenSpaceTransform().matrix().get(1, 3));
   EXPECT_FLOAT_EQ(
       5.0, grand_child_of_rs2->ScreenSpaceTransform().matrix().get(1, 3));
 }
 
 TEST_F(LayerTreeHostCommonTest, LargeTransforms) {
-  LayerImpl* parent = root_layer_for_testing();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
-  grand_child->SetDrawsContent(true);
-
   gfx::Transform large_transform;
   large_transform.Scale(SkDoubleToMScalar(1e37), SkDoubleToMScalar(1e37));
 
-  gfx::Transform identity;
-
-  SetLayerPropertiesForTesting(parent, identity, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(10, 10), true, false, true);
-  SetLayerPropertiesForTesting(child, large_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-  SetLayerPropertiesForTesting(grand_child, large_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-  ExecuteCalculateDrawProperties(parent);
+  root->SetBounds(gfx::Size(10, 10));
+  child->SetTransform(large_transform);
+  child->SetBounds(gfx::Size(10, 10));
+  grand_child->SetTransform(large_transform);
+  grand_child->SetBounds(gfx::Size(10, 10));
+  grand_child->SetDrawsContent(true);
+  ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(), grand_child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        ScreenSpaceTransformIsAnimatingWithDelayedAnimation) {
-  LayerImpl* parent = root_layer_for_testing();
-  LayerImpl* child = AddChild<LayerImpl>(parent);
+  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);
 
-  parent->SetDrawsContent(true);
+  root->SetDrawsContent(true);
   child->SetDrawsContent(true);
   grand_child->SetDrawsContent(true);
   great_grand_child->SetDrawsContent(true);
 
   gfx::Transform identity;
 
-  SetLayerPropertiesForTesting(parent, 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);
-  SetLayerPropertiesForTesting(great_grand_child, identity, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
+  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,
       TargetProperty::TRANSFORM);
   animation->set_fill_mode(Animation::FillMode::NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
   AddAnimationToElementWithPlayer(grand_child->element_id(), timeline_impl(),
                                   std::move(animation));
-  ExecuteCalculateDrawProperties(parent);
+  ExecuteCalculateDrawProperties(root);
 
-  EXPECT_FALSE(parent->screen_space_transform_is_animating());
+  EXPECT_FALSE(root->screen_space_transform_is_animating());
   EXPECT_FALSE(child->screen_space_transform_is_animating());
 
   EXPECT_FALSE(grand_child->TransformIsAnimating());
   EXPECT_TRUE(grand_child->HasPotentiallyRunningTransformAnimation());
   EXPECT_TRUE(grand_child->screen_space_transform_is_animating());
   EXPECT_TRUE(great_grand_child->screen_space_transform_is_animating());
 }
 
 TEST_F(LayerTreeHostCommonDrawRectsTest, DrawRectsForIdentityTransform) {
   // Test visible layer rect and drawable content rect are calculated correctly
@@ skipping 300 matching lines @@
   LayerImpl* drawing_layer = TestVisibleRectAndDrawableContentRect(
       target_surface_rect, layer_to_surface_transform, layer_content_rect);
   EXPECT_EQ(expected_visible_layer_rect, drawing_layer->visible_layer_rect());
   EXPECT_EQ(expected_drawable_content_rect,
             drawing_layer->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleRectsForPositionedRootLayerClippedByViewport) {
   LayerImpl* root = root_layer_for_testing();
+
+  root->SetPosition(gfx::PointF(60, 70));
+  root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
-
-  gfx::Transform identity_matrix;
-  // Root layer is positioned at (60, 70). The default device viewport size
-  // is (0, 0, 100x100) in target space. So the root layer's visible rect
-  // will be clipped by the viewport to be (0, 0, 40x30) in layer's space.
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(60, 70), gfx::Size(100, 100), true,
-                               false, true);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
   // In target space, not clipped.
   EXPECT_EQ(gfx::Rect(60, 70, 100, 100), root->drawable_content_rect());
   // In layer space, clipped.
   EXPECT_EQ(gfx::Rect(40, 30), root->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsForSimpleLayers) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child1_layer = AddChildToRoot<LayerImpl>();
+  LayerImpl* child2_layer = AddChildToRoot<LayerImpl>();
+  LayerImpl* child3_layer = AddChildToRoot<LayerImpl>();
+
+  root->SetBounds(gfx::Size(100, 100));
+  child1_layer->SetBounds(gfx::Size(50, 50));
   child1_layer->SetDrawsContent(true);
-  LayerImpl* child2_layer = AddChildToRoot<LayerImpl>();
+  child2_layer->SetPosition(gfx::PointF(75.f, 75.f));
+  child2_layer->SetBounds(gfx::Size(50, 50));
   child2_layer->SetDrawsContent(true);
-  LayerImpl* child3_layer = AddChildToRoot<LayerImpl>();
+  child3_layer->SetPosition(gfx::PointF(125.f, 125.f));
+  child3_layer->SetBounds(gfx::Size(50, 50));
   child3_layer->SetDrawsContent(true);
-
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child1_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
-  SetLayerPropertiesForTesting(child2_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(75.f, 75.f), gfx::Size(50, 50), true,
-                               false, false);
-  SetLayerPropertiesForTesting(child3_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
-                               true, false, false);
-
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
 
   // Layers that do not draw content should have empty visible_layer_rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
 
   // layer visible_layer_rects are clipped by their target surface.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1_layer->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2_layer->visible_layer_rect());
   EXPECT_TRUE(child3_layer->visible_layer_rect().IsEmpty());
 
   // layer drawable_content_rects are not clipped.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1_layer->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2_layer->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3_layer->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsForLayersClippedByLayer) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   LayerImpl* grand_child1 = AddChild<LayerImpl>(child);
+  LayerImpl* grand_child2 = AddChild<LayerImpl>(child);
+  LayerImpl* grand_child3 = AddChild<LayerImpl>(child);
+
+  root->SetBounds(gfx::Size(100, 100));
+  child->SetBounds(gfx::Size(100, 100));
+  child->SetMasksToBounds(true);
+  grand_child1->SetPosition(gfx::PointF(5.f, 5.f));
+  grand_child1->SetBounds(gfx::Size(50, 50));
   grand_child1->SetDrawsContent(true);
-  LayerImpl* grand_child2 = AddChild<LayerImpl>(child);
+  grand_child2->SetPosition(gfx::PointF(75.f, 75.f));
+  grand_child2->SetBounds(gfx::Size(50, 50));
   grand_child2->SetDrawsContent(true);
-  LayerImpl* grand_child3 = AddChild<LayerImpl>(child);
+  grand_child3->SetPosition(gfx::PointF(125.f, 125.f));
+  grand_child3->SetBounds(gfx::Size(50, 50));
   grand_child3->SetDrawsContent(true);
-
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
-  SetLayerPropertiesForTesting(grand_child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(5.f, 5.f), gfx::Size(50, 50), true,
-                               false, false);
-  SetLayerPropertiesForTesting(grand_child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(75.f, 75.f), gfx::Size(50, 50), true,
-                               false, false);
-  SetLayerPropertiesForTesting(grand_child3, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
-                               true, false, false);
-
-  child->SetMasksToBounds(true);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
 
   // Layers that do not draw content should have empty visible content rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), child->visible_layer_rect());
 
   // All grandchild visible content rects should be clipped by child.
@@ skipping 10 matching lines @@
 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);
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, child_scale_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false,
-                               false);
-  SetLayerPropertiesForTesting(grand_child, grand_child_scale_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false, false);
 
+  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);
+  grand_child->SetBounds(gfx::Size(100, 100));
   grand_child->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
   // The visible rect is expanded to integer coordinates.
   EXPECT_EQ(gfx::Rect(41, 41), grand_child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsForLayersInUnclippedRenderSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* child1 = AddChild<LayerImpl>(render_surface);
+  LayerImpl* child2 = AddChild<LayerImpl>(render_surface);
+  LayerImpl* child3 = AddChild<LayerImpl>(render_surface);
+
+  root->SetBounds(gfx::Size(100, 100));
+  render_surface->SetBounds(gfx::Size(3, 4));
+  render_surface->test_properties()->force_render_surface = true;
+  child1->SetPosition(gfx::PointF(5.f, 5.f));
+  child1->SetBounds(gfx::Size(50, 50));
   child1->SetDrawsContent(true);
-  LayerImpl* child2 = AddChild<LayerImpl>(render_surface);
+  child2->SetPosition(gfx::PointF(75.f, 75.f));
+  child2->SetBounds(gfx::Size(50, 50));
   child2->SetDrawsContent(true);
-  LayerImpl* child3 = AddChild<LayerImpl>(render_surface);
+  child3->SetPosition(gfx::PointF(125.f, 125.f));
+  child3->SetBounds(gfx::Size(50, 50));
   child3->SetDrawsContent(true);
-
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(3, 4), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(5.f, 5.f), gfx::Size(50, 50), true,
-                               false, false);
-  SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(75.f, 75.f), gfx::Size(50, 50), true,
-                               false, false);
-  SetLayerPropertiesForTesting(child3, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
-                               true, false, false);
-
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(render_surface->render_surface());
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
 
   // Layers that do not draw content should have empty visible content rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface->visible_layer_rect());
@@ skipping 17 matching lines @@
        DrawableAndVisibleRectsWhenCannotRenderToSeparateSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child1 = AddChild<LayerImpl>(parent);
   LayerImpl* child2 = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child1 = AddChild<LayerImpl>(child1);
   LayerImpl* grand_child2 = AddChild<LayerImpl>(child2);
   LayerImpl* leaf_node1 = AddChild<LayerImpl>(grand_child1);
   LayerImpl* leaf_node2 = AddChild<LayerImpl>(grand_child2);
 
+  root->SetBounds(gfx::Size(100, 100));
+  parent->SetPosition(gfx::PointF(2.f, 2.f));
+  parent->SetBounds(gfx::Size(400, 400));
+  child1->SetPosition(gfx::PointF(4.f, 4.f));
+  child1->SetBounds(gfx::Size(800, 800));
+  child1->test_properties()->force_render_surface = true;
+  child2->SetPosition(gfx::PointF(3.f, 3.f));
+  child2->SetBounds(gfx::Size(800, 800));
+  child2->test_properties()->force_render_surface = true;
+  grand_child1->SetPosition(gfx::PointF(8.f, 8.f));
+  grand_child1->SetBounds(gfx::Size(1500, 1500));
+  grand_child2->SetPosition(gfx::PointF(7.f, 7.f));
+  grand_child2->SetBounds(gfx::Size(1500, 1500));
+  leaf_node1->SetPosition(gfx::PointF(16.f, 16.f));
+  leaf_node1->SetBounds(gfx::Size(2000, 2000));
+  leaf_node2->SetPosition(gfx::PointF(9.f, 9.f));
+  leaf_node2->SetBounds(gfx::Size(2000, 2000));
+
   root->SetDrawsContent(true);
   parent->SetDrawsContent(true);
   child1->SetDrawsContent(true);
   child2->SetDrawsContent(true);
   grand_child1->SetDrawsContent(true);
   grand_child2->SetDrawsContent(true);
   leaf_node1->SetDrawsContent(true);
   leaf_node2->SetDrawsContent(true);
 
-  const gfx::Transform identity_matrix;
-
-  // child1 and child2 get render surfaces when surfaces are enabled.
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(2.f, 2.f), gfx::Size(400, 400), true,
-                               false, false);
-  SetLayerPropertiesForTesting(child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(4.f, 4.f), gfx::Size(800, 800), true,
-                               false, true);
-  SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(3.f, 3.f), gfx::Size(800, 800), true,
-                               false, true);
-  SetLayerPropertiesForTesting(grand_child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(8.f, 8.f), gfx::Size(1500, 1500),
-                               true, false, false);
-  SetLayerPropertiesForTesting(grand_child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(7.f, 7.f), gfx::Size(1500, 1500),
-                               true, false, false);
-  SetLayerPropertiesForTesting(leaf_node1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(16.f, 16.f), gfx::Size(2000, 2000),
-                               true, false, false);
-  SetLayerPropertiesForTesting(leaf_node2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(9.f, 9.f), gfx::Size(2000, 2000),
-                               true, false, false);
-
   // Case 1: No layers clip. Visible rects are clipped by the viewport, but the
   // viewport clip doesn't apply to layers that draw into unclipped surfaces.
   // Each layer's drawable content rect is its bounds in target space; the only
   // thing that changes with surfaces disabled is that target space is always
   // screen space.
   root->SetHasRenderSurface(true);
   child1->SetHasRenderSurface(true);
   child2->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(100, 100), root->visible_layer_rect());
@@ skipping 36 matching lines @@
   EXPECT_EQ(gfx::Rect(21, 21, 2000, 2000), leaf_node2->drawable_content_rect());
 
   // Case 2: The parent clips. In this case, neither surface is unclipped, so
   // all visible layer rects are clipped by the intersection of all ancestor
   // clips, whether or not surfaces are disabled. However, drawable content
   // rects are clipped only until the next render surface is reached, so
   // descendants of parent have their drawable content rects clipped only when
   // surfaces are disabled.
   parent->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
-  root->SetHasRenderSurface(true);
-  child1->SetHasRenderSurface(true);
-  child2->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(100, 100), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(98, 98), parent->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(94, 94), child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(95, 95), child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(86, 86), grand_child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(88, 88), grand_child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(70, 70), leaf_node1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(79, 79), leaf_node2->visible_layer_rect());
 
@@ skipping 27 matching lines @@
 
   parent->SetMasksToBounds(false);
 
   // Case 3: child1 and grand_child2 clip. In this case, descendants of these
   // layers have their visible rects clipped by them; without surfaces, these
   // rects are also clipped by the viewport. Similarly, descendants of these
   // layers have their drawable content rects clipped by them.
   child1->SetMasksToBounds(true);
   grand_child2->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
-  root->SetHasRenderSurface(true);
-  child1->SetHasRenderSurface(true);
-  child2->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(100, 100), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(98, 98), parent->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(800, 800), child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(800, 800), child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(792, 792), grand_child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(1500, 1500), grand_child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(776, 776), leaf_node1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(1491, 1491), leaf_node2->visible_layer_rect());
 
@@ skipping 26 matching lines @@
   EXPECT_EQ(gfx::Rect(30, 30, 776, 776), leaf_node1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(21, 21, 1491, 1491), leaf_node2->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleContentRectsForClippedSurfaceWithEmptyClip) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child1 = AddChild<LayerImpl>(root);
   LayerImpl* child2 = AddChild<LayerImpl>(root);
   LayerImpl* child3 = AddChild<LayerImpl>(root);
+
+  root->SetBounds(gfx::Size(100, 100));
+  child1->SetPosition(gfx::PointF(5.f, 5.f));
+  child1->SetBounds(gfx::Size(50, 50));
   child1->SetDrawsContent(true);
+  child2->SetPosition(gfx::PointF(75.f, 75.f));
+  child2->SetBounds(gfx::Size(50, 50));
   child2->SetDrawsContent(true);
+  child3->SetPosition(gfx::PointF(125.f, 125.f));
+  child3->SetBounds(gfx::Size(50, 50));
   child3->SetDrawsContent(true);
 
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(5.f, 5.f), gfx::Size(50, 50), true,
-                               false, false);
-  SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(75.f, 75.f), gfx::Size(50, 50), true,
-                               false, false);
-  SetLayerPropertiesForTesting(child3, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
-                               true, false, false);
-
   LayerImplList render_surface_layer_list_impl;
   // Now set the root render surface an empty clip.
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root, gfx::Size(), &render_surface_layer_list_impl);
 
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
   ASSERT_TRUE(root->render_surface());
   EXPECT_FALSE(root->is_clipped());
 
   gfx::Rect empty;
   EXPECT_EQ(empty, root->render_surface()->clip_rect());
   EXPECT_TRUE(root->render_surface()->is_clipped());
 
   // Visible content rect calculation will check if the target surface is
   // clipped or not. An empty clip rect does not indicate the render surface
   // is unclipped.
   EXPECT_EQ(empty, child1->visible_layer_rect());
   EXPECT_EQ(empty, child2->visible_layer_rect());
   EXPECT_EQ(empty, child3->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        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());
 
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, uninvertible_matrix, gfx::Point3F(),
-                               gfx::PointF(5.f, 5.f), gfx::Size(50, 50), true,
-                               false, false);
-
+  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
   // to the CSS spec.
   uninvertible_matrix.MakeIdentity();
   uninvertible_matrix.matrix().set(2, 2, 0.0);
   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
 
-  SetLayerPropertiesForTesting(child, uninvertible_matrix, gfx::Point3F(),
-                               gfx::PointF(5.f, 5.f), gfx::Size(50, 50), true,
-                               false, false);
-
+  child->SetTransform(uninvertible_matrix);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(child->visible_layer_rect().IsEmpty());
   EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
 
   // Case 3: a matrix with flattened z, also uninvertible and not visible.
   uninvertible_matrix.MakeIdentity();
   uninvertible_matrix.Translate(500.0, 0.0);
   uninvertible_matrix.matrix().set(2, 2, 0.0);
   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
 
-  SetLayerPropertiesForTesting(child, uninvertible_matrix, gfx::Point3F(),
-                               gfx::PointF(5.f, 5.f), gfx::Size(50, 50), true,
-                               false, false);
-
+  child->SetTransform(uninvertible_matrix);
   ExecuteCalculateDrawProperties(root);
 
   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);
-  child->SetDrawsContent(true);
-  grand_child->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
 
   gfx::Transform perspective;
   perspective.ApplyPerspectiveDepth(SkDoubleToMScalar(1e-12));
 
   gfx::Transform rotation;
   rotation.RotateAboutYAxis(45.0);
 
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, perspective, gfx::Point3F(),
-                               gfx::PointF(10.f, 10.f), gfx::Size(100, 100),
-                               false, true, false);
-  SetLayerPropertiesForTesting(grand_child, rotation, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), false, true,
-                               false);
-
+  root->SetBounds(gfx::Size(100, 100));
+  child->SetTransform(perspective);
+  child->SetPosition(gfx::PointF(10.f, 10.f));
+  child->SetBounds(gfx::Size(100, 100));
+  child->SetDrawsContent(true);
+  child->Set3dSortingContextId(1);
+  child->test_properties()->should_flatten_transform = false;
+  grand_child->SetTransform(rotation);
+  grand_child->SetBounds(gfx::Size(100, 100));
+  grand_child->SetDrawsContent(true);
+  grand_child->Set3dSortingContextId(1);
+  grand_child->test_properties()->should_flatten_transform = false;
   ExecuteCalculateDrawProperties(root);
 
   // Though all layers have invertible transforms, matrix multiplication using
   // floating-point math makes the draw transform uninvertible.
   EXPECT_FALSE(root->layer_tree_impl()
                    ->property_trees()
                    ->transform_tree.Node(grand_child->transform_tree_index())
                    ->ancestors_are_invertible);
 
   // CalcDrawProps skips a subtree when a layer's screen space transform is
@@ skipping 24 matching lines @@
 
   surface->SetDrawsContent(true);
   surface_child->SetDrawsContent(true);
   surface_sibling->SetDrawsContent(true);
   surface_child_mask->SetDrawsContent(true);
   surface->SetContentsOpaque(true);
   surface_child->SetContentsOpaque(true);
   surface_sibling->SetContentsOpaque(true);
   surface_child_mask->SetContentsOpaque(true);
 
-  surface->test_properties()->opacity = 0.5f;
-  surface_child->test_properties()->opacity = 0.6f;
-
-  gfx::Transform identity_matrix;
   gfx::Transform translate;
   translate.Translate(20.f, 20.f);
 
-  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1000, 1000), true,
-                               false, true);
-  SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(300, 300), false, true,
-                               false);
-  SetLayerPropertiesForTesting(surface.get(), translate, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(300, 300), false, true,
-                               true);
-  SetLayerPropertiesForTesting(surface_child.get(), identity_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(300, 300), false, false, true);
-  SetLayerPropertiesForTesting(surface_sibling.get(), identity_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(200, 200), false, false, false);
+  root->SetBounds(gfx::Size(1000, 1000));
+  child->SetBounds(gfx::Size(300, 300));
+  surface->SetTransform(translate);
+  surface->SetBounds(gfx::Size(300, 300));
+  surface->test_properties()->force_render_surface = true;
+  surface_child->SetBounds(gfx::Size(300, 300));
+  surface_child->test_properties()->force_render_surface = true;
+  surface_sibling->SetBounds(gfx::Size(200, 200));
 
   LayerImpl* surface_ptr = surface.get();
   LayerImpl* surface_child_ptr = surface_child.get();
   LayerImpl* surface_child_mask_ptr = surface_child_mask.get();
 
   host_impl.SetViewportSize(root->bounds());
 
   surface_child->test_properties()->SetMaskLayer(std::move(surface_child_mask));
   surface->test_properties()->AddChild(std::move(surface_child));
   child->test_properties()->AddChild(std::move(surface));
@@ skipping 32 matching lines @@
                                   &task_graph_runner);
 
   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);
-  child->SetDrawsContent(true);
-  grand_child->SetDrawsContent(true);
-  occluding_child->SetDrawsContent(true);
-  occluding_child->SetContentsOpaque(true);
 
   gfx::Transform identity_matrix;
   gfx::Transform perspective;
   perspective.ApplyPerspectiveDepth(SkDoubleToMScalar(1e-12));
 
   gfx::Transform rotation;
   rotation.RotateAboutYAxis(45.0);
 
-  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1000, 1000), true,
-                               false, true);
-  SetLayerPropertiesForTesting(child.get(), perspective, gfx::Point3F(),
-                               gfx::PointF(10.f, 10.f), gfx::Size(300, 300),
-                               false, true, false);
-  SetLayerPropertiesForTesting(grand_child.get(), rotation, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(200, 200), false, true,
-                               false);
-  SetLayerPropertiesForTesting(occluding_child.get(), identity_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(200, 200), false, false, false);
+  root->SetBounds(gfx::Size(1000, 1000));
+  child->SetTransform(perspective);
+  child->SetPosition(gfx::PointF(10.f, 10.f));
+  child->SetBounds(gfx::Size(300, 300));
+  child->test_properties()->should_flatten_transform = false;
+  child->Set3dSortingContextId(1);
+  grand_child->SetTransform(rotation);
+  grand_child->SetBounds(gfx::Size(200, 200));
+  grand_child->test_properties()->should_flatten_transform = false;
+  grand_child->Set3dSortingContextId(1);
+  occluding_child->SetBounds(gfx::Size(200, 200));
+  occluding_child->test_properties()->should_flatten_transform = false;
+
+  child->SetDrawsContent(true);
+  grand_child->SetDrawsContent(true);
+  occluding_child->SetDrawsContent(true);
+  occluding_child->SetContentsOpaque(true);
 
   host_impl.SetViewportSize(root->bounds());
 
   child->test_properties()->AddChild(std::move(grand_child));
   root->test_properties()->AddChild(std::move(child));
   root->test_properties()->AddChild(std::move(occluding_child));
   host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
   host_impl.SetVisible(true);
   host_impl.InitializeRenderer(output_surface.get());
   host_impl.active_tree()->BuildLayerListAndPropertyTreesForTesting();
@@ skipping 23 matching lines @@
       layer_bounds,
       grand_child_ptr->draw_properties()
           .occlusion_in_content_space.GetUnoccludedContentRect(layer_bounds));
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsForLayersInClippedRenderSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* child1 = AddChild<LayerImpl>(render_surface);
+  LayerImpl* child2 = AddChild<LayerImpl>(render_surface);
+  LayerImpl* child3 = AddChild<LayerImpl>(render_surface);
+
+  root->SetBounds(gfx::Size(100, 100));
+  root->SetMasksToBounds(true);
+  render_surface->SetBounds(gfx::Size(3, 4));
+  render_surface->test_properties()->force_render_surface = true;
+  child1->SetPosition(gfx::PointF(5.f, 5.f));
+  child1->SetBounds(gfx::Size(50, 50));
   child1->SetDrawsContent(true);
-  LayerImpl* child2 = AddChild<LayerImpl>(render_surface);
+  child2->SetPosition(gfx::PointF(75.f, 75.f));
+  child2->SetBounds(gfx::Size(50, 50));
   child2->SetDrawsContent(true);
-  LayerImpl* child3 = AddChild<LayerImpl>(render_surface);
+  child3->SetPosition(gfx::PointF(125.f, 125.f));
+  child3->SetBounds(gfx::Size(50, 50));
   child3->SetDrawsContent(true);
-
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(3, 4), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(5.f, 5.f), gfx::Size(50, 50), true,
-                               false, false);
-  SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(75.f, 75.f), gfx::Size(50, 50), true,
-                               false, false);
-  SetLayerPropertiesForTesting(child3, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
-                               true, false, false);
-
-  root->SetMasksToBounds(true);
-
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(render_surface->render_surface());
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
 
   // Layers that do not draw content should have empty visible content rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface->visible_layer_rect());
@@ skipping 15 matching lines @@
   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsForSurfaceHierarchy) {
   // Check that clipping does not propagate down surfaces.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface2 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* child1 = AddChild<LayerImpl>(render_surface2);
+  LayerImpl* child2 = AddChild<LayerImpl>(render_surface2);
+  LayerImpl* child3 = AddChild<LayerImpl>(render_surface2);
+
+  root->SetBounds(gfx::Size(100, 100));
+  root->SetMasksToBounds(true);
+  render_surface1->SetBounds(gfx::Size(3, 4));
+  render_surface1->test_properties()->force_render_surface = true;
+  render_surface2->SetBounds(gfx::Size(7, 13));
+  render_surface2->test_properties()->force_render_surface = true;
+  child1->SetPosition(gfx::PointF(5.f, 5.f));
+  child1->SetBounds(gfx::Size(50, 50));
   child1->SetDrawsContent(true);
-  LayerImpl* child2 = AddChild<LayerImpl>(render_surface2);
+  child2->SetPosition(gfx::PointF(75.f, 75.f));
+  child2->SetBounds(gfx::Size(50, 50));
   child2->SetDrawsContent(true);
-  LayerImpl* child3 = AddChild<LayerImpl>(render_surface2);
+  child3->SetPosition(gfx::PointF(125.f, 125.f));
+  child3->SetBounds(gfx::Size(50, 50));
   child3->SetDrawsContent(true);
-
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(3, 4), true, false,
-                               true);
-  SetLayerPropertiesForTesting(render_surface2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(7, 13), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(5.f, 5.f), gfx::Size(50, 50), true,
-                               false, false);
-  SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(75.f, 75.f), gfx::Size(50, 50), true,
-                               false, false);
-  SetLayerPropertiesForTesting(child3, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
-                               true, false, false);
-
-  root->SetMasksToBounds(true);
-
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(render_surface1->render_surface());
   ASSERT_TRUE(render_surface2->render_surface());
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
 
   // Layers that do not draw content should have empty visible content rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
@@ skipping 22 matching lines @@
   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleRectsForClippedDescendantsOfUnclippedSurfaces) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
   LayerImpl* child1 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* child2 = AddChild<LayerImpl>(child1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(child2);
+
+  root->SetBounds(gfx::Size(100, 100));
+  render_surface1->SetBounds(gfx::Size(100, 100));
+  render_surface1->test_properties()->force_render_surface = true;
+  child1->SetBounds(gfx::Size(500, 500));
   child1->SetDrawsContent(true);
+  child2->SetBounds(gfx::Size(700, 700));
   child2->SetDrawsContent(true);
+  render_surface2->SetBounds(gfx::Size(1000, 1000));
+  render_surface2->test_properties()->force_render_surface = true;
   render_surface2->SetDrawsContent(true);
 
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(500, 500), true, false,
-                               false);
-  SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(700, 700), true, false,
-                               false);
-  SetLayerPropertiesForTesting(render_surface2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1000, 1000), true,
-                               false, true);
-
   child1->SetMasksToBounds(true);
   child2->SetMasksToBounds(true);
-
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(500, 500), child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(100, 100), render_surface2->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleRectsWhenClipChildIsBetweenTwoRenderSurfaces) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(clip_child);
 
+  root->SetBounds(gfx::Size(100, 100));
+
+  clip_parent->SetBounds(gfx::Size(50, 50));
+  clip_parent->SetMasksToBounds(true);
+  clip_parent->test_properties()->clip_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  clip_parent->test_properties()->clip_children->insert(clip_child);
+
+  render_surface1->SetBounds(gfx::Size(20, 20));
+  render_surface1->SetMasksToBounds(true);
   render_surface1->SetDrawsContent(true);
-  render_surface2->SetDrawsContent(true);
+  render_surface1->test_properties()->force_render_surface = true;
+
+  clip_child->SetBounds(gfx::Size(60, 60));
   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());
 
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
-  SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(60, 60), true, false,
-                               false);
-  SetLayerPropertiesForTesting(render_surface2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(60, 60), true, false,
-                               true);
-  clip_parent->SetMasksToBounds(true);
-  render_surface1->SetMasksToBounds(true);
+  render_surface2->SetBounds(gfx::Size(60, 60));
+  render_surface2->SetDrawsContent(true);
+  render_surface2->test_properties()->force_render_surface = true;
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(20, 20), render_surface1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(50, 50), clip_child->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(50, 50), render_surface2->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipRectOfSurfaceWhoseParentIsAClipChild) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(clip_child);
 
+  root->SetBounds(gfx::Size(100, 100));
+
+  clip_parent->SetPosition(gfx::PointF(2.f, 2.f));
+  clip_parent->SetBounds(gfx::Size(50, 50));
+  clip_parent->test_properties()->clip_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  clip_parent->test_properties()->clip_children->insert(clip_child);
+
+  render_surface1->SetBounds(gfx::Size(20, 20));
   render_surface1->SetDrawsContent(true);
-  render_surface2->SetDrawsContent(true);
+  render_surface1->test_properties()->force_render_surface = true;
+
+  clip_child->SetBounds(gfx::Size(60, 60));
   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());
 
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(2.f, 2.f), gfx::Size(50, 50), true,
-                               false, false);
-  SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(20, 20), true, false,
-                               true);
-  SetLayerPropertiesForTesting(clip_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(60, 60), true, false,
-                               false);
-  SetLayerPropertiesForTesting(render_surface2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(60, 60), true, false,
-                               true);
+  render_surface2->SetBounds(gfx::Size(60, 60));
+  render_surface2->SetDrawsContent(true);
+  render_surface2->test_properties()->force_render_surface = true;
+
   clip_parent->SetMasksToBounds(true);
   render_surface1->SetMasksToBounds(true);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(50, 50), render_surface2->render_surface()->clip_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceContentRectWhenLayerNotDrawn) {
   // Test that only drawn layers contribute to render surface content rect.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* surface = AddChildToRoot<LayerImpl>();
   LayerImpl* test_layer = AddChild<LayerImpl>(surface);
 
-  test_layer->SetDrawsContent(false);
+  root->SetBounds(gfx::Size(200, 200));
+  surface->SetBounds(gfx::Size(100, 100));
   surface->SetDrawsContent(true);
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(200, 200), true, false,
-                               true);
-  SetLayerPropertiesForTesting(surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(test_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(150, 150), true, false,
-                               false);
+  surface->test_properties()->force_render_surface = true;
+  test_layer->SetBounds(gfx::Size(150, 150));
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(100, 100), surface->render_surface()->content_rect());
 
   test_layer->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(150, 150), surface->render_surface()->content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleRectsMultipleSurfaces) {
   // Tests visible rects computation when we have unclipped_surface->
   // surface_with_unclipped_descendants->clipped_surface, checks that the bounds
   // of surface_with_unclipped_descendants doesn't propagate to the
   // clipped_surface below it.
   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* clip_child = AddChild<LayerImpl>(unclipped_desc_surface);
   LayerImpl* clipped_surface = AddChild<LayerImpl>(clip_child);
 
+  root->SetBounds(gfx::Size(100, 100));
+
+  unclipped_surface->SetBounds(gfx::Size(30, 30));
   unclipped_surface->SetDrawsContent(true);
+  unclipped_surface->test_properties()->force_render_surface = true;
+
+  clip_parent->SetBounds(gfx::Size(50, 50));
+  clip_parent->test_properties()->clip_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  clip_parent->test_properties()->clip_children->insert(clip_child);
+
+  unclipped_desc_surface->SetBounds(gfx::Size(20, 20));
   unclipped_desc_surface->SetDrawsContent(true);
+  unclipped_desc_surface->test_properties()->force_render_surface = true;
+
+  clip_child->SetBounds(gfx::Size(60, 60));
+  clip_child->test_properties()->clip_parent = clip_parent;
+
+  clipped_surface->SetBounds(gfx::Size(60, 60));
   clipped_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());
+  clipped_surface->test_properties()->force_render_surface = true;
 
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(unclipped_surface, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               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(20, 20),
-                               true, false, true);
-  SetLayerPropertiesForTesting(clip_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(60, 60), true, false,
-                               false);
-  SetLayerPropertiesForTesting(clipped_surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(60, 60), true, false,
-                               true);
   clip_parent->SetMasksToBounds(true);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(30, 30), unclipped_surface->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(20, 20), unclipped_desc_surface->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(50, 50), clipped_surface->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, RootClipPropagationToClippedSurface) {
   // Tests visible rects computation when we have unclipped_surface->
   // surface_with_unclipped_descendants->clipped_surface, checks that the bounds
   // of root propagate to the clipped_surface.
   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* clip_child = AddChild<LayerImpl>(unclipped_desc_surface);
   LayerImpl* clipped_surface = AddChild<LayerImpl>(clip_child);
 
+  root->SetBounds(gfx::Size(10, 10));
+
+  unclipped_surface->SetBounds(gfx::Size(50, 50));
   unclipped_surface->SetDrawsContent(true);
+  unclipped_surface->test_properties()->force_render_surface = true;
+
+  clip_parent->SetBounds(gfx::Size(50, 50));
+  clip_parent->test_properties()->clip_children =
+      base::MakeUnique<std::set<LayerImpl*>>();
+  clip_parent->test_properties()->clip_children->insert(clip_child);
+
+  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->test_properties()->clip_parent = clip_parent;
+
+  clipped_surface->SetBounds(gfx::Size(50, 50));
   clipped_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());
+  clipped_surface->test_properties()->force_render_surface = true;
 
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), 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(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(50, 50), true, false,
-                               true);
   clip_parent->SetMasksToBounds(true);
   unclipped_desc_surface->SetMasksToBounds(true);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(50, 50), unclipped_surface->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(50, 50), unclipped_desc_surface->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(10, 10), clipped_surface->visible_layer_rect());
 }
 
 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);
-  child1->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
   gfx::Transform child_rotation;
   child_rotation.Rotate(45.0);
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(3, 4), true, false,
-                               true);
-  SetLayerPropertiesForTesting(
-      child1, child_rotation, gfx::Point3F(25, 25, 0.f),
-      gfx::PointF(25.f, 25.f), gfx::Size(50, 50), true, false, false);
 
+  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);
+  child1->test_properties()->transform_origin = gfx::Point3F(25.f, 25.f, 0.f);
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(render_surface->render_surface());
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
 
   // Layers that do not draw content should have empty visible content rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface->visible_layer_rect());
@@ skipping 14 matching lines @@
   EXPECT_EQ(expected_surface_drawable_content, child1->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsWithTransformOnClippedSurface) {
   // 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);
-  child1->SetDrawsContent(true);
 
-  gfx::Transform identity_matrix;
   gfx::Transform child_rotation;
   child_rotation.Rotate(45.0);
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(3, 4), true, false,
-                               true);
 
-  SetLayerPropertiesForTesting(
-      child1, child_rotation, gfx::Point3F(25, 25, 0.f),
-      gfx::PointF(25.f, 25.f), gfx::Size(50, 50), true, false, false);
-
+  root->SetBounds(gfx::Size(50, 50));
   root->SetMasksToBounds(true);
-
+  render_surface->SetBounds(gfx::Size(3, 4));
+  render_surface->test_properties()->force_render_surface = true;
+  child1->SetPosition(gfx::PointF(25.f, 25.f));
+  child1->SetBounds(gfx::Size(50, 50));
+  child1->SetDrawsContent(true);
+  child1->SetTransform(child_rotation);
+  child1->test_properties()->transform_origin = gfx::Point3F(25.f, 25.f, 0.f);
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(render_surface->render_surface());
 
   // The clipped surface clamps the DrawableContentRect that encloses the
   // rotated layer.
   int diagonal_radius = ceil(sqrt(2.0) * 25.0);
   gfx::Rect unclipped_surface_content = gfx::Rect(50 - diagonal_radius,
                                                   50 - diagonal_radius,
                                                   diagonal_radius * 2,
                                                   diagonal_radius * 2);
   gfx::RectF expected_surface_drawable_content(
       gfx::IntersectRects(unclipped_surface_content, gfx::Rect(50, 50)));
   EXPECT_EQ(expected_surface_drawable_content,
             render_surface->render_surface()->DrawableContentRect());
 
   // On the clipped surface, only a quarter  of the child1 is visible, but when
   // rotating it back to  child1's content space, the actual enclosing rect ends
   // up covering the full left half of child1.
   EXPECT_EQ(gfx::Rect(0, 0, 25, 50), child1->visible_layer_rect());
 
   // The child's DrawableContentRect is unclipped.
   EXPECT_EQ(unclipped_surface_content, child1->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsInHighDPI) {
   LayerImpl* root = root_layer_for_testing();
   FakePictureLayerImpl* render_surface1 =
       AddChildToRoot<FakePictureLayerImpl>();
-  render_surface1->SetDrawsContent(true);
   FakePictureLayerImpl* render_surface2 =
       AddChild<FakePictureLayerImpl>(render_surface1);
-  render_surface2->SetDrawsContent(true);
   FakePictureLayerImpl* child1 =
       AddChild<FakePictureLayerImpl>(render_surface2);
-  child1->SetDrawsContent(true);
   FakePictureLayerImpl* child2 =
       AddChild<FakePictureLayerImpl>(render_surface2);
-  child2->SetDrawsContent(true);
   FakePictureLayerImpl* child3 =
       AddChild<FakePictureLayerImpl>(render_surface2);
+
+  root->SetBounds(gfx::Size(100, 100));
+  root->SetMasksToBounds(true);
+  render_surface1->SetBounds(gfx::Size(3, 4));
+  render_surface1->SetPosition(gfx::PointF(5.f, 5.f));
+  render_surface1->SetDrawsContent(true);
+  render_surface1->test_properties()->force_render_surface = true;
+  render_surface2->SetBounds(gfx::Size(7, 13));
+  render_surface2->SetPosition(gfx::PointF(5.f, 5.f));
+  render_surface2->SetDrawsContent(true);
+  render_surface2->test_properties()->force_render_surface = true;
+  child1->SetBounds(gfx::Size(50, 50));
+  child1->SetPosition(gfx::PointF(5.f, 5.f));
+  child1->SetDrawsContent(true);
+  child2->SetBounds(gfx::Size(50, 50));
+  child2->SetPosition(gfx::PointF(75.f, 75.f));
+  child2->SetDrawsContent(true);
+  child3->SetBounds(gfx::Size(50, 50));
+  child3->SetPosition(gfx::PointF(125.f, 125.f));
   child3->SetDrawsContent(true);
-
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
-  SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(5.f, 5.f), gfx::Size(3, 4), true,
-                               false, true);
-  SetLayerPropertiesForTesting(render_surface2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(5.f, 5.f), gfx::Size(7, 13), true,
-                               false, true);
-  SetLayerPropertiesForTesting(child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(5.f, 5.f), gfx::Size(50, 50), true,
-                               false, false);
-  SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(75.f, 75.f), gfx::Size(50, 50), true,
-                               false, false);
-  SetLayerPropertiesForTesting(child3, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
-                               true, false, false);
-
   float device_scale_factor = 2.f;
-
-  root->SetMasksToBounds(true);
-
   ExecuteCalculateDrawProperties(root, device_scale_factor);
 
   ASSERT_TRUE(render_surface1->render_surface());
   ASSERT_TRUE(render_surface2->render_surface());
 
   // drawable_content_rects for all layers and surfaces are scaled by
   // device_scale_factor.
   EXPECT_EQ(gfx::RectF(200.f, 200.f),
             root->render_surface()->DrawableContentRect());
   EXPECT_EQ(gfx::RectF(10.f, 10.f, 190.f, 190.f),
@@ skipping 19 matching lines @@
   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* parent = root_layer_for_testing();
+  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 =
       AddChild<LayerImpl>(back_facing_surface);
@@ skipping 22 matching lines @@
   front_facing_child_of_front_facing_surface->SetDrawsContent(true);
   back_facing_child_of_front_facing_surface->SetDrawsContent(true);
   front_facing_child_of_back_facing_surface->SetDrawsContent(true);
   back_facing_child_of_back_facing_surface->SetDrawsContent(true);
 
   gfx::Transform backface_matrix;
   backface_matrix.Translate(50.0, 50.0);
   backface_matrix.RotateAboutYAxis(180.0);
   backface_matrix.Translate(-50.0, -50.0);
 
-  // Having a descendant and opacity will force these to have render surfaces.
-  front_facing_surface->test_properties()->opacity = 0.5f;
-  back_facing_surface->test_properties()->opacity = 0.5f;
+  root->SetBounds(gfx::Size(100, 100));
+  front_facing_child->SetBounds(gfx::Size(100, 100));
+  back_facing_child->SetBounds(gfx::Size(100, 100));
+  front_facing_surface->SetBounds(gfx::Size(100, 100));
+  back_facing_surface->SetBounds(gfx::Size(100, 100));
+  front_facing_child_of_front_facing_surface->SetBounds(gfx::Size(100, 100));
+  back_facing_child_of_front_facing_surface->SetBounds(gfx::Size(100, 100));
+  front_facing_child_of_back_facing_surface->SetBounds(gfx::Size(100, 100));
+  back_facing_child_of_back_facing_surface->SetBounds(gfx::Size(100, 100));
 
-  // Nothing preserves 3d. According to current W3C CSS gfx::Transforms spec,
-  // these layers should blindly use their own local transforms to determine
-  // back-face culling.
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(front_facing_child, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(back_facing_child, backface_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(front_facing_surface, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(back_facing_surface, backface_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(front_facing_child_of_front_facing_surface,
-                               identity_matrix, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(back_facing_child_of_front_facing_surface,
-                               backface_matrix, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(front_facing_child_of_back_facing_surface,
-                               identity_matrix, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(back_facing_child_of_back_facing_surface,
-                               backface_matrix, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false);
+  front_facing_surface->test_properties()->force_render_surface = true;
+  back_facing_surface->test_properties()->force_render_surface = true;
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(parent);
+  back_facing_child->SetTransform(backface_matrix);
+  back_facing_surface->SetTransform(backface_matrix);
+  back_facing_child_of_front_facing_surface->SetTransform(backface_matrix);
+  back_facing_child_of_back_facing_surface->SetTransform(backface_matrix);
+
+  // Note: No layers preserve 3d. According to current W3C CSS gfx::Transforms
+  // spec, these layers should blindly use their own local transforms to
+  // determine back-face culling.
+  ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
 
   // Verify which render surfaces were created.
   EXPECT_FALSE(front_facing_child->has_render_surface());
   EXPECT_FALSE(back_facing_child->has_render_surface());
   EXPECT_TRUE(front_facing_surface->has_render_surface());
   EXPECT_TRUE(back_facing_surface->has_render_surface());
   EXPECT_FALSE(
       front_facing_child_of_front_facing_surface->has_render_surface());
   EXPECT_FALSE(back_facing_child_of_front_facing_surface->has_render_surface());
   EXPECT_FALSE(front_facing_child_of_back_facing_surface->has_render_surface());
   EXPECT_FALSE(back_facing_child_of_back_facing_surface->has_render_surface());
 
   EXPECT_EQ(4u, update_layer_list_impl()->size());
   EXPECT_TRUE(UpdateLayerListImplContains(front_facing_child->id()));
   EXPECT_TRUE(UpdateLayerListImplContains(front_facing_surface->id()));
   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* parent = root_layer_for_testing();
+  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 =
       AddChild<LayerImpl>(back_facing_surface);
@@ skipping 31 matching lines @@
   front_facing_child_of_back_facing_surface->SetDrawsContent(true);
   back_facing_child_of_back_facing_surface->SetDrawsContent(true);
   dummy_replica_layer1->SetDrawsContent(true);
   dummy_replica_layer2->SetDrawsContent(true);
 
   gfx::Transform backface_matrix;
   backface_matrix.Translate(50.0, 50.0);
   backface_matrix.RotateAboutYAxis(180.0);
   backface_matrix.Translate(-50.0, -50.0);
 
+  root->SetBounds(gfx::Size(100, 100));
+  front_facing_child->SetBounds(gfx::Size(100, 100));
+  back_facing_child->SetBounds(gfx::Size(100, 100));
+  front_facing_surface->SetBounds(gfx::Size(100, 100));
+  back_facing_surface->SetBounds(gfx::Size(100, 100));
+  front_facing_child_of_front_facing_surface->SetBounds(gfx::Size(100, 100));
+  back_facing_child_of_front_facing_surface->SetBounds(gfx::Size(100, 100));
+  front_facing_child_of_back_facing_surface->SetBounds(gfx::Size(100, 100));
+  back_facing_child_of_back_facing_surface->SetBounds(gfx::Size(100, 100));
+
+  back_facing_child->SetTransform(backface_matrix);
+  back_facing_surface->SetTransform(backface_matrix);
+  back_facing_child_of_front_facing_surface->SetTransform(backface_matrix);
+  back_facing_child_of_back_facing_surface->SetTransform(backface_matrix);
+
   // Each surface creates its own new 3d rendering context (as defined by W3C
   // spec).  According to current W3C CSS gfx::Transforms spec, layers in a 3d
   // rendering context should use the transform with respect to that context.
   // This 3d rendering context occurs when (a) parent's transform style is flat
   // and (b) the layer's transform style is preserve-3d.
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true,
-                               false);  // parent transform style is flat.
-  SetLayerPropertiesForTesting(front_facing_child, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(back_facing_child, backface_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false);
-  // surface transform style is preserve-3d.
-  SetLayerPropertiesForTesting(front_facing_surface, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), false, true);
-  // surface transform style is preserve-3d.
-  SetLayerPropertiesForTesting(back_facing_surface, backface_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), false, true);
-  SetLayerPropertiesForTesting(front_facing_child_of_front_facing_surface,
-                               identity_matrix, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, true);
-  SetLayerPropertiesForTesting(back_facing_child_of_front_facing_surface,
-                               backface_matrix, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, true);
-  SetLayerPropertiesForTesting(front_facing_child_of_back_facing_surface,
-                               identity_matrix, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, true);
-  SetLayerPropertiesForTesting(back_facing_child_of_back_facing_surface,
-                               backface_matrix, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, true);
+  front_facing_surface->test_properties()->should_flatten_transform = false;
+  front_facing_surface->Set3dSortingContextId(1);
+  back_facing_surface->test_properties()->should_flatten_transform = false;
+  back_facing_surface->Set3dSortingContextId(1);
+  front_facing_child_of_front_facing_surface->Set3dSortingContextId(1);
+  back_facing_child_of_front_facing_surface->Set3dSortingContextId(1);
+  front_facing_child_of_back_facing_surface->Set3dSortingContextId(1);
+  back_facing_child_of_back_facing_surface->Set3dSortingContextId(1);
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(parent);
+  ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
 
   // Verify which render surfaces were created and used.
   EXPECT_FALSE(front_facing_child->has_render_surface());
   EXPECT_FALSE(back_facing_child->has_render_surface());
   EXPECT_TRUE(front_facing_surface->has_render_surface());
   // We expect that a has_render_surface was created but not used.
   EXPECT_TRUE(back_facing_surface->has_render_surface());
   EXPECT_FALSE(
       front_facing_child_of_front_facing_surface->has_render_surface());
   EXPECT_FALSE(back_facing_child_of_front_facing_surface->has_render_surface());
   EXPECT_FALSE(front_facing_child_of_back_facing_surface->has_render_surface());
   EXPECT_FALSE(back_facing_child_of_back_facing_surface->has_render_surface());
 
   EXPECT_EQ(3u, update_layer_list_impl()->size());
 
   EXPECT_TRUE(UpdateLayerListImplContains(front_facing_child->id()));
   EXPECT_TRUE(UpdateLayerListImplContains(front_facing_surface->id()));
   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* parent = root_layer_for_testing();
+  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;
   child2->test_properties()->double_sided = false;
@@ skipping 15 matching lines @@
 
   SetElementIdsForTesting();
 
   // Animate the transform on the render surface.
   AddAnimatedTransformToElementWithPlayer(animating_surface->element_id(),
                                           timeline_impl(), 10.0, 30, 0);
   // This is just an animating layer, not a surface.
   AddAnimatedTransformToElementWithPlayer(animating_child->element_id(),
                                           timeline_impl(), 10.0, 30, 0);
 
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(child, backface_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(animating_surface, backface_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false, true);
-  SetLayerPropertiesForTesting(child_of_animating_surface, backface_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(animating_child, backface_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
+  root->SetBounds(gfx::Size(100, 100));
+  child->SetBounds(gfx::Size(100, 100));
+  child->SetTransform(backface_matrix);
+  animating_surface->SetBounds(gfx::Size(100, 100));
+  animating_surface->SetTransform(backface_matrix);
+  animating_surface->test_properties()->force_render_surface = true;
+  child_of_animating_surface->SetBounds(gfx::Size(100, 100));
+  child_of_animating_surface->SetTransform(backface_matrix);
+  animating_child->SetBounds(gfx::Size(100, 100));
+  animating_child->SetTransform(backface_matrix);
+  child2->SetBounds(gfx::Size(100, 100));
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(parent);
+  ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
 
   EXPECT_FALSE(child->has_render_surface());
   EXPECT_TRUE(animating_surface->has_render_surface());
   EXPECT_FALSE(child_of_animating_surface->has_render_surface());
   EXPECT_FALSE(animating_child->has_render_surface());
   EXPECT_FALSE(child2->has_render_surface());
 
   EXPECT_EQ(1u, update_layer_list_impl()->size());
 
   // The back facing layers are culled from the layer list, and have an empty
   // visible rect.
   EXPECT_TRUE(UpdateLayerListImplContains(child2->id()));
   EXPECT_TRUE(child->visible_layer_rect().IsEmpty());
   EXPECT_TRUE(animating_surface->visible_layer_rect().IsEmpty());
   EXPECT_TRUE(child_of_animating_surface->visible_layer_rect().IsEmpty());
   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* parent = root_layer_for_testing();
+  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;
 
   // Everything draws content.
   front_facing_surface->SetDrawsContent(true);
   back_facing_surface->SetDrawsContent(true);
   child1->SetDrawsContent(true);
   child2->SetDrawsContent(true);
 
   gfx::Transform backface_matrix;
   backface_matrix.Translate(50.0, 50.0);
   backface_matrix.RotateAboutYAxis(180.0);
   backface_matrix.Translate(-50.0, -50.0);
 
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), false,
-                               true);  // parent transform style is preserve3d.
-  SetLayerPropertiesForTesting(front_facing_surface, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true,
-                               true);  // surface transform style is flat.
-  SetLayerPropertiesForTesting(back_facing_surface, backface_matrix,
-                               gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(100, 100), true,
-                               true);  // surface transform style is flat.
-  SetLayerPropertiesForTesting(child1, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
+  root->SetBounds(gfx::Size(100, 100));
+  front_facing_surface->SetBounds(gfx::Size(100, 100));
+  front_facing_surface->test_properties()->force_render_surface = true;
+  back_facing_surface->SetBounds(gfx::Size(100, 100));
+  back_facing_surface->SetTransform(backface_matrix);
+  back_facing_surface->test_properties()->force_render_surface = true;
+  child1->SetBounds(gfx::Size(100, 100));
+  child2->SetBounds(gfx::Size(100, 100));
 
   front_facing_surface->Set3dSortingContextId(1);
   back_facing_surface->Set3dSortingContextId(1);
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(parent);
+  ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
 
   // Verify which render surfaces were created and used.
   EXPECT_TRUE(front_facing_surface->has_render_surface());
 
   // We expect the render surface to have been created, but remain unused.
   EXPECT_TRUE(back_facing_surface->has_render_surface());
   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* parent = root_layer_for_testing();
-  parent->SetDrawsContent(true);
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), false, true,
-                               true);
+  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);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(2.f, 2.f), gfx::Size(10, 10), false,
-                               true, false);
 
   LayerImpl* child2 = AddChildToRoot<LayerImpl>();
+  child2->SetPosition(gfx::PointF(2.f, 2.f));
+  child2->SetBounds(gfx::Size(5, 5));
   child2->SetDrawsContent(true);
-  SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(2.f, 2.f), gfx::Size(5, 5), false,
-                               true, false);
 
   float device_scale_factor = 2.5f;
   gfx::Size viewport_size(100, 100);
-  ExecuteCalculateDrawProperties(parent, device_scale_factor);
+  ExecuteCalculateDrawProperties(root, device_scale_factor);
 
-  EXPECT_IDEAL_SCALE_EQ(device_scale_factor, parent);
+  EXPECT_IDEAL_SCALE_EQ(device_scale_factor, root);
   EXPECT_IDEAL_SCALE_EQ(device_scale_factor, child);
   EXPECT_IDEAL_SCALE_EQ(device_scale_factor, child2);
 
   EXPECT_EQ(1u, render_surface_layer_list_impl()->size());
 
-  // Verify parent transforms
-  gfx::Transform expected_parent_transform;
-  expected_parent_transform.Scale(device_scale_factor, device_scale_factor);
-  EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
-                                  parent->ScreenSpaceTransform());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
-                                  parent->DrawTransform());
+  // Verify root transforms
+  gfx::Transform expected_root_transform;
+  expected_root_transform.Scale(device_scale_factor, device_scale_factor);
+  EXPECT_TRANSFORMATION_MATRIX_EQ(expected_root_transform,
+                                  root->ScreenSpaceTransform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(expected_root_transform,
+                                  root->DrawTransform());
 
-  // Verify results of transformed parent rects
-  gfx::RectF parent_bounds(gfx::SizeF(parent->bounds()));
+  // Verify results of transformed root rects
+  gfx::RectF root_bounds(gfx::SizeF(root->bounds()));
 
-  gfx::RectF parent_draw_rect =
-      MathUtil::MapClippedRect(parent->DrawTransform(), parent_bounds);
-  gfx::RectF parent_screen_space_rect =
-      MathUtil::MapClippedRect(parent->ScreenSpaceTransform(), parent_bounds);
+  gfx::RectF root_draw_rect =
+      MathUtil::MapClippedRect(root->DrawTransform(), root_bounds);
+  gfx::RectF root_screen_space_rect =
+      MathUtil::MapClippedRect(root->ScreenSpaceTransform(), root_bounds);
 
-  gfx::RectF expected_parent_draw_rect(gfx::SizeF(parent->bounds()));
-  expected_parent_draw_rect.Scale(device_scale_factor);
-  EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_draw_rect);
-  EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_screen_space_rect);
+  gfx::RectF expected_root_draw_rect(gfx::SizeF(root->bounds()));
+  expected_root_draw_rect.Scale(device_scale_factor);
+  EXPECT_FLOAT_RECT_EQ(expected_root_draw_rect, root_draw_rect);
+  EXPECT_FLOAT_RECT_EQ(expected_root_draw_rect, root_screen_space_rect);
 
   // Verify child and child2 transforms. They should match.
   gfx::Transform expected_child_transform;
   expected_child_transform.Scale(device_scale_factor, device_scale_factor);
   expected_child_transform.Translate(child->position().x(),
                                      child->position().y());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->ScreenSpaceTransform());
@@ skipping 28 matching lines @@
 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();
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), false, true,
-                               false);
+  root->SetBounds(gfx::Size(100, 100));
 
   LayerImpl* page_scale = AddChildToRoot<LayerImpl>();
-  SetLayerPropertiesForTesting(page_scale, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), false, true,
-                               false);
+  page_scale->SetBounds(gfx::Size(100, 100));
 
   LayerImpl* parent = AddChild<LayerImpl>(page_scale);
+  parent->SetBounds(gfx::Size(100, 100));
   parent->SetDrawsContent(true);
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), false, true,
-                               false);
 
   LayerImpl* perspective_surface = AddChild<LayerImpl>(parent);
-  SetLayerPropertiesForTesting(perspective_surface,
-                               perspective_matrix * scale_small_matrix,
-                               gfx::Point3F(), gfx::PointF(2.f, 2.f),
-                               gfx::Size(10, 10), false, true, true);
+  perspective_surface->SetPosition(gfx::PointF(2.f, 2.f));
+  perspective_surface->SetBounds(gfx::Size(10, 10));
+  perspective_surface->SetTransform(perspective_matrix * scale_small_matrix);
   perspective_surface->SetDrawsContent(true);
+  perspective_surface->test_properties()->force_render_surface = true;
 
   LayerImpl* scale_surface = AddChild<LayerImpl>(parent);
-  SetLayerPropertiesForTesting(scale_surface, scale_small_matrix,
-                               gfx::Point3F(), gfx::PointF(2.f, 2.f),
-                               gfx::Size(10, 10), false, true, true);
+  scale_surface->SetPosition(gfx::PointF(2.f, 2.f));
+  scale_surface->SetBounds(gfx::Size(10, 10));
+  scale_surface->SetTransform(scale_small_matrix);
   scale_surface->SetDrawsContent(true);
+  scale_surface->test_properties()->force_render_surface = true;
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 3.f;
   root->layer_tree_impl()->SetViewportLayersFromIds(
       Layer::INVALID_ID, page_scale->id(), Layer::INVALID_ID,
       Layer::INVALID_ID);
   root->layer_tree_impl()->BuildLayerListAndPropertyTreesForTesting();
   root->layer_tree_impl()->SetPageScaleOnActiveTree(page_scale_factor);
   ExecuteCalculateDrawProperties(root, device_scale_factor, page_scale_factor,
                                  root);
@@ skipping 59 matching lines @@
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 0.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   LayerImpl* root = root_layer_for_testing();
   root->SetBounds(gfx::Size(100, 100));
 
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
+  parent->SetBounds(gfx::Size(100, 100));
+  parent->SetTransform(parent_scale_matrix);
   parent->SetDrawsContent(true);
-  SetLayerPropertiesForTesting(parent, parent_scale_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), false, true,
-                               false);
 
   LayerImpl* child_scale = AddChild<LayerImpl>(parent);
+  child_scale->SetPosition(gfx::PointF(2.f, 2.f));
+  child_scale->SetBounds(gfx::Size(10, 10));
+  child_scale->SetTransform(child_scale_matrix);
   child_scale->SetDrawsContent(true);
-  SetLayerPropertiesForTesting(child_scale, child_scale_matrix, gfx::Point3F(),
-                               gfx::PointF(2.f, 2.f), gfx::Size(10, 10), false,
-                               true, false);
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 0.01f;
 
   {
     ExecuteCalculateDrawProperties(root, device_scale_factor, page_scale_factor,
                                    root);
 
     // The ideal scale is able to go below 1.
     float expected_ideal_scale =
@@ skipping 14 matching lines @@
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 1.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   LayerImpl* root = root_layer_for_testing();
   root->SetBounds(gfx::Size(100, 100));
 
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
+  parent->SetBounds(gfx::Size(100, 100));
+  parent->SetTransform(parent_scale_matrix);
   parent->SetDrawsContent(true);
-  SetLayerPropertiesForTesting(parent, parent_scale_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), false, true,
-                               false);
 
   LayerImpl* child_scale = AddChild<LayerImpl>(parent);
+  child_scale->SetBounds(gfx::Size(10, 10));
+  child_scale->SetPosition(gfx::PointF(2.f, 2.f));
+  child_scale->SetTransform(child_scale_matrix);
   child_scale->SetDrawsContent(true);
-  SetLayerPropertiesForTesting(child_scale, child_scale_matrix, gfx::Point3F(),
-                               gfx::PointF(2.f, 2.f), gfx::Size(10, 10), false,
-                               true, false);
 
-  {
-    ExecuteCalculateDrawProperties(root);
+  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);
-  }
+  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);
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), false, true,
-                               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);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(2.f, 2.f), gfx::Size(10, 10), false,
-                               true, 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);
-  SetLayerPropertiesForTesting(replica.get(), replica_transform, gfx::Point3F(),
-                               gfx::PointF(2.f, 2.f), gfx::Size(10, 10), false,
-                               true, false);
+  replica->SetPosition(gfx::PointF(2.f, 2.f));
+  replica->SetTransform(replica_transform);
+
   // We need to set parent on replica layer for property tree building.
   replica->test_properties()->parent = child;
   child->test_properties()->SetReplicaLayer(std::move(replica));
 
   // This layer should end up in the same surface as child, with the same draw
   // and screen space transforms.
   LayerImpl* duplicate_child_non_owner = AddChild<LayerImpl>(child);
+  duplicate_child_non_owner->SetBounds(gfx::Size(10, 10));
   duplicate_child_non_owner->SetDrawsContent(true);
-  SetLayerPropertiesForTesting(duplicate_child_non_owner, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
-                               false, true, false);
 
   float device_scale_factor = 1.5f;
   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 expected_parent_transform;
   expected_parent_transform.Scale(device_scale_factor, device_scale_factor);
@@ skipping 64 matching lines @@
   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);
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(33, 31), false, true,
-                               true);
 
   LayerImpl* child = AddChildToRoot<LayerImpl>();
+  child->SetBounds(gfx::Size(13, 11));
   child->SetDrawsContent(true);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(13, 11), false, true,
-                               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);
-  SetLayerPropertiesForTesting(replica.get(), replica_transform, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(13, 11), false, true,
-                               false);
+  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;
@@ skipping 37 matching lines @@
   EXPECT_EQ(grand_child.get(), host()->LayerById(grand_child->id()));
   EXPECT_EQ(mask_layer.get(), host()->LayerById(mask_layer->id()));
   EXPECT_EQ(replica_layer.get(), host()->LayerById(replica_layer->id()));
   EXPECT_FALSE(host()->LayerById(nonexistent_id));
 }
 
 TEST_F(LayerTreeHostCommonTest, TransparentChildRenderSurfaceCreation) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
+
+  root->SetBounds(gfx::Size(100, 100));
+  child->SetBounds(gfx::Size(10, 10));
+  child->test_properties()->opacity = 0.5f;
+  grand_child->SetBounds(gfx::Size(10, 10));
   grand_child->SetDrawsContent(true);
-
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false);
-  SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(10, 10), true, false);
-
-  child->test_properties()->opacity = 0.5f;
-
   ExecuteCalculateDrawProperties(root);
-
   EXPECT_FALSE(child->has_render_surface());
 }
 
 TEST_F(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(host()->settings(), &task_runner_provider,
                                   &shared_bitmap_manager, &task_graph_runner);
   host_impl.CreatePendingTree();
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.pending_tree(), 1);
-
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               false);
+  root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl.pending_tree(), 2);
-  SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
+  child->SetBounds(gfx::Size(50, 50));
   child->SetDrawsContent(true);
   child->test_properties()->opacity = 0.0f;
 
   const int child_id = child->id();
   root->test_properties()->AddChild(std::move(child));
   root->SetHasRenderSurface(true);
   LayerImpl* root_layer = root.get();
   host_impl.pending_tree()->SetRootLayerForTesting(std::move(root));
   host_impl.pending_tree()->BuildLayerListAndPropertyTreesForTesting();
 
@@ skipping 123 matching lines @@
 
     root_->SetContentsOpaque(true);
     child_->SetContentsOpaque(true);
     grand_child_->SetContentsOpaque(true);
 
     root_->SetDrawsContent(true);
     child_->SetDrawsContent(true);
     grand_child_->SetDrawsContent(true);
 
     gfx::Transform identity_matrix;
-    SetLayerPropertiesForTesting(root_, identity_matrix, gfx::Point3F(),
-                                 gfx::PointF(), gfx::Size(1, 1), true, false,
-                                 true);
-    SetLayerPropertiesForTesting(child_, identity_matrix, gfx::Point3F(),
-                                 gfx::PointF(), gfx::Size(1, 1), true, false,
-                                 std::tr1::get<2>(GetParam()));
-    SetLayerPropertiesForTesting(grand_child_, identity_matrix, gfx::Point3F(),
-                                 gfx::PointF(), gfx::Size(1, 1), true, false,
-                                 false);
+    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_;
@@ skipping 154 matching lines @@
   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();
-  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
-  root->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl.pending_tree(), 2);
-  SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(40, 40), true, false,
-                               false);
+  child->SetBounds(gfx::Size(40, 40));
   child->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> grand_child =
       LayerImpl::Create(host_impl.pending_tree(), 3);
-  SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               true, false, false);
+  grand_child->SetBounds(gfx::Size(30, 30));
   grand_child->SetDrawsContent(true);
   grand_child->test_properties()->hide_layer_and_subtree = true;
 
   child->test_properties()->AddChild(std::move(grand_child));
   root->test_properties()->AddChild(std::move(child));
   root->SetHasRenderSurface(true);
   host_impl.pending_tree()->SetRootLayerForTesting(std::move(root));
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
@@ skipping 13 matching lines @@
   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);
-  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
+  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);
-  SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(40, 40), true, false,
-                               false);
+  child->SetBounds(gfx::Size(40, 40));
   child->SetDrawsContent(true);
   child->test_properties()->hide_layer_and_subtree = true;
 
   std::unique_ptr<LayerImpl> grand_child =
       LayerImpl::Create(host_impl.pending_tree(), 3);
-  SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               true, false, false);
+  grand_child->SetBounds(gfx::Size(30, 30));
   grand_child->SetDrawsContent(true);
 
   child->test_properties()->AddChild(std::move(grand_child));
   root->test_properties()->AddChild(std::move(child));
   host_impl.pending_tree()->SetRootLayerForTesting(std::move(root));
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, root_layer->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
@@ skipping 12 matching lines @@
   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);
-  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
+  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);
-  SetLayerPropertiesForTesting(copy_grand_parent.get(), identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
-                               true, false, false);
+  copy_grand_parent->SetBounds(gfx::Size(40, 40));
   copy_grand_parent->SetDrawsContent(true);
   LayerImpl* copy_grand_parent_layer = copy_grand_parent.get();
 
   std::unique_ptr<LayerImpl> copy_parent =
       LayerImpl::Create(host_impl.pending_tree(), 3);
-  SetLayerPropertiesForTesting(copy_parent.get(), identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               true, false, true);
+  copy_parent->SetBounds(gfx::Size(30, 30));
   copy_parent->SetDrawsContent(true);
+  copy_parent->test_properties()->force_render_surface = true;
   LayerImpl* copy_parent_layer = copy_parent.get();
 
   std::unique_ptr<LayerImpl> copy_request =
       LayerImpl::Create(host_impl.pending_tree(), 4);
-  SetLayerPropertiesForTesting(copy_request.get(), identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(20, 20),
-                               true, false, true);
+  copy_request->SetBounds(gfx::Size(20, 20));
   copy_request->SetDrawsContent(true);
+  copy_request->test_properties()->force_render_surface = true;
   LayerImpl* copy_layer = copy_request.get();
 
   std::unique_ptr<LayerImpl> copy_child =
       LayerImpl::Create(host_impl.pending_tree(), 5);
-  SetLayerPropertiesForTesting(copy_child.get(), identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(20, 20),
-                               true, false, false);
+  copy_child->SetBounds(gfx::Size(20, 20));
   copy_child->SetDrawsContent(true);
   LayerImpl* copy_child_layer = copy_child.get();
 
   std::unique_ptr<LayerImpl> copy_grand_child =
       LayerImpl::Create(host_impl.pending_tree(), 6);
-  SetLayerPropertiesForTesting(copy_grand_child.get(), identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(20, 20),
-                               true, false, false);
-  copy_child->SetDrawsContent(true);
+  copy_grand_child->SetBounds(gfx::Size(20, 20));
+  copy_grand_child->SetDrawsContent(true);
   LayerImpl* copy_grand_child_layer = copy_grand_child.get();
 
   std::unique_ptr<LayerImpl> copy_grand_parent_sibling_before =
       LayerImpl::Create(host_impl.pending_tree(), 7);
-  SetLayerPropertiesForTesting(copy_grand_parent_sibling_before.get(),
-                               identity_matrix, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(40, 40), true, false, false);
+  copy_grand_parent_sibling_before->SetBounds(gfx::Size(40, 40));
   copy_grand_parent_sibling_before->SetDrawsContent(true);
   LayerImpl* copy_grand_parent_sibling_before_layer =
       copy_grand_parent_sibling_before.get();
 
   std::unique_ptr<LayerImpl> copy_grand_parent_sibling_after =
       LayerImpl::Create(host_impl.pending_tree(), 8);
-  SetLayerPropertiesForTesting(copy_grand_parent_sibling_after.get(),
-                               identity_matrix, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(40, 40), true, false, false);
+  copy_grand_parent_sibling_after->SetBounds(gfx::Size(40, 40));
   copy_grand_parent_sibling_after->SetDrawsContent(true);
   LayerImpl* copy_grand_parent_sibling_after_layer =
       copy_grand_parent_sibling_after.get();
 
   copy_child->test_properties()->AddChild(std::move(copy_grand_child));
   copy_request->test_properties()->AddChild(std::move(copy_child));
   copy_parent->test_properties()->AddChild(std::move(copy_request));
   copy_grand_parent->test_properties()->AddChild(std::move(copy_parent));
   root->test_properties()->AddChild(
       std::move(copy_grand_parent_sibling_before));
@@ skipping 81 matching lines @@
   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);
-  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
+  root->SetBounds(gfx::Size(50, 50));
   root->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> copy_parent =
       LayerImpl::Create(host_impl.pending_tree(), 2);
-  SetLayerPropertiesForTesting(copy_parent.get(), identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(), true,
-                               false, false);
   copy_parent->SetDrawsContent(true);
   copy_parent->SetMasksToBounds(true);
 
   std::unique_ptr<LayerImpl> copy_layer =
       LayerImpl::Create(host_impl.pending_tree(), 3);
-  SetLayerPropertiesForTesting(copy_layer.get(), identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               true, false, true);
+  copy_layer->SetBounds(gfx::Size(30, 30));
   copy_layer->SetDrawsContent(true);
+  copy_layer->test_properties()->force_render_surface = true;
 
   std::unique_ptr<LayerImpl> copy_child =
       LayerImpl::Create(host_impl.pending_tree(), 4);
-  SetLayerPropertiesForTesting(copy_child.get(), identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(20, 20),
-                               true, false, false);
+  copy_child->SetBounds(gfx::Size(20, 20));
   copy_child->SetDrawsContent(true);
 
   copy_layer->test_properties()->copy_requests.push_back(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
 
   copy_layer->test_properties()->AddChild(std::move(copy_child));
   copy_parent->test_properties()->AddChild(std::move(copy_layer));
   root->test_properties()->AddChild(std::move(copy_parent));
 
   LayerImplList render_surface_layer_list;
@@ skipping 12 matching lines @@
   // 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();
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
+  root->SetBounds(gfx::Size(50, 50));
   root->SetDrawsContent(true);
   root->SetMasksToBounds(true);
 
   LayerImpl* copy_layer = AddChild<LayerImpl>(root);
-  SetLayerPropertiesForTesting(copy_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
+  copy_layer->SetBounds(gfx::Size(100, 100));
   copy_layer->SetDrawsContent(true);
+  copy_layer->test_properties()->force_render_surface = true;
 
   LayerImpl* copy_child = AddChild<LayerImpl>(copy_layer);
-  SetLayerPropertiesForTesting(copy_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(40, 40), gfx::Size(20, 20), true,
-                               false, false);
+  copy_child->SetPosition(gfx::PointF(40.f, 40.f));
+  copy_child->SetBounds(gfx::Size(20, 20));
   copy_child->SetDrawsContent(true);
 
   LayerImpl* copy_clip = AddChild<LayerImpl>(copy_layer);
-  SetLayerPropertiesForTesting(copy_clip, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(55, 55), true, false,
-                               false);
+  copy_clip->SetBounds(gfx::Size(55, 55));
   copy_clip->SetMasksToBounds(true);
 
   LayerImpl* copy_clipped_child = AddChild<LayerImpl>(copy_clip);
-  SetLayerPropertiesForTesting(copy_clipped_child, identity_matrix,
-                               gfx::Point3F(), gfx::PointF(40, 40),
-                               gfx::Size(20, 20), true, false, false);
+  copy_clipped_child->SetPosition(gfx::PointF(40.f, 40.f));
+  copy_clipped_child->SetBounds(gfx::Size(20, 20));
   copy_clipped_child->SetDrawsContent(true);
 
   LayerImpl* copy_surface = AddChild<LayerImpl>(copy_clip);
-  SetLayerPropertiesForTesting(copy_surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(45, 45), gfx::Size(20, 20), true,
-                               false, true);
+  copy_surface->SetPosition(gfx::PointF(45.f, 45.f));
+  copy_surface->SetBounds(gfx::Size(20, 20));
   copy_surface->SetDrawsContent(true);
+  copy_surface->test_properties()->force_render_surface = true;
 
   copy_layer->test_properties()->copy_requests.push_back(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
 
   DCHECK(!copy_layer->test_properties()->copy_requests.empty());
   ExecuteCalculateDrawProperties(root);
   DCHECK(copy_layer->test_properties()->copy_requests.empty());
 
   EXPECT_EQ(gfx::Rect(100, 100), copy_layer->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(20, 20), copy_child->visible_layer_rect());
@@ skipping 29 matching lines @@
   EXPECT_EQ(gfx::Rect(10, 10), copy_child->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(10, 10), copy_clipped_child->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(5, 5), copy_surface->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectInsideSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* surface = AddChild<LayerImpl>(root);
   LayerImpl* surface_child = AddChild<LayerImpl>(surface);
 
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               true);
-  SetLayerPropertiesForTesting(surface, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(-10, 20), gfx::Size(), true, false,
-                               true);
-  SetLayerPropertiesForTesting(surface_child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(50, 50), true, false,
-                               false);
+  root->SetBounds(gfx::Size(50, 50));
   root->SetDrawsContent(true);
+  surface->SetPosition(gfx::PointF(-10, 20));
+  surface->test_properties()->force_render_surface = true;
+  surface_child->SetBounds(gfx::Size(50, 50));
   surface_child->SetDrawsContent(true);
-
   ExecuteCalculateDrawProperties(root);
 
   // The visible_layer_rect for the |surface_child| should not be clipped by
   // the viewport.
   EXPECT_EQ(gfx::Rect(50, 50), surface_child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformedClipParent) {
   // Ensure that a transform between the layer and its render surface is not a
   // problem. Constructs the following layer tree.
@@ skipping 4543 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