cc: Move LayerImpl::AddChild and RemoveChild to LayerImplTestProperties

cc/trees/layer_tree_impl_unittest.cc

 // Copyright 2014 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_impl.h"
 
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/solid_color_scrollbar_layer_impl.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
@@ skipping 151 matching lines @@
                                position, bounds, true, false, true);
   root->SetDrawsContent(true);
 
   // Create hud and add it as a child of root.
   gfx::Size hud_bounds(200, 200);
   SetLayerPropertiesForTesting(hud.get(), identity_matrix, transform_origin,
                                position, hud_bounds, true, false, false);
   hud->SetDrawsContent(true);
 
   host_impl().active_tree()->set_hud_layer(hud.get());
-  root->AddChild(std::move(hud));
+  root->test_properties()->AddChild(std::move(hud));
 
   host_impl().SetViewportSize(hud_bounds);
   host_impl().active_tree()->SetRootLayer(std::move(root));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(2u, root_layer()->render_surface()->layer_list().size());
 
   // Hit testing for a point inside HUD, but outside root should return null
@@ skipping 228 matching lines @@
                                false);
   clip->SetMasksToBounds(true);
 
   std::unique_ptr<LayerImpl> test =
       LayerImpl::Create(host_impl().active_tree(), 5);
   SetLayerPropertiesForTesting(test.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                false);
   test->SetDrawsContent(true);
 
-  clip->AddChild(std::move(test));
-  scale->AddChild(std::move(clip));
-  render_surface->AddChild(std::move(scale));
-  root->AddChild(std::move(render_surface));
+  clip->test_properties()->AddChild(std::move(test));
+  scale->test_properties()->AddChild(std::move(clip));
+  render_surface->test_properties()->AddChild(std::move(scale));
+  root->test_properties()->AddChild(std::move(render_surface));
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   gfx::PointF test_point(160.f, 160.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
@@ skipping 23 matching lines @@
                                false);
   child1->SetMasksToBounds(true);
   child1->SetDrawsContent(true);
   std::unique_ptr<LayerImpl> child2 =
       LayerImpl::Create(host_impl().active_tree(), 3);
   SetLayerPropertiesForTesting(child2.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(75, 75), true, false,
                                false);
   child2->SetMasksToBounds(true);
   child2->SetDrawsContent(true);
-  root->AddChild(std::move(child1));
-  root->AddChild(std::move(child2));
+  root->test_properties()->AddChild(std::move(child1));
+  root->test_properties()->AddChild(std::move(child2));
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   gfx::PointF test_point(50.f, 50.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(3, result_layer->id());
@@ skipping 10 matching lines @@
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), bounds, true, false, true);
 
   std::unique_ptr<LayerImpl> surface =
       LayerImpl::Create(host_impl().active_tree(), 2);
   SetLayerPropertiesForTesting(surface.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), bounds, true, false, true);
   surface->SetMasksToBounds(true);
   surface->SetDrawsContent(true);
 
-  root->AddChild(std::move(surface));
+  root->test_properties()->AddChild(std::move(surface));
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   gfx::PointF test_point(max_texture_size - 50, max_texture_size - 50);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_TRUE(result_layer);
 
   test_point = gfx::PointF(max_texture_size + 50, max_texture_size + 50);
@@ skipping 84 matching lines @@
                                  false, false);
     clipping_layer->SetMasksToBounds(true);
 
     std::unique_ptr<LayerImpl> child =
         LayerImpl::Create(host_impl().active_tree(), 456);
     position = gfx::PointF(-50.f, -50.f);
     bounds = gfx::Size(300, 300);
     SetLayerPropertiesForTesting(child.get(), identity_matrix, transform_origin,
                                  position, bounds, true, false, false);
     child->SetDrawsContent(true);
-    clipping_layer->AddChild(std::move(child));
-    root->AddChild(std::move(clipping_layer));
+    clipping_layer->test_properties()->AddChild(std::move(child));
+    root->test_properties()->AddChild(std::move(clipping_layer));
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
   ASSERT_EQ(456, root_layer()->render_surface()->layer_list().at(0)->id());
@@ skipping 85 matching lines @@
     rotated_leaf_transform.Translate(50.0, 50.0);
     rotated_leaf_transform.RotateAboutZAxis(45.0);
     rotated_leaf_transform.Translate(-50.0, -50.0);
     position = gfx::PointF();
     bounds = gfx::Size(100, 100);
     SetLayerPropertiesForTesting(rotated_leaf.get(), rotated_leaf_transform,
                                  transform_origin, position, bounds, true,
                                  false, false);
     rotated_leaf->SetDrawsContent(true);
 
-    grand_child->AddChild(std::move(rotated_leaf));
-    child->AddChild(std::move(grand_child));
-    root->AddChild(std::move(child));
+    grand_child->test_properties()->AddChild(std::move(rotated_leaf));
+    child->test_properties()->AddChild(std::move(grand_child));
+    root->test_properties()->AddChild(std::move(child));
     host_impl().active_tree()->SetRootLayer(std::move(root));
 
     ExecuteCalculateDrawProperties(root_layer);
   }
 
   host_impl().SetViewportSize(root_layer->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
   // (11, 89) is close to the the bottom left corner within the clip, but it is
   // not inside the layer.
   gfx::PointF test_point(11.f, 89.f);
@@ skipping 69 matching lines @@
     // The child of the intermediate_layer is translated so that it does not
     // overlap intermediate_layer at all.  If child is incorrectly clipped, we
     // would not be able to hit it successfully.
     std::unique_ptr<LayerImpl> child =
         LayerImpl::Create(host_impl().active_tree(), 456);
     position = gfx::PointF(60.f, 60.f);  // 70, 70 in screen space
     bounds = gfx::Size(20, 20);
     SetLayerPropertiesForTesting(child.get(), identity_matrix, transform_origin,
                                  position, bounds, true, false, false);
     child->SetDrawsContent(true);
-    intermediate_layer->AddChild(std::move(child));
-    root->AddChild(std::move(intermediate_layer));
+    intermediate_layer->test_properties()->AddChild(std::move(child));
+    root->test_properties()->AddChild(std::move(intermediate_layer));
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
   ASSERT_EQ(456, root_layer()->render_surface()->layer_list().at(0)->id());
@@ skipping 66 matching lines @@
     // Remember that grand_child is positioned with respect to its parent (i.e.
     // child1).  In screen space, the intended position is (10, 50), with size
     // 100 x 50.
     position = gfx::PointF(0.f, 40.f);
     bounds = gfx::Size(100, 50);
     SetLayerPropertiesForTesting(grand_child1.get(), identity_matrix,
                                  transform_origin, position, bounds, true,
                                  false, false);
     grand_child1->SetDrawsContent(true);
 
-    child1->AddChild(std::move(grand_child1));
-    root->AddChild(std::move(child1));
-    root->AddChild(std::move(child2));
+    child1->test_properties()->AddChild(std::move(grand_child1));
+    root->test_properties()->AddChild(std::move(child1));
+    root->test_properties()->AddChild(std::move(child2));
     host_impl().active_tree()->SetRootLayer(std::move(root));
 
     ExecuteCalculateDrawProperties(root_layer);
   }
 
   LayerImpl* child1 = root_layer->test_properties()->children[0];
   LayerImpl* child2 = root_layer->test_properties()->children[1];
   LayerImpl* grand_child1 = child1->test_properties()->children[0];
 
   host_impl().SetViewportSize(root_layer->bounds());
@@ skipping 99 matching lines @@
   {
     gfx::Transform translate_z;
     translate_z.Translate3d(0, 0, right_child_depth);
     SetLayerPropertiesForTesting(right_child.get(), translate_z,
                                  transform_origin, position, bounds, false,
                                  false, false);
     right_child->SetDrawsContent(true);
     right_child->Set3dSortingContextId(right_child_sorting_context);
   }
 
-  root->AddChild(std::move(left_child));
-  root->AddChild(std::move(right_child));
+  root->test_properties()->AddChild(std::move(left_child));
+  root->test_properties()->AddChild(std::move(right_child));
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
   CHECK_EQ(1u, RenderSurfaceLayerList().size());
 
   gfx::PointF test_point = gfx::PointF(1.f, 1.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 
@@ skipping 87 matching lines @@
     // child1).  In screen space, the intended position is (10, 50), with size
     // 100 x 50.
     position = gfx::PointF(0.f, 40.f);
     bounds = gfx::Size(100, 50);
     SetLayerPropertiesForTesting(grand_child1.get(), identity_matrix,
                                  transform_origin, position, bounds, true,
                                  false, false);
     grand_child1->SetDrawsContent(true);
     grand_child1->test_properties()->should_flatten_transform = false;
 
-    child1->AddChild(std::move(grand_child1));
-    root->AddChild(std::move(child1));
-    root->AddChild(std::move(child2));
+    child1->test_properties()->AddChild(std::move(grand_child1));
+    root->test_properties()->AddChild(std::move(child1));
+    root->test_properties()->AddChild(std::move(child2));
   }
 
   LayerImpl* child1 = root->test_properties()->children[0];
   LayerImpl* child2 = root->test_properties()->children[1];
   LayerImpl* grand_child1 = child1->test_properties()->children[0];
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
@@ skipping 83 matching lines @@
     grand_child->SetDrawsContent(true);
     grand_child->SetHasRenderSurface(true);
 
     // This should let |grand_child| "escape" |child|'s clip.
     grand_child->test_properties()->clip_parent = root.get();
     std::unique_ptr<std::set<LayerImpl*>> clip_children(
         new std::set<LayerImpl*>);
     clip_children->insert(grand_child.get());
     root->test_properties()->clip_children.reset(clip_children.release());
 
-    child->AddChild(std::move(grand_child));
-    root->AddChild(std::move(child));
+    child->test_properties()->AddChild(std::move(grand_child));
+    root->test_properties()->AddChild(std::move(child));
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   gfx::PointF test_point(12.f, 52.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
@@ skipping 39 matching lines @@
         new std::set<LayerImpl*>);
     scroll_children->insert(scroll_child.get());
     child->test_properties()->scroll_children.reset(scroll_children.release());
 
     SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
                                  transform_origin, position, bounds, true,
                                  false, false);
     grand_child->SetDrawsContent(true);
     grand_child->SetHasRenderSurface(true);
 
-    scroll_child->AddChild(std::move(grand_child));
-    root->AddChild(std::move(scroll_child));
-    root->AddChild(std::move(child));
+    scroll_child->test_properties()->AddChild(std::move(grand_child));
+    root->test_properties()->AddChild(std::move(scroll_child));
+    root->test_properties()->AddChild(std::move(child));
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   gfx::PointF test_point(12.f, 52.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   // The |test_point| should have been clipped away by |child|, the scroll
@@ skipping 51 matching lines @@
     // child1).  In screen space, the intended position is (10, 50), with size
     // 100 x 50.
     position = gfx::PointF(0.f, 40.f);
     bounds = gfx::Size(100, 50);
     SetLayerPropertiesForTesting(grand_child1.get(), identity_matrix,
                                  transform_origin, position, bounds, true,
                                  false, false);
     grand_child1->SetDrawsContent(true);
     grand_child1->test_properties()->force_render_surface = true;
 
-    child1->AddChild(std::move(grand_child1));
-    root->AddChild(std::move(child1));
-    root->AddChild(std::move(child2));
+    child1->test_properties()->AddChild(std::move(grand_child1));
+    root->test_properties()->AddChild(std::move(child1));
+    root->test_properties()->AddChild(std::move(child2));
     host_impl().active_tree()->SetRootLayer(std::move(root));
 
     ExecuteCalculateDrawProperties(root_layer);
   }
 
   LayerImpl* child1 = root_layer->test_properties()->children[0];
   LayerImpl* child2 = root_layer->test_properties()->children[1];
   LayerImpl* grand_child1 = child1->test_properties()->children[0];
 
   host_impl().SetViewportSize(root_layer->bounds());
@@ skipping 305 matching lines @@
     gfx::PointF position(25.f, 25.f);
     gfx::Size bounds(50, 50);
     std::unique_ptr<LayerImpl> test_layer =
         LayerImpl::Create(host_impl().active_tree(), 12345);
     SetLayerPropertiesForTesting(test_layer.get(), identity_matrix,
                                  transform_origin, position, bounds, true,
                                  false, false);
 
     test_layer->SetDrawsContent(true);
     test_layer->SetTouchEventHandlerRegion(touch_handler_region);
-    root->AddChild(std::move(test_layer));
+    root->test_properties()->AddChild(std::move(test_layer));
   }
 
   float device_scale_factor = 3.f;
   float page_scale_factor = 5.f;
   float max_page_scale_factor = 10.f;
   gfx::Size scaled_bounds_for_root = gfx::ScaleToCeiledSize(
       root->bounds(), device_scale_factor * page_scale_factor);
   host_impl().SetViewportSize(scaled_bounds_for_root);
 
   host_impl().active_tree()->SetDeviceScaleFactor(device_scale_factor);
@@ skipping 134 matching lines @@
 
     std::unique_ptr<LayerImpl> child =
         LayerImpl::Create(host_impl().active_tree(), 456);
     Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
     position = gfx::PointF(-50.f, -50.f);
     bounds = gfx::Size(300, 300);
     SetLayerPropertiesForTesting(child.get(), identity_matrix, transform_origin,
                                  position, bounds, true, false, false);
     child->SetDrawsContent(true);
     child->SetTouchEventHandlerRegion(touch_handler_region);
-    clipping_layer->AddChild(std::move(child));
-    root->AddChild(std::move(clipping_layer));
+    clipping_layer->test_properties()->AddChild(std::move(child));
+    root->test_properties()->AddChild(std::move(clipping_layer));
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
   ASSERT_EQ(456, root_layer()->render_surface()->layer_list().at(0)->id());
@@ skipping 71 matching lines @@
 
     std::unique_ptr<LayerImpl> child =
         LayerImpl::Create(host_impl().active_tree(), 456);
     Region touch_handler_region(gfx::Rect(0, 0, 300, 300));
     position = gfx::PointF(-50.f, -50.f);
     bounds = gfx::Size(300, 300);
     SetLayerPropertiesForTesting(child.get(), identity_matrix, transform_origin,
                                  position, bounds, true, false, false);
     child->SetDrawsContent(true);
     child->SetTouchEventHandlerRegion(touch_handler_region);
-    clipping_layer->AddChild(std::move(child));
-    surface->AddChild(std::move(clipping_layer));
-    root->AddChild(std::move(surface));
+    clipping_layer->test_properties()->AddChild(std::move(child));
+    surface->test_properties()->AddChild(std::move(clipping_layer));
+    root->test_properties()->AddChild(std::move(surface));
   }
 
   float device_scale_factor = 3.f;
   float page_scale_factor = 1.f;
   float max_page_scale_factor = 1.f;
   gfx::Size scaled_bounds_for_root = gfx::ScaleToCeiledSize(
       root->bounds(), device_scale_factor * page_scale_factor);
   host_impl().SetViewportSize(scaled_bounds_for_root);
 
   host_impl().active_tree()->SetDeviceScaleFactor(device_scale_factor);
@@ skipping 46 matching lines @@
         LayerImpl::Create(host_impl().active_tree(), 123);
     // this layer is positioned, and hit testing should correctly know where the
     // layer is located.
     gfx::PointF position;
     gfx::Size bounds(50, 50);
     SetLayerPropertiesForTesting(touch_layer.get(), identity_matrix,
                                  transform_origin, position, bounds, true,
                                  false, false);
     touch_layer->SetDrawsContent(true);
     touch_layer->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 50, 50));
-    root->AddChild(std::move(touch_layer));
+    root->test_properties()->AddChild(std::move(touch_layer));
   }
 
   {
     std::unique_ptr<LayerImpl> notouch_layer =
         LayerImpl::Create(host_impl().active_tree(), 1234);
     // this layer is positioned, and hit testing should correctly know where the
     // layer is located.
     gfx::PointF position(0, 25);
     gfx::Size bounds(50, 50);
     SetLayerPropertiesForTesting(notouch_layer.get(), identity_matrix,
                                  transform_origin, position, bounds, true,
                                  false, false);
     notouch_layer->SetDrawsContent(true);
-    root->AddChild(std::move(notouch_layer));
+    root->test_properties()->AddChild(std::move(notouch_layer));
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(2u, root_layer()->render_surface()->layer_list().size());
   ASSERT_EQ(123, root_layer()->render_surface()->layer_list().at(0)->id());
@@ skipping 48 matching lines @@
     gfx::PointF position;
     gfx::Size bounds(50, 50);
     std::unique_ptr<LayerImpl> test_layer =
         LayerImpl::Create(host_impl().active_tree(), 12345);
     SetLayerPropertiesForTesting(test_layer.get(), identity_matrix,
                                  transform_origin, position, bounds, true,
                                  false, false);
 
     test_layer->SetDrawsContent(false);
     test_layer->SetTouchEventHandlerRegion(touch_handler_region);
-    root->AddChild(std::move(test_layer));
+    root->test_properties()->AddChild(std::move(test_layer));
   }
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   LayerImpl* test_layer =
       host_impl().active_tree()->root_layer()->test_properties()->children[0];
   // As test_layer doesn't draw content, the layer list of root's render surface
   // should contain only the root layer.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
@@ skipping 152 matching lines @@
     clipping_layer->SetMasksToBounds(true);
 
     std::unique_ptr<LayerImpl> clipped_layer =
         LayerImpl::Create(host_impl().active_tree(), clipped_layer_id);
     position = gfx::PointF();
     bounds = gfx::Size(100, 100);
     SetLayerPropertiesForTesting(clipped_layer.get(), identity_matrix,
                                  transform_origin, position, bounds, true,
                                  false, false);
     clipped_layer->SetDrawsContent(true);
-    clipping_layer->AddChild(std::move(clipped_layer));
-    root->AddChild(std::move(clipping_layer));
+    clipping_layer->test_properties()->AddChild(std::move(clipped_layer));
+    root->test_properties()->AddChild(std::move(clipping_layer));
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
 
   LayerSelection input;
@@ skipping 66 matching lines @@
   gfx::Vector2dF sub_layer_offset(10, 0);
   {
     std::unique_ptr<LayerImpl> sub_layer =
         LayerImpl::Create(host_impl().active_tree(), sub_layer_id);
     gfx::PointF position = gfx::PointF() + sub_layer_offset;
     gfx::Size bounds(50, 50);
     SetLayerPropertiesForTesting(sub_layer.get(), identity_matrix,
                                  transform_origin, position, bounds, true,
                                  false, false);
     sub_layer->SetDrawsContent(true);
-    root->AddChild(std::move(sub_layer));
+    root->test_properties()->AddChild(std::move(sub_layer));
   }
 
   float device_scale_factor = 3.f;
   float page_scale_factor = 5.f;
   gfx::Size scaled_bounds_for_root = gfx::ScaleToCeiledSize(
       root->bounds(), device_scale_factor * page_scale_factor);
   host_impl().SetViewportSize(scaled_bounds_for_root);
 
   host_impl().active_tree()->SetDeviceScaleFactor(device_scale_factor);
   host_impl().active_tree()->SetPageScaleOnActiveTree(page_scale_factor);
@@ skipping 71 matching lines @@
     SetLayerPropertiesForTesting(child.get(), large_transform, transform_origin,
                                  position, bounds, true, false, false);
 
     std::unique_ptr<LayerImpl> grand_child =
         LayerImpl::Create(host_impl().active_tree(), grand_child_id);
     SetLayerPropertiesForTesting(grand_child.get(), large_transform,
                                  transform_origin, position, bounds, true,
                                  false, false);
     grand_child->SetDrawsContent(true);
 
-    child->AddChild(std::move(grand_child));
-    root->AddChild(std::move(child));
+    child->test_properties()->AddChild(std::move(grand_child));
+    root->test_properties()->AddChild(std::move(child));
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   LayerSelection input;
 
   input.start.type = gfx::SelectionBound::LEFT;
   input.start.edge_top = gfx::Point(10, 10);
@@ skipping 20 matching lines @@
   EXPECT_EQ(0u, host_impl().active_tree()->NumLayers());
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), 1);
   EXPECT_EQ(1u, host_impl().active_tree()->NumLayers());
 }
 
 TEST_F(LayerTreeImplTest, NumLayersSmallTree) {
   EXPECT_EQ(0u, host_impl().active_tree()->NumLayers());
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), 1);
-  root->AddChild(LayerImpl::Create(host_impl().active_tree(), 2));
-  root->AddChild(LayerImpl::Create(host_impl().active_tree(), 3));
-  root->test_properties()->children[1]->AddChild(
+  root->test_properties()->AddChild(
+      LayerImpl::Create(host_impl().active_tree(), 2));
+  root->test_properties()->AddChild(
+      LayerImpl::Create(host_impl().active_tree(), 3));
+  root->test_properties()->children[1]->test_properties()->AddChild(
       LayerImpl::Create(host_impl().active_tree(), 4));
   EXPECT_EQ(4u, host_impl().active_tree()->NumLayers());
 }
 
 TEST_F(LayerTreeImplTest, DeviceScaleFactorNeedsDrawPropertiesUpdate) {
   host_impl().active_tree()->SetDeviceScaleFactor(1.f);
   host_impl().active_tree()->UpdateDrawProperties(false);
   EXPECT_FALSE(host_impl().active_tree()->needs_update_draw_properties());
   host_impl().active_tree()->SetDeviceScaleFactor(2.f);
   EXPECT_TRUE(host_impl().active_tree()->needs_update_draw_properties());
@@ skipping 28 matching lines @@
     left_child->SetDrawsContent(true);
   }
   {
     gfx::Transform translate_z;
     translate_z.Translate3d(0, 0, 10);
     SetLayerPropertiesForTesting(right_child.get(), translate_z,
                                  transform_origin, position, bounds, false,
                                  false, false);
   }
 
-  root->AddChild(std::move(left_child));
-  root->AddChild(std::move(right_child));
+  root->test_properties()->AddChild(std::move(left_child));
+  root->test_properties()->AddChild(std::move(right_child));
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
   CHECK_EQ(1u, RenderSurfaceLayerList().size());
 
   gfx::PointF test_point = gfx::PointF(1.f, 1.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 
   CHECK(result_layer);
   EXPECT_EQ(2, result_layer->id());
 }
 
 }  // namespace
 }  // namespace cc