cc: Clean up root_layer code in LTI

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 94 matching lines @@
 };
 
 class LayerTreeHostCommonDrawRectsTest : public LayerTreeHostCommonTest {
  public:
   LayerTreeHostCommonDrawRectsTest() : LayerTreeHostCommonTest() {}
 
   LayerImpl* TestVisibleRectAndDrawableContentRect(
       const gfx::Rect& target_rect,
       const gfx::Transform& layer_transform,
       const gfx::Rect& layer_rect) {
-    LayerImpl* root = root_layer();
+    LayerImpl* root = root_layer_for_testing();
     LayerImpl* target = AddChild<LayerImpl>(root);
     LayerImpl* drawing_layer = AddChild<LayerImpl>(target);
 
     root->SetDrawsContent(true);
     target->SetDrawsContent(true);
     target->SetMasksToBounds(true);
     drawing_layer->SetDrawsContent(true);
 
     gfx::Transform identity;
 
@@ skipping 12 matching lines @@
     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();
+  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);
 
   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();
+  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);
   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->data.transform_id, transform_tree_size);
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForSingleLayer) {
   gfx::Transform identity_matrix;
-  LayerImpl* root = root_layer();
+  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& tree =
       host_impl()->active_tree()->property_trees()->transform_tree;
 
   // Case 2: Setting the bounds of the layer should not affect either the draw
   // transform or the screenspace transform.
@@ skipping 129 matching lines @@
                                                      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->test_properties()->AddChild(std::move(clip_layer_scoped_ptr));
   root->SetHasRenderSurface(true);
   LayerImpl* root_layer = root.get();
-  host_impl.active_tree()->SetRootLayer(std::move(root));
+  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,
@@ skipping 45 matching lines @@
                       sub_layer_screen_position.y() * page_scale *
                           kDeviceScale));
   expected_transform.Scale(page_scale * kDeviceScale,
                            page_scale * kDeviceScale);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
                                   sublayer->DrawTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForSimpleHierarchy) {
   gfx::Transform identity_matrix;
-  LayerImpl* root = root_layer();
+  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);
 
   TransformTree& tree =
       host_impl()->active_tree()->property_trees()->transform_tree;
@@ skipping 68 matching lines @@
       draw_property_utils::ScreenSpaceTransform(child, tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_composite_transform,
       draw_property_utils::DrawTransform(grand_child, tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_composite_transform,
       draw_property_utils::ScreenSpaceTransform(grand_child, tree));
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForSingleRenderSurface) {
-  LayerImpl* root = root_layer();
+  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);
 
@@ skipping 47 matching lines @@
                                   child->render_target()->draw_transform());
 
   // The screen space is the same as the target since the child surface draws
   // into the root.
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       surface_sublayer_composite_transform,
       child->render_target()->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsWhenCannotRenderToSeparateSurface) {
-  LayerImpl* root = root_layer();
+  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);
 
@@ skipping 34 matching lines @@
 
   // With separate surfaces disabled, the grand child's draw transform should be
   // the same as its screen space transform.
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform,
                                   grand_child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform,
                                   grand_child->ScreenSpaceTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForReplica) {
-  LayerImpl* root = root_layer();
+  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(),
@@ skipping 60 matching lines @@
   //   transforms described w.r.t. that surface
   //   - A render surface described w.r.t. an ancestor render surface: should
   //   have a draw transform described w.r.t. that ancestor surface
   //   - Replicas of a render surface are described w.r.t. the replica's
   //   transform around its anchor, along with the surface itself.
   //   - Sanity check on recursion: verify transforms of layers described w.r.t.
   //   a render surface that is described w.r.t. an ancestor render surface.
   //   - verifying that each layer has a reference to the correct render surface
   //   and render target values.
 
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
   parent->SetDrawsContent(true);
   LayerImpl* render_surface1 = AddChild<LayerImpl>(parent);
   render_surface1->SetDrawsContent(true);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(render_surface1);
   render_surface2->SetDrawsContent(true);
   LayerImpl* child_of_root = AddChild<LayerImpl>(parent);
   child_of_root->SetDrawsContent(true);
   LayerImpl* child_of_rs1 = AddChild<LayerImpl>(render_surface1);
   child_of_rs1->SetDrawsContent(true);
@@ skipping 221 matching lines @@
   EXPECT_FLOAT_EQ(
       5.0, grand_child_of_rs2->ScreenSpaceTransform().matrix().get(1, 3));
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForFlatteningLayer) {
   // For layers that flatten their subtree, there should be an orthographic
   // projection (for x and y values) in the middle of the transform sequence.
   // Note that the way the code is currently implemented, it is not expected to
   // use a canonical orthographic projection.
 
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   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);
 
@@ skipping 47 matching lines @@
   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();
+  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);
 
@@ skipping 23 matching lines @@
 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();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   grand_child->SetDrawsContent(true);
 
   // 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);
@@ skipping 10 matching lines @@
   // This is the real test, the rest are sanity checks.
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
                                   child->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
                                   grand_child->DrawTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceWithSublayerScale) {
   const gfx::Transform identity_matrix;
-  LayerImpl* root = root_layer();
+  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(),
@@ skipping 19 matching lines @@
   // 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();
+  LayerImpl* root = root_layer_for_testing();
   root->SetDrawsContent(true);
   LayerImpl* child = AddChild<LayerImpl>(root);
   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(),
@@ skipping 107 matching lines @@
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         compositeSquared, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         compositeSquared, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceListForRenderSurfaceWithClippedLayer) {
-  LayerImpl* parent = root_layer();
+  LayerImpl* parent = root_layer_for_testing();
   parent->SetMasksToBounds(true);
   LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
   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(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 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());
   EXPECT_EQ(1U, render_surface_layer_list_impl()->size());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceListForTransparentChild) {
-  LayerImpl* parent = root_layer();
+  LayerImpl* parent = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(parent);
   LayerImpl* child = AddChild<LayerImpl>(render_surface1);
   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,
@@ skipping 11 matching lines @@
   // have been extended by the children.
   ASSERT_TRUE(parent->render_surface());
   EXPECT_EQ(0U, parent->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());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceListForTransparentChildWithBackgroundFilter) {
-  LayerImpl* parent = root_layer();
+  LayerImpl* parent = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(parent);
   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,
@@ skipping 38 matching lines @@
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
   }
 
   node = effect_tree.Node(render_surface1->effect_tree_index());
   EXPECT_FALSE(node->data.is_drawn);
   EXPECT_EQ(gfx::Rect(), render_surface1->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceListForFilter) {
-  LayerImpl* root = root_layer();
+  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(),
@@ skipping 22 matching lines @@
   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();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   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);
 
   FilterOperations filters;
   filters.Append(FilterOperation::CreateReferenceFilter(
       SkOffsetImageFilter::Make(50, 50, nullptr)));
   child->SetFilters(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();
+  LayerImpl* root = root_layer_for_testing();
   root->layer_tree_impl()->SetDeviceScaleFactor(device_scale_factor);
   LayerImpl* child = AddChild<LayerImpl>(root);
   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);
 
   FilterOperations filters;
   filters.Append(FilterOperation::CreateReferenceFilter(
       SkOffsetImageFilter::Make(50, 50, nullptr)));
   child->SetFilters(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();
+  LayerImpl* parent = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   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->test_properties()->opacity = 0.5f;
 
   ExecuteCalculateDrawProperties(parent);
 
   // 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();
+  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,
@@ skipping 21 matching lines @@
   // 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();
+  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->SetDrawsContent(true);
   parent->SetDrawsContent(true);
   child1->SetDrawsContent(true);
@@ skipping 51 matching lines @@
   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();
+  LayerImpl* parent = 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);
@@ skipping 15 matching lines @@
     ExecuteCalculateDrawPropertiesWithPropertyTrees(parent);
     EXPECT_TRUE(parent->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();
+  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.
@@ skipping 55 matching lines @@
   //  that have something to draw.
   //  - parent is a large container layer.
   //  - 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();
+  LayerImpl* parent = 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
   // render_surface_layer_list, even though grand_child and great_grand_child
   // should be clipped.
   LayerImpl* leaf_node1 = AddChild<LayerImpl>(child);
   leaf_node1->SetDrawsContent(true);
   LayerImpl* leaf_node2 = AddChild<LayerImpl>(great_grand_child);
@@ skipping 40 matching lines @@
   //  - parent 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.
   //  - grand_child is a render surface, and the only visible content in child.
   //  It is positioned outside of the clip rect from parent.
 
   // 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();
+  LayerImpl* parent = 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);
@@ skipping 27 matching lines @@
   //  - 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();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   parent->SetDrawsContent(true);
   LayerImpl* child1 = AddChild<LayerImpl>(parent);
   child1->SetDrawsContent(true);
   LayerImpl* child2 = AddChild<LayerImpl>(parent);
   child2->SetDrawsContent(true);
   LayerImpl* grand_child = AddChild<LayerImpl>(child1);
   grand_child->SetDrawsContent(true);
   LayerImpl* leaf_node1 = AddChild<LayerImpl>(grand_child);
   leaf_node1->SetDrawsContent(true);
@@ skipping 79 matching lines @@
   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();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(parent);
 
   root->SetDrawsContent(true);
   parent->SetDrawsContent(true);
   child->SetDrawsContent(true);
 
   const gfx::Transform identity_matrix;
 
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
@@ skipping 24 matching lines @@
   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();
+  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->SetDrawsContent(true);
   parent->SetDrawsContent(true);
   child1->SetDrawsContent(true);
@@ skipping 168 matching lines @@
   //   be the layer rect expressed in target space.
   //   grand_child2 - partially clipped but NOT masksToBounds; the clip rect
   //   will be the intersection of layer bounds and the mask region.
   //   grand_child3 - partially clipped and masksToBounds; the
   //   DrawableContentRect will still be the intersection of layer bounds and
   //   the mask region.
   //   grand_child4 - outside parent's clip rect; the DrawableContentRect should
   //   be empty.
 
   const gfx::Transform identity_matrix;
-  LayerImpl* parent = root_layer();
+  LayerImpl* parent = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child1 = AddChild<LayerImpl>(child);
   grand_child1->SetDrawsContent(true);
   LayerImpl* grand_child2 = AddChild<LayerImpl>(child);
   grand_child2->SetDrawsContent(true);
   LayerImpl* grand_child3 = AddChild<LayerImpl>(child);
   grand_child3->SetDrawsContent(true);
   LayerImpl* grand_child4 = AddChild<LayerImpl>(child);
   grand_child4->SetDrawsContent(true);
 
@@ skipping 31 matching lines @@
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipRectIsPropagatedCorrectlyToSurfaces) {
   // Verify that render surfaces (and their layers) get the appropriate
   // 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.
-  LayerImpl* parent = root_layer();
+  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
   // this test.
   LayerImpl* leaf_node1 = AddChild<LayerImpl>(grand_child1);
   leaf_node1->SetDrawsContent(true);
   LayerImpl* leaf_node2 = AddChild<LayerImpl>(grand_child2);
@@ skipping 61 matching lines @@
             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();
+  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->SetDrawsContent(true);
   parent->SetDrawsContent(true);
   child1->SetDrawsContent(true);
@@ skipping 159 matching lines @@
   EXPECT_EQ(gfx::Rect(100, 100), root->render_surface()->clip_rect());
   EXPECT_EQ(gfx::Rect(2, 2, 400, 400), parent->clip_rect());
   EXPECT_EQ(gfx::Rect(6, 6, 396, 396), child1->clip_rect());
   EXPECT_EQ(gfx::Rect(2, 2, 400, 400), child2->clip_rect());
   EXPECT_EQ(gfx::Rect(6, 6, 396, 396), grand_child->clip_rect());
   EXPECT_EQ(gfx::Rect(6, 6, 396, 396), leaf_node1->clip_rect());
   EXPECT_EQ(gfx::Rect(2, 2, 400, 400), leaf_node2->clip_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingWhenSurfacesDisabled) {
-  LayerImpl* root = root_layer();
+  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->SetDrawsContent(true);
   parent->SetDrawsContent(true);
   child->SetDrawsContent(true);
   grand_child->SetDrawsContent(true);
   leaf_node->SetDrawsContent(true);
@@ skipping 29 matching lines @@
   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();
+  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->SetDrawsContent(true);
   parent->SetDrawsContent(true);
   child->SetDrawsContent(true);
   grand_child->SetDrawsContent(true);
   leaf_node->SetDrawsContent(true);
@@ skipping 54 matching lines @@
 
   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_EQ(expected_leaf_draw_transform_with_surfaces,
             leaf_node->DrawTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, AnimationsForRenderSurfaceHierarchy) {
-  LayerImpl* parent = root_layer();
+  LayerImpl* parent = 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);
@@ skipping 119 matching lines @@
       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();
+  LayerImpl* parent = 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);
 
   EXPECT_EQ(gfx::Rect(), grand_child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        ScreenSpaceTransformIsAnimatingWithDelayedAnimation) {
-  LayerImpl* parent = root_layer();
+  LayerImpl* parent = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   LayerImpl* great_grand_child = AddChild<LayerImpl>(grand_child);
 
   parent->SetDrawsContent(true);
   child->SetDrawsContent(true);
   grand_child->SetDrawsContent(true);
   great_grand_child->SetDrawsContent(true);
 
   gfx::Transform identity;
@@ skipping 332 matching lines @@
   gfx::Rect expected_drawable_content_rect = target_surface_rect;
   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();
+  LayerImpl* root = root_layer_for_testing();
   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();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child1_layer = AddChildToRoot<LayerImpl>();
   child1_layer->SetDrawsContent(true);
   LayerImpl* child2_layer = AddChildToRoot<LayerImpl>();
   child2_layer->SetDrawsContent(true);
   LayerImpl* child3_layer = AddChildToRoot<LayerImpl>();
   child3_layer->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
@@ skipping 22 matching lines @@
   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();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   LayerImpl* grand_child1 = AddChild<LayerImpl>(child);
   grand_child1->SetDrawsContent(true);
   LayerImpl* grand_child2 = AddChild<LayerImpl>(child);
   grand_child2->SetDrawsContent(true);
   LayerImpl* grand_child3 = AddChild<LayerImpl>(child);
   grand_child3->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
@@ skipping 27 matching lines @@
   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), grand_child2->visible_layer_rect());
   EXPECT_TRUE(grand_child3->visible_layer_rect().IsEmpty());
 
   // All grandchild DrawableContentRects should also be clipped by child.
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), grand_child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 25, 25), grand_child2->drawable_content_rect());
   EXPECT_TRUE(grand_child3->drawable_content_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectWithClippingAndScaling) {
-  LayerImpl* root = root_layer();
+  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);
 
   child->SetMasksToBounds(true);
   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();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* child1 = AddChild<LayerImpl>(render_surface);
   child1->SetDrawsContent(true);
   LayerImpl* child2 = AddChild<LayerImpl>(render_surface);
   child2->SetDrawsContent(true);
   LayerImpl* child3 = AddChild<LayerImpl>(render_surface);
   child3->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
@@ skipping 33 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());
 
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleRectsWhenCannotRenderToSeparateSurface) {
-  LayerImpl* root = root_layer();
+  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->SetDrawsContent(true);
   parent->SetDrawsContent(true);
@@ skipping 176 matching lines @@
   EXPECT_EQ(gfx::Rect(5, 5, 800, 800), child2->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(14, 14, 792, 792), grand_child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(12, 12, 1500, 1500),
             grand_child2->drawable_content_rect());
   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();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child1 = AddChild<LayerImpl>(root);
   LayerImpl* child2 = AddChild<LayerImpl>(root);
   LayerImpl* child3 = AddChild<LayerImpl>(root);
   child1->SetDrawsContent(true);
   child2->SetDrawsContent(true);
   child3->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
@@ skipping 24 matching lines @@
   // 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();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   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,
@@ skipping 33 matching lines @@
                                false, false);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(child->visible_layer_rect().IsEmpty());
   EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleContentRectForLayerWithUninvertibleDrawTransform) {
-  LayerImpl* root = root_layer();
+  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));
 
@@ skipping 63 matching lines @@
                                false);
   SetLayerPropertiesForTesting(occluding_child.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(),
                                gfx::Size(200, 200), false, false, false);
 
   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()->SetRootLayer(std::move(root));
+  host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
   host_impl.SetVisible(true);
   host_impl.InitializeRenderer(output_surface.get());
   host_impl.active_tree()->BuildLayerListAndPropertyTreesForTesting();
   bool update_lcd_text = false;
   host_impl.active_tree()->UpdateDrawProperties(update_lcd_text);
 
   LayerImpl* grand_child_ptr = host_impl.active_tree()
-                                   ->root_layer()
+                                   ->root_layer_for_testing()
                                    ->test_properties()
                                    ->children[0]
                                    ->test_properties()
                                    ->children[0];
 
   // Though all layers have invertible transforms, matrix multiplication using
   // floating-point math makes the draw transform uninvertible.
   EXPECT_FALSE(
       host_impl.active_tree()
           ->property_trees()
           ->transform_tree.Node(grand_child_ptr->transform_tree_index())
           ->data.ancestors_are_invertible);
 
   // Since |grand_child| has an uninvertible screen space transform, it is
   // skipped so
   // that we are not computing its occlusion_in_content_space.
   gfx::Rect layer_bounds = gfx::Rect();
   EXPECT_EQ(
       layer_bounds,
       grand_child_ptr->draw_properties()
           .occlusion_in_content_space.GetUnoccludedContentRect(layer_bounds));
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsForLayersInClippedRenderSurface) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* child1 = AddChild<LayerImpl>(render_surface);
   child1->SetDrawsContent(true);
   LayerImpl* child2 = AddChild<LayerImpl>(render_surface);
   child2->SetDrawsContent(true);
   LayerImpl* child3 = AddChild<LayerImpl>(render_surface);
   child3->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
@@ skipping 38 matching lines @@
 
   // But the DrawableContentRects are unclipped.
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
   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();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface2 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* child1 = AddChild<LayerImpl>(render_surface2);
   child1->SetDrawsContent(true);
   LayerImpl* child2 = AddChild<LayerImpl>(render_surface2);
   child2->SetDrawsContent(true);
   LayerImpl* child3 = AddChild<LayerImpl>(render_surface2);
   child3->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
@@ skipping 48 matching lines @@
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_layer_rect());
 
   // DrawableContentRects are also unclipped.
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleRectsForClippedDescendantsOfUnclippedSurfaces) {
-  LayerImpl* root = root_layer();
+  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);
   child1->SetDrawsContent(true);
   child2->SetDrawsContent(true);
   render_surface2->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
@@ skipping 15 matching lines @@
   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();
+  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);
 
   render_surface1->SetDrawsContent(true);
   render_surface2->SetDrawsContent(true);
   clip_child->SetDrawsContent(true);
   clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
@@ skipping 19 matching lines @@
   clip_parent->SetMasksToBounds(true);
   render_surface1->SetMasksToBounds(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();
+  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);
 
   render_surface1->SetDrawsContent(true);
   render_surface2->SetDrawsContent(true);
   clip_child->SetDrawsContent(true);
   clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
@@ skipping 18 matching lines @@
                                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();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* surface = AddChildToRoot<LayerImpl>();
   LayerImpl* test_layer = AddChild<LayerImpl>(surface);
 
   test_layer->SetDrawsContent(false);
   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);
 
   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();
+  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);
 
   unclipped_surface->SetDrawsContent(true);
   unclipped_desc_surface->SetDrawsContent(true);
   clipped_surface->SetDrawsContent(true);
   clip_child->test_properties()->clip_parent = clip_parent;
@@ skipping 25 matching lines @@
   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();
+  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);
 
   unclipped_surface->SetDrawsContent(true);
   unclipped_desc_surface->SetDrawsContent(true);
   clipped_surface->SetDrawsContent(true);
   clip_child->test_properties()->clip_parent = clip_parent;
@@ skipping 26 matching lines @@
   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();
+  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);
@@ skipping 28 matching lines @@
 
   // All layers that draw content into the unclipped surface are also unclipped.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
   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();
+  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);
@@ skipping 26 matching lines @@
   // 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();
+  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 =
@@ skipping 59 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();
+  LayerImpl* parent = 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 83 matching lines @@
       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();
+  LayerImpl* parent = 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 95 matching lines @@
       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();
+  LayerImpl* parent = 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 55 matching lines @@
 
   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();
+  LayerImpl* parent = 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.
@@ skipping 38 matching lines @@
 
   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();
+  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* child = AddChildToRoot<LayerImpl>();
   child->SetDrawsContent(true);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(2.f, 2.f), gfx::Size(10, 10), false,
                                true, false);
@@ skipping 74 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();
+  LayerImpl* root = root_layer_for_testing();
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), false, true,
                                false);
 
   LayerImpl* page_scale = AddChildToRoot<LayerImpl>();
   SetLayerPropertiesForTesting(page_scale, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), false, true,
                                false);
 
   LayerImpl* parent = AddChild<LayerImpl>(page_scale);
@@ skipping 83 matching lines @@
 
 TEST_F(LayerTreeHostCommonScalingTest, SmallIdealScale) {
   gfx::Transform parent_scale_matrix;
   SkMScalar initial_parent_scale = 1.75;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 0.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   root->SetBounds(gfx::Size(100, 100));
 
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
   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->SetDrawsContent(true);
@@ skipping 23 matching lines @@
 
 TEST_F(LayerTreeHostCommonScalingTest, IdealScaleForAnimatingLayer) {
   gfx::Transform parent_scale_matrix;
   SkMScalar initial_parent_scale = 1.75;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 1.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   root->SetBounds(gfx::Size(100, 100));
 
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
   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->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);
 
     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();
+  LayerImpl* parent = root_layer_for_testing();
   parent->SetDrawsContent(true);
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), false, true,
                                true);
 
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   child->SetDrawsContent(true);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(2.f, 2.f), gfx::Size(10, 10), false,
                                true, true);
@@ skipping 93 matching lines @@
       child->render_surface()->replica_screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_replica_screen_space_transform,
       child->render_surface()->replica_screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest,
      RenderSurfaceTransformsInHighDPIAccurateScaleZeroPosition) {
   gfx::Transform identity_matrix;
 
-  LayerImpl* parent = root_layer();
+  LayerImpl* parent = root_layer_for_testing();
   parent->SetDrawsContent(true);
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(33, 31), false, true,
                                true);
 
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   child->SetDrawsContent(true);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(13, 11), false, true,
                                true);
@@ skipping 52 matching lines @@
   int nonexistent_id = -1;
   EXPECT_EQ(root.get(), host()->LayerById(root->id()));
   EXPECT_EQ(child.get(), host()->LayerById(child->id()));
   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();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   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(),
@@ skipping 27 matching lines @@
   SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
   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()->SetRootLayer(std::move(root));
+  host_impl.pending_tree()->SetRootLayerForTesting(std::move(root));
   host_impl.pending_tree()->BuildLayerListAndPropertyTreesForTesting();
   // Add opacity animation.
   scoped_refptr<AnimationTimeline> timeline =
       AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
   AddOpacityTransitionToLayerWithPlayer(child_id, timeline, 10.0, 0.0f, 1.0f,
                                         false);
 
   LayerImplList render_surface_layer_list;
@@ skipping 36 matching lines @@
 
   child_ptr = root_layer->layer_tree_impl()->LayerById(2);
   tree = root_layer->layer_tree_impl()->property_trees()->effect_tree;
   node = tree.Node(child_ptr->effect_tree_index());
   EXPECT_TRUE(node->data.is_drawn);
   EXPECT_TRUE(tree.ContributesToDrawnSurface(child_ptr->effect_tree_index()));
 
   // But if the opacity of the layer remains 0 after activation, it should not
   // be drawn.
   host_impl.ActivateSyncTree();
-  LayerImpl* active_root = host_impl.active_tree()->root_layer();
+  host_impl.active_tree()->SetRootLayerFromLayerListForTesting();
+  LayerImpl* active_root = host_impl.active_tree()->root_layer_for_testing();
   LayerImpl* active_child = host_impl.active_tree()->LayerById(child_ptr->id());
 
   EffectTree& active_effect_tree =
       host_impl.active_tree()->property_trees()->effect_tree;
   EXPECT_TRUE(active_effect_tree.needs_update());
 
   ExecuteCalculateDrawProperties(active_root);
 
   node = active_effect_tree.Node(active_child->effect_tree_index());
   EXPECT_FALSE(node->data.is_drawn);
@@ skipping 40 matching lines @@
     std::unique_ptr<LayerImpl> grand_child_ptr =
         LayerImpl::Create(host_impl_.active_tree(), 3);
 
     // Stash raw pointers to look at later.
     root_ = root_ptr.get();
     child_ = child_ptr.get();
     grand_child_ = grand_child_ptr.get();
 
     child_->test_properties()->AddChild(std::move(grand_child_ptr));
     root_->test_properties()->AddChild(std::move(child_ptr));
-    host_impl_.active_tree()->SetRootLayer(std::move(root_ptr));
+    host_impl_.active_tree()->SetRootLayerForTesting(std::move(root_ptr));
 
     root_->SetContentsOpaque(true);
     child_->SetContentsOpaque(true);
     grand_child_->SetContentsOpaque(true);
 
     root_->SetDrawsContent(true);
     child_->SetDrawsContent(true);
     grand_child_->SetDrawsContent(true);
 
     gfx::Transform identity_matrix;
@@ skipping 193 matching lines @@
       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->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()->SetRootLayer(std::move(root));
+  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;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // We should have one render surface and two layers. The grand child has
   // hidden itself.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ skipping 29 matching lines @@
 
   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->SetDrawsContent(true);
 
   child->test_properties()->AddChild(std::move(grand_child));
   root->test_properties()->AddChild(std::move(child));
-  host_impl.pending_tree()->SetRootLayer(std::move(root));
+  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;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // We should have one render surface and one layers. The child has
   // hidden itself and the grand child.
   ASSERT_EQ(1u, render_surface_layer_list.size());
@@ skipping 79 matching lines @@
       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));
   root->test_properties()->AddChild(std::move(copy_grand_parent));
   root->test_properties()->AddChild(std::move(copy_grand_parent_sibling_after));
-  host_impl.pending_tree()->SetRootLayer(std::move(root));
+  host_impl.pending_tree()->SetRootLayerForTesting(std::move(root));
 
   // Hide the copy_grand_parent and its subtree. But make a copy request in that
   // hidden subtree on copy_layer. Also hide the copy grand child and its
   // subtree.
   copy_grand_parent_layer->test_properties()->hide_layer_and_subtree = true;
   copy_grand_parent_sibling_before_layer->test_properties()
       ->hide_layer_and_subtree = true;
   copy_grand_parent_sibling_after_layer->test_properties()
       ->hide_layer_and_subtree = true;
   copy_grand_child_layer->test_properties()->hide_layer_and_subtree = true;
@@ skipping 104 matching lines @@
 
   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;
   LayerImpl* root_layer = root.get();
-  root_layer->layer_tree_impl()->SetRootLayer(std::move(root));
+  root_layer->layer_tree_impl()->SetRootLayerForTesting(std::move(root));
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, root_layer->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // We should have two render surface, as the others are clipped out.
   ASSERT_EQ(2u, render_surface_layer_list.size());
   EXPECT_EQ(root_layer->id(), render_surface_layer_list.at(0)->id());
 
   // The root render surface should only have 2 contributing layer, since the
   // other layers are empty/clipped away.
   ASSERT_EQ(2u, root_layer->render_surface()->layer_list().size());
   EXPECT_EQ(root_layer->id(),
             root_layer->render_surface()->layer_list().at(0)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleRectInNonRootCopyRequest) {
   const gfx::Transform identity_matrix;
 
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   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);
@@ skipping 40 matching lines @@
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(50, 50), copy_layer->visible_layer_rect());
   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();
+  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);
@@ skipping 15 matching lines @@
   // problem. Constructs the following layer tree.
   //
   //   root (a render surface)
   //     + render_surface
   //       + clip_parent (scaled)
   //         + intervening_clipping_layer
   //           + clip_child
   //
   // The render surface should be resized correctly and the clip child should
   // inherit the right clip rect.
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* clip_parent = AddChild<LayerImpl>(render_surface);
   clip_parent->SetDrawsContent(true);
   LayerImpl* intervening = AddChild<LayerImpl>(clip_parent);
   intervening->SetDrawsContent(true);
   LayerImpl* clip_child = AddChild<LayerImpl>(intervening);
   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);
@@ skipping 52 matching lines @@
   // case. In the following tree, both render surfaces should be resized to
   // accomodate for the clip child, despite an intervening clip.
   //
   //   root (a render surface)
   //    + clip_parent (masks to bounds)
   //      + render_surface1 (sets opacity)
   //        + intervening (masks to bounds)
   //          + render_surface2 (also sets opacity)
   //            + clip_child
   //
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_parent);
   LayerImpl* intervening = AddChild<LayerImpl>(render_surface1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(intervening);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface2);
   render_surface1->SetDrawsContent(true);
   render_surface2->SetDrawsContent(true);
   clip_child->SetDrawsContent(true);
 
   clip_child->test_properties()->clip_parent = clip_parent;
@@ skipping 68 matching lines @@
   // is a scroll involved. Note, we do _not_ have to consider any other sort
   // of transform.
   //
   //   root (a render surface)
   //    + clip_parent (masks to bounds)
   //      + render_surface1 (sets opacity)
   //        + intervening (masks to bounds AND scrolls)
   //          + render_surface2 (also sets opacity)
   //            + clip_child
   //
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_parent);
   LayerImpl* intervening = AddChild<LayerImpl>(render_surface1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(intervening);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface2);
   render_surface1->SetDrawsContent(true);
   render_surface2->SetDrawsContent(true);
   clip_child->SetDrawsContent(true);
 
   clip_child->test_properties()->clip_parent = clip_parent;
@@ skipping 67 matching lines @@
 
 TEST_F(LayerTreeHostCommonTest, DescendantsOfClipChildren) {
   // Ensures that descendants of the clip child inherit the correct clip.
   //
   //   root (a render surface)
   //    + clip_parent (masks to bounds)
   //      + intervening (masks to bounds)
   //        + clip_child
   //          + child
   //
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChild<LayerImpl>(root);
   LayerImpl* intervening = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(intervening);
   LayerImpl* child = AddChild<LayerImpl>(clip_child);
   clip_child->SetDrawsContent(true);
   child->SetDrawsContent(true);
 
   clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
@@ skipping 37 matching lines @@
   // render surfaces.
   //
   //   root (a render surface)
   //    + clip_parent (masks to bounds)
   //      + render_surface1
   //        + clip_child
   //      + render_surface2
   //        + non_clip_child
   //
   // In this example render_surface2 should be unaffected by clip_child.
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_parent);
   render_surface1->SetDrawsContent(true);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface1);
   clip_child->SetDrawsContent(true);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(clip_parent);
   render_surface2->SetDrawsContent(true);
   LayerImpl* non_clip_child = AddChild<LayerImpl>(render_surface2);
   non_clip_child->SetDrawsContent(true);
 
@@ skipping 57 matching lines @@
 
   // Sanity check our num_unclipped_descendants values.
   EXPECT_EQ(1u, render_surface1->test_properties()->num_unclipped_descendants);
   EXPECT_EQ(0u, render_surface2->test_properties()->num_unclipped_descendants);
 }
 
 TEST_F(LayerTreeHostCommonTest,
        CreateRenderSurfaceWhenFlattenInsideRenderingContext) {
   // Verifies that Render Surfaces are created at the edge of rendering context.
 
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child1 = AddChildToRoot<LayerImpl>();
   LayerImpl* child2 = AddChild<LayerImpl>(child1);
   LayerImpl* child3 = AddChild<LayerImpl>(child2);
   root->SetDrawsContent(true);
 
   const gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
 
@@ skipping 57 matching lines @@
                                position, bounds, true, false, false);
   child3->SetDrawsContent(true);
 
   child2->Set3dSortingContextId(1);
   child3->Set3dSortingContextId(1);
 
   child2->test_properties()->AddChild(std::move(child3));
   child1->test_properties()->AddChild(std::move(child2));
   root->test_properties()->AddChild(std::move(child1));
   LayerImpl* root_layer = root.get();
-  root_layer->layer_tree_impl()->SetRootLayer(std::move(root));
+  root_layer->layer_tree_impl()->SetRootLayerForTesting(std::move(root));
 
   {
     LayerImplList render_surface_layer_list;
     FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(root_layer);
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root_layer, root_layer->bounds(), &render_surface_layer_list);
     inputs.can_render_to_separate_surface = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
     EXPECT_EQ(2u, render_surface_layer_list.size());
@@ skipping 46 matching lines @@
     // Only root layer has a render surface.
     EXPECT_EQ(1, count_represents_target_render_surface);
     // No layer contributes a render surface to root render surface.
     EXPECT_EQ(0, count_represents_contributing_render_surface);
     // All 4 layers represent itself.
     EXPECT_EQ(4, count_represents_itself);
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleSurfaces) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* back_facing = AddChild<LayerImpl>(root);
   LayerImpl* render_surface1 = AddChild<LayerImpl>(back_facing);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(back_facing);
   LayerImpl* child1 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* child2 = AddChild<LayerImpl>(render_surface2);
   child1->SetDrawsContent(true);
   child2->SetDrawsContent(true);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
@@ skipping 53 matching lines @@
   // context.
   EXPECT_EQ(2u, render_surface_layer_list_impl()->size());
   EXPECT_EQ(1u, render_surface_layer_list_impl()
                     ->at(0)
                     ->render_surface()
                     ->layer_list()
                     .size());
 }
 
 TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleLayers) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   grand_child->SetDrawsContent(true);
 
   child->test_properties()->double_sided = false;
   grand_child->SetUseParentBackfaceVisibility(true);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), false, false,
@@ skipping 73 matching lines @@
   EXPECT_TRUE(child->should_check_backface_visibility());
   EXPECT_TRUE(grand_child->should_check_backface_visibility());
   // grand_child is in an existing 3d rendering context, so it should not use
   // local transform for backface visibility.
   EXPECT_TRUE(root->use_local_transform_for_backface_visibility());
   EXPECT_TRUE(child->use_local_transform_for_backface_visibility());
   EXPECT_FALSE(grand_child->use_local_transform_for_backface_visibility());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformAnimationUpdatesBackfaceVisibility) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* back_facing = AddChild<LayerImpl>(root);
   LayerImpl* render_surface1 = AddChild<LayerImpl>(back_facing);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(back_facing);
 
   gfx::Transform identity_transform;
   gfx::Transform rotate_about_y;
   rotate_about_y.RotateAboutYAxis(180.0);
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), false, true,
                                true);
@@ skipping 38 matching lines @@
 TEST_F(LayerTreeHostCommonTest, ClippedByScrollParent) {
   // Checks that the simple case (being clipped by a scroll parent that would
   // have been processed before you anyhow) results in the right clips.
   //
   // + root
   //   + scroll_parent_border
   //   | + scroll_parent_clip
   //   |   + scroll_parent
   //   + scroll_child
   //
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* scroll_parent_border = AddChildToRoot<LayerImpl>();
   LayerImpl* scroll_parent_clip = AddChild<LayerImpl>(scroll_parent_border);
   LayerImpl* scroll_parent = AddChild<LayerImpl>(scroll_parent_clip);
   LayerImpl* scroll_child = AddChild<LayerImpl>(root);
 
   scroll_parent->SetDrawsContent(true);
   scroll_child->SetDrawsContent(true);
   scroll_parent_clip->SetMasksToBounds(true);
 
   scroll_child->test_properties()->scroll_parent = scroll_parent;
@@ skipping 24 matching lines @@
 
   EXPECT_TRUE(root->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30), scroll_child->clip_rect());
   EXPECT_TRUE(scroll_child->is_clipped());
 }
 
 TEST_F(LayerTreeHostCommonTest, ScrollChildAndScrollParentDifferentTargets) {
   // Tests the computation of draw transform for the scroll child when its
   // target is different from its scroll parent's target.
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* scroll_child_target = AddChildToRoot<LayerImpl>();
   LayerImpl* scroll_child = AddChild<LayerImpl>(scroll_child_target);
   LayerImpl* scroll_parent_target = AddChild<LayerImpl>(scroll_child_target);
   LayerImpl* scroll_parent = AddChild<LayerImpl>(scroll_parent_target);
 
   scroll_parent->SetDrawsContent(true);
   scroll_child->SetDrawsContent(true);
 
   scroll_child->test_properties()->scroll_parent = scroll_parent;
   std::unique_ptr<std::set<LayerImpl*>> scroll_children(
@@ skipping 31 matching lines @@
   EXPECT_EQ(scroll_child->effect_tree_index(),
             scroll_child_target->effect_tree_index());
   EXPECT_EQ(scroll_child->visible_layer_rect(), gfx::Rect(10, 10, 40, 40));
   EXPECT_EQ(scroll_child->clip_rect(), gfx::Rect(15, 15, 75, 75));
   gfx::Transform scale;
   scale.Scale(1.5f, 1.5f);
   EXPECT_EQ(scroll_child->DrawTransform(), scale);
 }
 
 TEST_F(LayerTreeHostCommonTest, SingularTransformSubtreesDoNotDraw) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   root->SetDrawsContent(true);
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
   parent->SetDrawsContent(true);
   LayerImpl* child = AddChild<LayerImpl>(parent);
   child->SetDrawsContent(true);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, true,
                                true);
@@ skipping 33 matching lines @@
 TEST_F(LayerTreeHostCommonTest, ClippedByOutOfOrderScrollParent) {
   // Checks that clipping by a scroll parent that follows you in paint order
   // still results in correct clipping.
   //
   // + root
   //   + scroll_parent_border
   //     + scroll_parent_clip
   //       + scroll_parent
   //   + scroll_child
   //
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* scroll_parent_border = AddChild<LayerImpl>(root);
   LayerImpl* scroll_parent_clip = AddChild<LayerImpl>(scroll_parent_border);
   LayerImpl* scroll_parent = AddChild<LayerImpl>(scroll_parent_clip);
   LayerImpl* scroll_child = AddChild<LayerImpl>(root);
 
   scroll_parent->SetDrawsContent(true);
   scroll_child->SetDrawsContent(true);
 
   scroll_parent_clip->SetMasksToBounds(true);
 
@@ skipping 35 matching lines @@
   //
   // + root
   //   + scroll_child
   //   + scroll_parent_border
   //   | + scroll_parent_clip
   //   |   + scroll_parent
   //   + scroll_grandparent_border
   //     + scroll_grandparent_clip
   //       + scroll_grandparent
   //
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* scroll_child = AddChild<LayerImpl>(root);
   LayerImpl* scroll_parent_border = AddChild<LayerImpl>(root);
   LayerImpl* scroll_parent_clip = AddChild<LayerImpl>(scroll_parent_border);
   LayerImpl* scroll_parent = AddChild<LayerImpl>(scroll_parent_clip);
   LayerImpl* scroll_grandparent_border = AddChild<LayerImpl>(root);
   LayerImpl* scroll_grandparent_clip =
       AddChild<LayerImpl>(scroll_grandparent_border);
   LayerImpl* scroll_grandparent = AddChild<LayerImpl>(scroll_grandparent_clip);
 
   scroll_parent->SetDrawsContent(true);
@@ skipping 64 matching lines @@
   //   + scroll_child
   //   + scroll_parent_border
   //     + scroll_parent_clip
   //       + scroll_parent
   //         + render_surface2
   //   + scroll_grandparent_border
   //     + scroll_grandparent_clip
   //       + scroll_grandparent
   //         + render_surface1
   //
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   root->SetDrawsContent(true);
 
   LayerImpl* scroll_child = AddChild<LayerImpl>(root);
   scroll_child->SetDrawsContent(true);
 
   LayerImpl* scroll_parent_border = AddChild<LayerImpl>(root);
   LayerImpl* scroll_parent_clip = AddChild<LayerImpl>(scroll_parent_border);
   LayerImpl* scroll_parent = AddChild<LayerImpl>(scroll_parent_clip);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(scroll_parent);
   LayerImpl* scroll_grandparent_border = AddChild<LayerImpl>(root);
@@ skipping 77 matching lines @@
   // Ensures that when we have a render surface between a fixed position layer
   // and its container, we compute the fixed position layer's draw transform
   // with respect to that intervening render surface, not with respect to its
   // container's render target.
   //
   // + root
   //   + render_surface
   //     + fixed
   //       + child
   //
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChild<LayerImpl>(root);
   LayerImpl* fixed = AddChild<LayerImpl>(render_surface);
   LayerImpl* child = AddChild<LayerImpl>(fixed);
 
   render_surface->SetDrawsContent(true);
   fixed->SetDrawsContent(true);
   child->SetDrawsContent(true);
 
   render_surface->test_properties()->force_render_surface = true;
   root->test_properties()->is_container_for_fixed_position_layers = true;
@@ skipping 97 matching lines @@
   root->SetDrawsContent(true);
   container->SetDrawsContent(true);
   scroller->SetDrawsContent(true);
   fixed->SetDrawsContent(true);
   scroller->test_properties()->AddChild(std::move(fixed));
   container->test_properties()->AddChild(std::move(scroller));
   root->test_properties()->AddChild(std::move(container));
 
   // Rounded to integers already.
   {
-    root->layer_tree_impl()->SetRootLayer(std::move(root_ptr));
+    root->layer_tree_impl()->SetRootLayerForTesting(std::move(root_ptr));
     root->layer_tree_impl()->BuildLayerListAndPropertyTreesForTesting();
 
     gfx::Vector2dF scroll_delta(3.0, 5.0);
     SetScrollOffsetDelta(scroll_layer, scroll_delta);
 
     LayerImplList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), &render_surface_layer_list);
     root->layer_tree_impl()
         ->property_trees()
@@ skipping 68 matching lines @@
        ScrollSnappingWithAnimatedScreenSpaceTransform) {
   // This test verifies that a scrolling layer whose screen space transform is
   // animating doesn't get snapped to integer coordinates.
   //
   // + root
   //   + animated layer
   //     + surface
   //       + container
   //         + scroller
   //
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* animated_layer = AddChildToRoot<FakePictureLayerImpl>();
   LayerImpl* surface = AddChild<LayerImpl>(animated_layer);
   LayerImpl* container = AddChild<LayerImpl>(surface);
   LayerImpl* scroller = AddChild<LayerImpl>(container);
   scroller->SetScrollClipLayer(container->id());
   scroller->SetDrawsContent(true);
 
   gfx::Transform identity_transform;
   gfx::Transform start_scale;
   start_scale.Scale(1.5f, 1.5f);
@@ skipping 84 matching lines @@
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
   SetLayerPropertiesForTesting(child_raw, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
 
   SetLayerPropertiesForTesting(grand_child_raw, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
 
-  host_impl.active_tree()->SetRootLayer(std::move(grand_parent));
+  host_impl.active_tree()->SetRootLayerForTesting(std::move(grand_parent));
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // No layers have animations.
   EXPECT_EQ(
       0.f,
       grand_parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
@@ skipping 321 matching lines @@
   LayerImpl* grand_parent_raw = grand_parent.get();
   LayerImpl* parent_raw = parent.get();
   LayerImpl* child_raw = child.get();
   LayerImpl* grand_child1_raw = grand_child1.get();
   LayerImpl* grand_child2_raw = grand_child2.get();
 
   child->test_properties()->AddChild(std::move(grand_child1));
   child->test_properties()->AddChild(std::move(grand_child2));
   parent->test_properties()->AddChild(std::move(child));
   grand_parent->test_properties()->AddChild(std::move(parent));
-  host_impl.active_tree()->SetRootLayer(std::move(grand_parent));
+  host_impl.active_tree()->SetRootLayerForTesting(std::move(grand_parent));
 
   SetLayerPropertiesForTesting(grand_parent_raw, identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
                                true, false, true);
   SetLayerPropertiesForTesting(parent_raw, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
 
   SetLayerPropertiesForTesting(child_raw, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
@@ skipping 228 matching lines @@
       LayerImpl::Create(host_impl.active_tree(), 2);
   LayerImpl* child1_layer = child1.get();
   std::unique_ptr<LayerImpl> child2 =
       LayerImpl::Create(host_impl.active_tree(), 3);
   LayerImpl* child2_layer = child2.get();
 
   root->test_properties()->AddChild(std::move(child1));
   root->test_properties()->AddChild(std::move(child2));
   root->test_properties()->force_render_surface = true;
   root->SetDrawsContent(true);
-  host_impl.active_tree()->SetRootLayer(std::move(root));
+  host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
 
   gfx::Transform identity_matrix, scale_transform_child1,
       scale_transform_child2;
   scale_transform_child1.Scale(2, 3);
   scale_transform_child2.Scale(4, 5);
 
   SetLayerPropertiesForTesting(root_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 1), true, false,
                                true);
   SetLayerPropertiesForTesting(child1_layer, scale_transform_child1,
@@ skipping 100 matching lines @@
 
   EXPECT_FLOAT_EQ(
       0.f, root_layer->draw_properties().maximum_animation_contents_scale);
   EXPECT_FLOAT_EQ(
       0.f, child1_layer->draw_properties().maximum_animation_contents_scale);
   EXPECT_FLOAT_EQ(
       96.f, child2_layer->draw_properties().maximum_animation_contents_scale);
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectInChildRenderSurface) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip = AddChild<LayerImpl>(root);
   LayerImpl* content = AddChild<LayerImpl>(clip);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(768 / 2, 3000), true,
                                false, true);
   SetLayerPropertiesForTesting(clip, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(768 / 2, 10000), true,
                                false, false);
@@ skipping 36 matching lines @@
   gfx::Size root_size = gfx::Size(300, 500);
 
   // Sublayer should be bigger than the root enlarged by bounds_delta.
   gfx::Size sublayer_size = gfx::Size(300, 1000);
 
   // Device viewport accomidated the root and the top controls.
   gfx::Size device_viewport_size = gfx::Size(300, 600);
   gfx::Transform identity_matrix;
 
   host_impl.SetViewportSize(device_viewport_size);
-  host_impl.active_tree()->SetRootLayer(
+  host_impl.active_tree()->SetRootLayerForTesting(
       LayerImpl::Create(host_impl.active_tree(), 1));
 
-  LayerImpl* root = host_impl.active_tree()->root_layer();
+  LayerImpl* root = host_impl.active_tree()->root_layer_for_testing();
   SetLayerPropertiesForTesting(root,
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                root_size,
                                false,
                                false,
                                true);
   root->SetMasksToBounds(true);
 
@@ skipping 182 matching lines @@
   // means the clip cannot be projected into |surface|'s space, so we treat
   // |surface| and layers that draw into it as having empty visible rect.
   EXPECT_EQ(gfx::Rect(), surface->visible_layer_rect_for_testing());
   EXPECT_EQ(gfx::Rect(),
             descendant_of_animation->visible_layer_rect_for_testing());
 }
 
 // Verify that having an animated filter (but no current filter, as these
 // are mutually exclusive) correctly creates a render surface.
 TEST_F(LayerTreeHostCommonTest, AnimatedFilterCreatesRenderSurface) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grandchild = AddChild<LayerImpl>(child);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(grandchild, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
@@ skipping 11 matching lines @@
   EXPECT_TRUE(grandchild->filters().IsEmpty());
 
   EXPECT_FALSE(root->FilterIsAnimating());
   EXPECT_TRUE(child->FilterIsAnimating());
   EXPECT_FALSE(grandchild->FilterIsAnimating());
 }
 
 // Verify that having a filter animation with a delayed start time creates a
 // render surface.
 TEST_F(LayerTreeHostCommonTest, DelayedFilterAnimationCreatesRenderSurface) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grandchild = AddChild<LayerImpl>(child);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
   SetLayerPropertiesForTesting(grandchild, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false);
@@ skipping 29 matching lines @@
   EXPECT_FALSE(root->HasPotentiallyRunningFilterAnimation());
   EXPECT_FALSE(child->FilterIsAnimating());
   EXPECT_TRUE(child->HasPotentiallyRunningFilterAnimation());
   EXPECT_FALSE(grandchild->FilterIsAnimating());
   EXPECT_FALSE(grandchild->HasPotentiallyRunningFilterAnimation());
 }
 
 // Ensures that the property tree code accounts for offsets between fixed
 // position layers and their respective containers.
 TEST_F(LayerTreeHostCommonTest, PropertyTreesAccountForFixedParentOffset) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grandchild = AddChild<LayerImpl>(child);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
                                gfx::PointF(1000, 1000), gfx::Size(50, 50), true,
                                false, false);
@@ skipping 14 matching lines @@
 
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), grandchild->visible_layer_rect());
 }
 
 // Ensures that the property tree code accounts for offsets between fixed
 // position containers and their transform tree parents, when a fixed position
 // layer's container is its layer tree parent, but this parent doesn't have its
 // own transform tree node.
 TEST_F(LayerTreeHostCommonTest,
        PropertyTreesAccountForFixedParentOffsetWhenContainerIsParent) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grandchild = AddChild<LayerImpl>(child);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   SetLayerPropertiesForTesting(child, identity_transform, gfx::Point3F(),
                                gfx::PointF(1000, 1000), gfx::Size(50, 50), true,
                                false, false);
@@ skipping 62 matching lines @@
   rotated->AddChild(surface);
   surface->AddChild(container);
   surface->AddChild(box);
 
   host()->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, OnlyApplyFixedPositioningOnce) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* frame_clip = AddChild<LayerImpl>(root);
   LayerImpl* fixed = AddChild<LayerImpl>(frame_clip);
   gfx::Transform identity;
   gfx::Transform translate_z;
   translate_z.Translate3d(0, 0, 10);
 
   SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(800, 800), true, false, true);
   root->test_properties()->is_container_for_fixed_position_layers = true;
 
@@ skipping 10 matching lines @@
   fixed->test_properties()->position_constraint = constraint;
   fixed->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(root);
 
   gfx::Rect expected(0, 0, 100, 100);
   EXPECT_EQ(expected, fixed->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, FixedClipsShouldBeAssociatedWithTheRightNode) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* frame_clip = AddChild<LayerImpl>(root);
   LayerImpl* scroller = AddChild<LayerImpl>(frame_clip);
   LayerImpl* fixed = AddChild<LayerImpl>(scroller);
 
   gfx::Transform identity;
   SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(800, 800), true, false, true);
   SetLayerPropertiesForTesting(frame_clip, identity, gfx::Point3F(),
                                gfx::PointF(500, 100), gfx::Size(100, 100), true,
                                false, false);
@@ skipping 45 matching lines @@
   EXPECT_FALSE(host()->property_trees()->needs_rebuild);
 
   root->SetTransform(translate);
   EXPECT_FALSE(host()->property_trees()->needs_rebuild);
 
   root->SetTransform(rotate);
   EXPECT_TRUE(host()->property_trees()->needs_rebuild);
 }
 
 TEST_F(LayerTreeHostCommonTest, ChangeTransformOrigin) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
 
   gfx::Transform identity_matrix;
   gfx::Transform scale_matrix;
   scale_matrix.Scale(2.f, 2.f);
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                true);
   SetLayerPropertiesForTesting(child, scale_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
 
   root->SetDrawsContent(true);
   child->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(10, 10), child->visible_layer_rect());
 
   child->test_properties()->transform_origin = gfx::Point3F(10.f, 10.f, 10.f);
 
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(5, 5, 5, 5), child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, UpdateScrollChildPosition) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* scroll_parent = AddChild<LayerImpl>(root);
   LayerImpl* scroll_child = AddChild<LayerImpl>(scroll_parent);
 
   scroll_child->SetDrawsContent(true);
   scroll_child->test_properties()->scroll_parent = scroll_parent;
   std::unique_ptr<std::set<LayerImpl*>> scroll_children(
       new std::set<LayerImpl*>);
   scroll_children->insert(scroll_child);
   scroll_parent->test_properties()->scroll_children.reset(
       scroll_children.release());
@@ skipping 183 matching lines @@
   SetLayerPropertiesForTesting(grandchild.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
 
   LayerImpl* root_ptr = root.get();
   LayerImpl* child_ptr = child.get();
   LayerImpl* grandchild_ptr = grandchild.get();
 
   child->test_properties()->AddChild(std::move(grandchild));
   root->test_properties()->AddChild(std::move(child));
-  host_impl.active_tree()->SetRootLayer(std::move(root));
+  host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
 
   // Check the non-skipped case.
   // ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   // EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   // Now we will reset the visible rect from property trees for the grandchild,
   // and we will configure |child| in several ways that should force the subtree
   // to be skipped. The visible content rect for |grandchild| should, therefore,
   // remain empty.
   grandchild_ptr->set_visible_layer_rect(gfx::Rect());
@@ skipping 94 matching lines @@
   child_ptr->SetTransform(singular);
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
 
   host_impl.active_tree()->animation_host()->UnregisterPlayerForElement(
       root_ptr->id(), player.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerSkippingInSubtreeOfSingularTransform) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   gfx::Transform identity;
   SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(10, 10), true, false, true);
   SetLayerPropertiesForTesting(child, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(10, 10), true, false, false);
   SetLayerPropertiesForTesting(grand_child, identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
@@ skipping 70 matching lines @@
   SetLayerPropertiesForTesting(grandchild.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
 
   LayerImpl* root_ptr = root.get();
   LayerImpl* grandchild_ptr = grandchild.get();
 
   child->test_properties()->AddChild(std::move(grandchild));
   root->test_properties()->AddChild(std::move(child));
 
-  host_impl.pending_tree()->SetRootLayer(std::move(root));
+  host_impl.pending_tree()->SetRootLayerForTesting(std::move(root));
 
   // Check the non-skipped case.
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   std::unique_ptr<KeyframedFloatAnimationCurve> curve(
       KeyframedFloatAnimationCurve::Create());
   std::unique_ptr<TimingFunction> func =
       CubicBezierTimingFunction::CreatePreset(
           CubicBezierTimingFunction::EaseType::EASE);
@@ skipping 15 matching lines @@
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   host_impl.active_tree()->animation_host()->UnregisterPlayerForElement(
       root_ptr->id(), player.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingLayer) {
   gfx::Transform identity;
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
 
   SetLayerPropertiesForTesting(root, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(100, 100), true, false, true);
   SetLayerPropertiesForTesting(child, identity, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(10, 10), true, false, false);
   child->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(10, 10), child->visible_layer_rect());
@@ skipping 82 matching lines @@
   EXPECT_NE(-1, child->transform_tree_index());
 
   child->RemoveFromParent();
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(-1, child->transform_tree_index());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceClipsSubtree) {
   // Ensure that a Clip Node is added when a render surface applies clip.
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* significant_transform = AddChildToRoot<LayerImpl>();
   LayerImpl* layer_clips_subtree = AddChild<LayerImpl>(significant_transform);
   LayerImpl* render_surface = AddChild<LayerImpl>(layer_clips_subtree);
   LayerImpl* test_layer = AddChild<LayerImpl>(render_surface);
 
   const gfx::Transform identity_matrix;
   // This transform should be a significant one so that a transform node is
   // formed for it.
   gfx::Transform transform1;
   transform1.RotateAboutYAxis(45);
@@ skipping 41 matching lines @@
   ClipTree& clip_tree = root->layer_tree_impl()->property_trees()->clip_tree;
   ClipNode* clip_node = clip_tree.Node(render_surface->clip_tree_index());
   EXPECT_FALSE(clip_node->data.applies_local_clip);
   EXPECT_EQ(gfx::Rect(20, 20), test_layer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformOfParentClipNodeAncestorOfTarget) {
   // Ensure that when parent clip node's transform is an ancestor of current
   // clip node's target, clip is 'projected' from parent space to current
   // target space and visible rects are calculated correctly.
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_layer = AddChild<LayerImpl>(root);
   LayerImpl* target_layer = AddChild<LayerImpl>(clip_layer);
   LayerImpl* test_layer = AddChild<LayerImpl>(target_layer);
 
   const gfx::Transform identity_matrix;
   gfx::Transform transform;
   transform.RotateAboutYAxis(45);
   clip_layer->SetMasksToBounds(true);
   target_layer->SetMasksToBounds(true);
   test_layer->SetDrawsContent(true);
@@ skipping 12 matching lines @@
                                false);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(30, 30), test_layer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceWithUnclippedDescendantsClipsSubtree) {
   // Ensure clip rect is calculated correctly when render surface has unclipped
   // descendants.
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* between_clip_parent_and_child = AddChild<LayerImpl>(clip_parent);
   LayerImpl* render_surface =
       AddChild<LayerImpl>(between_clip_parent_and_child);
   LayerImpl* test_layer = AddChild<LayerImpl>(render_surface);
 
   const gfx::Transform identity_matrix;
   gfx::Transform translate;
   translate.Translate(2.0, 2.0);
 
@@ skipping 25 matching lines @@
   EXPECT_FALSE(test_layer->render_target()->is_clipped());
   EXPECT_EQ(gfx::Rect(-2, -2, 30, 30), test_layer->clip_rect());
   EXPECT_EQ(gfx::Rect(28, 28), test_layer->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceWithUnclippedDescendantsButDoesntApplyOwnClip) {
   // Ensure that the visible layer rect of a descendant of a surface with
   // unclipped descendants is computed correctly, when the surface doesn't apply
   // a clip.
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface);
   LayerImpl* child = AddChild<LayerImpl>(render_surface);
 
   const gfx::Transform identity_matrix;
 
   clip_child->SetDrawsContent(true);
   child->SetDrawsContent(true);
   clip_child->test_properties()->clip_parent = clip_parent;
@@ skipping 15 matching lines @@
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(40, 40), true, false,
                                false);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(40, 40), child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceClipsSubtreeAndHasUnclippedDescendants) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* test_layer1 = AddChild<LayerImpl>(render_surface);
   LayerImpl* clip_child = AddChild<LayerImpl>(test_layer1);
   LayerImpl* test_layer2 = AddChild<LayerImpl>(clip_child);
 
   const gfx::Transform identity_matrix;
   root->SetMasksToBounds(true);
   render_surface->SetMasksToBounds(true);
   render_surface->SetDrawsContent(true);
@@ skipping 25 matching lines @@
                                false);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(30, 30), render_surface->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(30, 30), test_layer1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(30, 30), clip_child->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(30, 30), test_layer2->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, UnclippedClipParent) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface);
 
   const gfx::Transform identity_matrix;
   clip_parent->SetDrawsContent(true);
   render_surface->SetMasksToBounds(true);
   render_surface->SetDrawsContent(true);
   clip_child->SetDrawsContent(true);
 
@@ skipping 21 matching lines @@
   // tree parent's clipping state.
   EXPECT_FALSE(clip_parent->is_clipped());
   EXPECT_TRUE(render_surface->is_clipped());
   EXPECT_FALSE(clip_child->is_clipped());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceContentRectWithMultipleSurfaces) {
   // Tests the value of render surface content rect when we have multiple types
   // of surfaces : unclipped surfaces, surfaces with unclipped surfaces and
   // clipped surfaces.
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* unclipped_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* clip_parent = AddChild<LayerImpl>(unclipped_surface);
   LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* unclipped_desc_surface2 =
       AddChild<LayerImpl>(unclipped_desc_surface);
   LayerImpl* clip_child = AddChild<LayerImpl>(unclipped_desc_surface2);
   LayerImpl* clipped_surface = AddChild<LayerImpl>(clip_child);
 
   unclipped_surface->SetDrawsContent(true);
   unclipped_desc_surface->SetDrawsContent(true);
@@ skipping 37 matching lines @@
             unclipped_desc_surface->render_surface()->content_rect());
   EXPECT_EQ(gfx::Rect(50, 50),
             unclipped_desc_surface2->render_surface()->content_rect());
   EXPECT_EQ(gfx::Rect(50, 50),
             clipped_surface->render_surface()->content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipBetweenClipChildTargetAndClipParentTarget) {
   // Tests the value of render surface content rect when we have a layer that
   // clips between the clip parent's target and clip child's target.
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* surface = AddChildToRoot<LayerImpl>();
   LayerImpl* clip_layer = AddChild<LayerImpl>(surface);
   LayerImpl* clip_parent = AddChild<LayerImpl>(clip_layer);
   LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(unclipped_desc_surface);
 
   clip_child->SetDrawsContent(true);
   unclipped_desc_surface->SetDrawsContent(true);
   clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
@@ skipping 24 matching lines @@
   surface->SetMasksToBounds(true);
   clip_layer->SetMasksToBounds(true);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(10, 10),
             unclipped_desc_surface->render_surface()->content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleRectForDescendantOfScaledSurface) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* surface = AddChildToRoot<LayerImpl>();
   LayerImpl* clip_layer = AddChild<LayerImpl>(surface);
   LayerImpl* clip_parent = AddChild<LayerImpl>(clip_layer);
   LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(unclipped_desc_surface);
 
   clip_child->SetDrawsContent(true);
   unclipped_desc_surface->SetDrawsContent(true);
   clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
@@ skipping 22 matching lines @@
                                false);
   surface->SetMasksToBounds(true);
   clip_layer->SetMasksToBounds(true);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(20, 20), clip_child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerWithInputHandlerAndZeroOpacity) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChild<LayerImpl>(root);
   LayerImpl* test_layer = AddChild<LayerImpl>(render_surface);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   gfx::Transform translation;
   translation.Translate(10, 10);
   SetLayerPropertiesForTesting(test_layer, translation, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(20, 20), true, false,
                                false);
 
   render_surface->SetMasksToBounds(true);
   test_layer->SetDrawsContent(true);
   test_layer->test_properties()->opacity = 0.f;
   test_layer->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 20, 20));
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(translation, test_layer->ScreenSpaceTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipChildVisibleRect) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface);
 
   const gfx::Transform identity_matrix;
   clip_parent->SetMasksToBounds(true);
   render_surface->SetMasksToBounds(true);
   render_surface->SetDrawsContent(true);
   clip_child->SetDrawsContent(true);
   clip_child->test_properties()->clip_parent = clip_parent;
@@ skipping 13 matching lines @@
   SetLayerPropertiesForTesting(clip_child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(40, 40), clip_child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        LayerClipRectLargerThanClippingRenderSurfaceRect) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChild<LayerImpl>(root);
   LayerImpl* test_layer = AddChild<LayerImpl>(render_surface);
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   SetLayerPropertiesForTesting(test_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
   root->SetMasksToBounds(true);
   root->SetDrawsContent(true);
   render_surface->SetMasksToBounds(true);
   render_surface->SetDrawsContent(true);
   test_layer->SetMasksToBounds(true);
   test_layer->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(30, 30), root->clip_rect());
   EXPECT_EQ(gfx::Rect(50, 50), render_surface->clip_rect());
   EXPECT_EQ(gfx::Rect(50, 50), test_layer->clip_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, SubtreeIsHiddenTest) {
   // Tests that subtree is hidden is updated.
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* hidden = AddChild<LayerImpl>(root);
   LayerImpl* test = AddChild<LayerImpl>(hidden);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   SetLayerPropertiesForTesting(hidden, identity_matrix, gfx::Point3F(),
                                gfx::PointF(10, 10), gfx::Size(30, 30), true,
                                false, true);
   SetLayerPropertiesForTesting(test, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
 
   hidden->test_properties()->hide_layer_and_subtree = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRUE(test->IsHidden());
 
   hidden->test_properties()->hide_layer_and_subtree = false;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(test->IsHidden());
 }
 
 TEST_F(LayerTreeHostCommonTest, TwoUnclippedRenderSurfaces) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface2);
 
   const gfx::Transform identity_matrix;
   clip_child->test_properties()->clip_parent = root;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
   root->test_properties()->clip_children.reset(clip_children.release());
   root->SetMasksToBounds(true);
@@ skipping 15 matching lines @@
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(-10, -10, 30, 30), render_surface2->clip_rect());
   // A clip node is created for every render surface and for layers that have
   // local clip. So, here it should be craeted for every layer.
   EXPECT_EQ(root->layer_tree_impl()->property_trees()->clip_tree.size(), 5u);
 }
 
 TEST_F(LayerTreeHostCommonTest, MaskLayerDrawProperties) {
   // Tests that a mask layer's draw properties are computed correctly.
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   child->test_properties()->SetMaskLayer(
       LayerImpl::Create(root->layer_tree_impl(), 100));
   LayerImpl* mask = child->test_properties()->mask_layer;
 
   const gfx::Transform identity_matrix;
   gfx::Transform transform;
   transform.Translate(10, 10);
 
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
@@ skipping 26 matching lines @@
   transform.Translate(10, 10);
   child->SetTransform(transform);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(transform, mask->ScreenSpaceTransform());
   EXPECT_EQ(gfx::Rect(20, 20), mask->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, ReplicaMaskLayerDrawProperties) {
   // Tests that a replica mask layer's draw properties are computed correctly.
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   child->test_properties()->SetReplicaLayer(
       LayerImpl::Create(root->layer_tree_impl(), 100));
   LayerImpl* replica = child->test_properties()->replica_layer;
   replica->test_properties()->parent = child;
   replica->test_properties()->SetMaskLayer(
       LayerImpl::Create(root->layer_tree_impl(), 200));
   LayerImpl* replica_mask = replica->test_properties()->mask_layer;
 
   const gfx::Transform identity_matrix;
@@ skipping 36 matching lines @@
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRUE(replica_mask->is_drawn_render_surface_layer_list_member());
   EXPECT_EQ(gfx::Rect(20, 20), replica_mask->visible_layer_rect());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_screen_space_transform,
                                   replica_mask->ScreenSpaceTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        SublayerScaleWithTransformNodeBetweenTwoTargets) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
   LayerImpl* between_targets = AddChild<LayerImpl>(render_surface1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(between_targets);
   LayerImpl* test_layer = AddChild<LayerImpl>(render_surface2);
   const gfx::Transform identity_matrix;
   test_layer->SetDrawsContent(true);
 
   gfx::Transform scale;
   scale.Scale(2.f, 2.f);
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
@@ skipping 26 matching lines @@
   node = tree.Node(between_targets->transform_tree_index());
   EXPECT_EQ(node->data.sublayer_scale, gfx::Vector2dF(1.f, 1.f));
 
   node = tree.Node(render_surface2->transform_tree_index());
   EXPECT_EQ(node->data.sublayer_scale, gfx::Vector2dF(2.f, 2.f));
 
   EXPECT_EQ(gfx::Rect(15, 15), test_layer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, LargeTransformTest) {
-  LayerImpl* root = root_layer();
+  LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(render_surface1);
 
   const gfx::Transform identity_matrix;
   child->SetDrawsContent(true);
   child->SetMasksToBounds(true);
 
   gfx::Transform large_transform;
   large_transform.Scale(99999999999999999999.f, 99999999999999999999.f);
   large_transform.Scale(9999999999999999999.f, 9999999999999999999.f);
@@ skipping 421 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