cc: Move LayerImpl::AddChild and RemoveChild to LayerImplTestProperties

cc/trees/layer_tree_host_impl_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_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 313 matching lines @@
                                                        gfx::ScrollOffset());
     outer_scroll->SetBounds(content_size);
     outer_scroll->SetPosition(gfx::PointF());
 
     std::unique_ptr<LayerImpl> contents =
         LayerImpl::Create(layer_tree_impl, kContentLayerId);
     contents->SetDrawsContent(true);
     contents->SetBounds(content_size);
     contents->SetPosition(gfx::PointF());
 
-    outer_scroll->AddChild(std::move(contents));
-    outer_clip->AddChild(std::move(outer_scroll));
-    inner_scroll->AddChild(std::move(outer_clip));
-    page_scale->AddChild(std::move(inner_scroll));
-    inner_clip->AddChild(std::move(page_scale));
-    root->AddChild(std::move(inner_clip));
+    outer_scroll->test_properties()->AddChild(std::move(contents));
+    outer_clip->test_properties()->AddChild(std::move(outer_scroll));
+    inner_scroll->test_properties()->AddChild(std::move(outer_clip));
+    page_scale->test_properties()->AddChild(std::move(inner_scroll));
+    inner_clip->test_properties()->AddChild(std::move(page_scale));
+    root->test_properties()->AddChild(std::move(inner_clip));
 
     layer_tree_impl->SetRootLayer(std::move(root));
     layer_tree_impl->SetViewportLayersFromIds(
         Layer::INVALID_ID, kPageScaleLayerId, kInnerViewportScrollLayerId,
         kOuterViewportScrollLayerId);
 
     layer_tree_impl->DidBecomeActive();
     return layer_tree_impl->InnerViewportScrollLayer();
   }
 
@@ skipping 241 matching lines @@
 
   std::unique_ptr<ScrollAndScaleSet> scroll_info =
       host_impl_->ProcessScrollDeltas();
   ASSERT_EQ(scroll_info->scrolls.size(), 0u);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollDeltaTreeButNoChanges) {
   {
     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));
-    root->test_properties()->children[1]->AddChild(
+    root->test_properties()->children[1]->test_properties()->AddChild(
         LayerImpl::Create(host_impl_->active_tree(), 5));
     root->test_properties()
         ->children[1]
         ->test_properties()
         ->children[0]
+        ->test_properties()
         ->AddChild(LayerImpl::Create(host_impl_->active_tree(), 6));
     host_impl_->active_tree()->SetRootLayer(std::move(root));
   }
   LayerImpl* root = host_impl_->active_tree()->root_layer();
 
   ExpectClearedScrollDeltasRecursive(root);
 
   std::unique_ptr<ScrollAndScaleSet> scroll_info;
 
   scroll_info = host_impl_->ProcessScrollDeltas();
   ASSERT_EQ(scroll_info->scrolls.size(), 0u);
   ExpectClearedScrollDeltasRecursive(root);
 
   scroll_info = host_impl_->ProcessScrollDeltas();
   ASSERT_EQ(scroll_info->scrolls.size(), 0u);
   ExpectClearedScrollDeltasRecursive(root);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollDeltaRepeatedScrolls) {
   gfx::ScrollOffset scroll_offset(20, 30);
   gfx::Vector2d scroll_delta(11, -15);
   {
     std::unique_ptr<LayerImpl> root_clip =
         LayerImpl::Create(host_impl_->active_tree(), 2);
     std::unique_ptr<LayerImpl> root =
         LayerImpl::Create(host_impl_->active_tree(), 1);
     root_clip->SetBounds(gfx::Size(10, 10));
     LayerImpl* root_layer = root.get();
-    root_clip->AddChild(std::move(root));
+    root_clip->test_properties()->AddChild(std::move(root));
     root_layer->SetBounds(gfx::Size(110, 110));
     root_layer->SetScrollClipLayer(root_clip->id());
     root_layer->layer_tree_impl()
         ->property_trees()
         ->scroll_tree.UpdateScrollOffsetBaseForTesting(root_layer->id(),
                                                        scroll_offset);
     host_impl_->active_tree()->SetRootLayer(std::move(root_clip));
     host_impl_->active_tree()->BuildLayerListAndPropertyTreesForTesting();
     root_layer->ScrollBy(scroll_delta);
   }
@@ skipping 145 matching lines @@
   LayerImpl* root = host_impl_->active_tree()->root_layer();
 
   LayerImpl* child = 0;
   {
     std::unique_ptr<LayerImpl> child_layer =
         LayerImpl::Create(host_impl_->active_tree(), 6);
     child = child_layer.get();
     child_layer->SetDrawsContent(true);
     child_layer->SetPosition(gfx::PointF(0, 20));
     child_layer->SetBounds(gfx::Size(50, 50));
-    scroll->AddChild(std::move(child_layer));
+    scroll->test_properties()->AddChild(std::move(child_layer));
     SetNeedsRebuildPropertyTrees();
     RebuildPropertyTrees();
   }
 
   // Touch handler regions determine whether touch events block scroll.
   root->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 100, 100));
   EXPECT_TRUE(host_impl_->DoTouchEventsBlockScrollAt(gfx::Point(10, 10)));
 
   // But they don't influence the actual handling of the scroll gestures.
   InputHandler::ScrollStatus status = host_impl_->ScrollBegin(
@@ skipping 140 matching lines @@
   std::unique_ptr<LayerImpl> squash1 = LayerImpl::Create(layer_tree_impl, 5);
   squash1->SetBounds(gfx::Size(140, 300));
   squash1->SetPosition(gfx::PointF(220, 0));
   squash1->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> squash2 = LayerImpl::Create(layer_tree_impl, 6);
   squash2->SetBounds(gfx::Size(140, 300));
   squash2->SetPosition(gfx::PointF(220, 300));
   squash2->SetDrawsContent(true);
 
-  scroll->AddChild(std::move(squash2));
-  clip->AddChild(std::move(scroll));
-  clip->AddChild(std::move(scrollbar));
-  clip->AddChild(std::move(squash1));
-  root->AddChild(std::move(clip));
+  scroll->test_properties()->AddChild(std::move(squash2));
+  clip->test_properties()->AddChild(std::move(scroll));
+  clip->test_properties()->AddChild(std::move(scrollbar));
+  clip->test_properties()->AddChild(std::move(squash1));
+  root->test_properties()->AddChild(std::move(clip));
 
   layer_tree_impl->SetRootLayer(std::move(root));
   SetNeedsRebuildPropertyTrees();
   RebuildPropertyTrees();
   layer_tree_impl->DidBecomeActive();
 
   // The point hits squash1 layer and also scroll layer, because scroll layer is
   // not an ancestor of squash1 layer, we cannot scroll on impl thread.
   InputHandler::ScrollStatus status = host_impl_->ScrollBegin(
       BeginState(gfx::Point(230, 150)).get(), InputHandler::WHEEL);
@@ skipping 309 matching lines @@
 
   host_impl_->SetViewportSize(gfx::Size(50, 50));
 
   host_impl_->CreatePendingTree();
   host_impl_->pending_tree()->SetRootLayer(
       LayerImpl::Create(host_impl_->pending_tree(), 1));
   LayerImpl* root = host_impl_->pending_tree()->root_layer();
   root->SetBounds(gfx::Size(50, 50));
   root->test_properties()->force_render_surface = true;
 
-  root->AddChild(LayerImpl::Create(host_impl_->pending_tree(), 2));
+  root->test_properties()->AddChild(
+      LayerImpl::Create(host_impl_->pending_tree(), 2));
   host_impl_->pending_tree()->BuildLayerListForTesting();
   LayerImpl* child = root->test_properties()->children[0];
   child->SetBounds(gfx::Size(10, 10));
   child->draw_properties().visible_layer_rect = gfx::Rect(10, 10);
   child->SetDrawsContent(true);
   AddAnimatedTransformToLayerWithPlayer(child->id(), timeline(), 10.0, 3, 0);
 
   EXPECT_FALSE(did_request_next_frame_);
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
@@ skipping 30 matching lines @@
   EXPECT_FALSE(host_impl_->CommitToActiveTree());
 
   host_impl_->SetViewportSize(gfx::Size(50, 50));
 
   host_impl_->active_tree()->SetRootLayer(
       LayerImpl::Create(host_impl_->active_tree(), 1));
   LayerImpl* root = host_impl_->active_tree()->root_layer();
   root->SetBounds(gfx::Size(50, 50));
   root->test_properties()->force_render_surface = true;
 
-  root->AddChild(LayerImpl::Create(host_impl_->active_tree(), 2));
+  root->test_properties()->AddChild(
+      LayerImpl::Create(host_impl_->active_tree(), 2));
   LayerImpl* child = root->test_properties()->children[0];
   child->SetBounds(gfx::Size(10, 10));
   child->draw_properties().visible_layer_rect = gfx::Rect(10, 10);
   child->SetDrawsContent(true);
 
   // Add a translate from 6,7 to 8,9.
   TransformOperations start;
   start.AppendTranslate(6.f, 7.f, 0.f);
   TransformOperations end;
   end.AppendTranslate(8.f, 9.f, 0.f);
@@ skipping 43 matching lines @@
   EXPECT_TRUE(host_impl_->CommitToActiveTree());
 
   host_impl_->SetViewportSize(gfx::Size(50, 50));
 
   host_impl_->active_tree()->SetRootLayer(
       LayerImpl::Create(host_impl_->active_tree(), 1));
   LayerImpl* root = host_impl_->active_tree()->root_layer();
   root->SetBounds(gfx::Size(50, 50));
   root->SetHasRenderSurface(true);
 
-  root->AddChild(LayerImpl::Create(host_impl_->active_tree(), 2));
+  root->test_properties()->AddChild(
+      LayerImpl::Create(host_impl_->active_tree(), 2));
   LayerImpl* child = root->test_properties()->children[0];
   child->SetBounds(gfx::Size(10, 10));
   child->draw_properties().visible_layer_rect = gfx::Rect(10, 10);
   child->SetDrawsContent(true);
   AddAnimatedTransformToLayerWithPlayer(child->id(), timeline(), 10.0, 3, 0);
 
   // Set up the property trees so that UpdateDrawProperties will work in
   // CommitComplete below.
   LayerImplList list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
@@ skipping 17 matching lines @@
 }
 
 TEST_F(LayerTreeHostImplTest, AnimationSchedulingOnLayerDestruction) {
   host_impl_->SetViewportSize(gfx::Size(50, 50));
 
   host_impl_->active_tree()->SetRootLayer(
       LayerImpl::Create(host_impl_->active_tree(), 1));
   LayerImpl* root = host_impl_->active_tree()->root_layer();
   root->SetBounds(gfx::Size(50, 50));
 
-  root->AddChild(LayerImpl::Create(host_impl_->active_tree(), 2));
+  root->test_properties()->AddChild(
+      LayerImpl::Create(host_impl_->active_tree(), 2));
   LayerImpl* child = root->test_properties()->children[0];
   child->SetBounds(gfx::Size(10, 10));
   child->draw_properties().visible_layer_rect = gfx::Rect(10, 10);
   child->SetDrawsContent(true);
 
   // Add a translate animation.
   TransformOperations start;
   start.AppendTranslate(6.f, 7.f, 0.f);
   TransformOperations end;
   end.AppendTranslate(8.f, 9.f, 0.f);
@@ skipping 14 matching lines @@
 
   // The next frame after activating, we'll tick the animation again.
   host_impl_->Animate();
   // An animation exists on the active layer. Doing Animate() requests another
   // frame after the current one.
   EXPECT_TRUE(did_request_next_frame_);
   did_request_next_frame_ = false;
 
   // Destroy layer, unregister animation target (element).
   child->test_properties()->parent = nullptr;
-  root->RemoveChildForTesting(child);
+  root->test_properties()->RemoveChild(child);
   child = nullptr;
 
   // Doing Animate() doesn't request another frame after the current one.
   host_impl_->Animate();
   EXPECT_FALSE(did_request_next_frame_);
 
   host_impl_->Animate();
   EXPECT_FALSE(did_request_next_frame_);
 }
 
@@ skipping 17 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, AnimationMarksLayerNotReady) {
   host_impl_->SetViewportSize(gfx::Size(50, 50));
 
   host_impl_->active_tree()->SetRootLayer(
       LayerImpl::Create(host_impl_->active_tree(), 1));
   LayerImpl* root = host_impl_->active_tree()->root_layer();
   root->SetBounds(gfx::Size(50, 50));
   root->SetHasRenderSurface(true);
 
-  root->AddChild(std::unique_ptr<MissingTilesLayer>(
+  root->test_properties()->AddChild(std::unique_ptr<MissingTilesLayer>(
       new MissingTilesLayer(host_impl_->active_tree(), 2)));
   MissingTilesLayer* child =
       static_cast<MissingTilesLayer*>(root->test_properties()->children[0]);
   child->SetBounds(gfx::Size(10, 10));
   child->draw_properties().visible_layer_rect = gfx::Rect(10, 10);
   child->SetDrawsContent(true);
 
   EXPECT_TRUE(child->was_ever_ready_since_last_transform_animation());
 
   // Add a translate from 6,7 to 8,9.
@@ skipping 498 matching lines @@
   // to the other. Scrolls shouldn't bubbling from the child.
   LayerImpl *parent;
   LayerImpl *child;
   LayerImpl *child_clip;
 
   std::unique_ptr<LayerImpl> scroll_parent_clip =
       LayerImpl::Create(host_impl_->active_tree(), 6);
   std::unique_ptr<LayerImpl> scroll_parent =
       CreateScrollableLayer(7, gfx::Size(10, 10), scroll_parent_clip.get());
   parent = scroll_parent.get();
-  scroll_parent_clip->AddChild(std::move(scroll_parent));
+  scroll_parent_clip->test_properties()->AddChild(std::move(scroll_parent));
 
-  viewport_scroll->AddChild(std::move(scroll_parent_clip));
+  viewport_scroll->test_properties()->AddChild(std::move(scroll_parent_clip));
 
   std::unique_ptr<LayerImpl> scroll_child_clip =
       LayerImpl::Create(host_impl_->active_tree(), 8);
   std::unique_ptr<LayerImpl> scroll_child =
       CreateScrollableLayer(9, gfx::Size(10, 10), scroll_child_clip.get());
   child = scroll_child.get();
   scroll_child->SetPosition(gfx::PointF(20.f, 20.f));
-  scroll_child_clip->AddChild(std::move(scroll_child));
+  scroll_child_clip->test_properties()->AddChild(std::move(scroll_child));
 
   child_clip = scroll_child_clip.get();
-  viewport_scroll->AddChild(std::move(scroll_child_clip));
+  viewport_scroll->test_properties()->AddChild(std::move(scroll_child_clip));
 
   child_clip->test_properties()->scroll_parent = parent;
   std::unique_ptr<std::set<LayerImpl*>> scroll_children(
       new std::set<LayerImpl*>);
   scroll_children->insert(child_clip);
   parent->test_properties()->scroll_children.reset(scroll_children.release());
 
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
@@ skipping 652 matching lines @@
 
     std::unique_ptr<SolidColorScrollbarLayerImpl> scrollbar =
         SolidColorScrollbarLayerImpl::Create(host_impl_->active_tree(), 400,
                                              VERTICAL, 10, 0, false, true);
     scrollbar->test_properties()->opacity = 0.f;
     EXPECT_FLOAT_EQ(0.f, scrollbar->test_properties()->opacity);
 
     LayerImpl* scroll = host_impl_->active_tree()->OuterViewportScrollLayer();
     LayerImpl* root = host_impl_->active_tree()->InnerViewportContainerLayer();
     scrollbar->SetScrollLayerId(scroll->id());
-    root->AddChild(std::move(scrollbar));
+    root->test_properties()->AddChild(std::move(scrollbar));
 
     host_impl_->active_tree()->DidBecomeActive();
     SetNeedsRebuildPropertyTrees();
     DrawFrame();
   }
 
   void RunTest(LayerTreeSettings::ScrollbarAnimator animator) {
     LayerTreeSettings settings = DefaultSettings();
     settings.scrollbar_animator = animator;
     settings.scrollbar_fade_delay_ms = 20;
@@ skipping 163 matching lines @@
     host_impl_->CreatePendingTree();
     CreateScrollAndContentsLayers(host_impl_->pending_tree(), content_size);
     std::unique_ptr<SolidColorScrollbarLayerImpl> scrollbar =
         SolidColorScrollbarLayerImpl::Create(host_impl_->pending_tree(), 400,
                                              VERTICAL, 10, 0, false, true);
     scrollbar->test_properties()->opacity = 0.f;
     LayerImpl* scroll = host_impl_->pending_tree()->OuterViewportScrollLayer();
     LayerImpl* container =
         host_impl_->pending_tree()->InnerViewportContainerLayer();
     scrollbar->SetScrollLayerId(scroll->id());
-    container->AddChild(std::move(scrollbar));
+    container->test_properties()->AddChild(std::move(scrollbar));
     host_impl_->pending_tree()->PushPageScaleFromMainThread(1.f, 1.f, 1.f);
     host_impl_->pending_tree()->BuildLayerListAndPropertyTreesForTesting();
     host_impl_->ActivateSyncTree();
 
     LayerImpl* active_scrollbar_layer =
         host_impl_->active_tree()->LayerById(400);
 
     EffectNode* active_tree_node =
         host_impl_->active_tree()->property_trees()->effect_tree.Node(
             active_scrollbar_layer->effect_tree_index());
@@ skipping 142 matching lines @@
       gfx::ScrollOffset(10, 10));
   EXPECT_FALSE(animation_task_.Equals(base::Closure()));
   animation_task_ = base::Closure();
   host_impl_->active_tree()->InnerViewportScrollLayer()->SetCurrentScrollOffset(
       gfx::ScrollOffset(10, 10));
   EXPECT_FALSE(animation_task_.Equals(base::Closure()));
   animation_task_ = base::Closure();
 
   // Check scrollbar registration on a sublayer.
   child->SetScrollClipLayer(child_clip->id());
-  child_clip->AddChild(std::move(child));
-  root_scroll->AddChild(std::move(child_clip));
+  child_clip->test_properties()->AddChild(std::move(child));
+  root_scroll->test_properties()->AddChild(std::move(child_clip));
   EXPECT_EQ(0ul, host_impl_->ScrollbarsFor(child_scroll_id).size());
   EXPECT_EQ(nullptr,
             host_impl_->ScrollbarAnimationControllerForId(child_scroll_id));
   vert_2_scrollbar->SetScrollLayerId(child_scroll_id);
   EXPECT_EQ(1ul, host_impl_->ScrollbarsFor(child_scroll_id).size());
   EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForId(child_scroll_id));
   horiz_2_scrollbar->SetScrollLayerId(child_scroll_id);
   EXPECT_EQ(2ul, host_impl_->ScrollbarsFor(child_scroll_id).size());
   EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForId(child_scroll_id));
 
@@ skipping 56 matching lines @@
   LayerImpl* root_scroll =
       host_impl_->active_tree()->OuterViewportScrollLayer();
   // The scrollbar is on the left side.
   std::unique_ptr<SolidColorScrollbarLayerImpl> scrollbar =
       SolidColorScrollbarLayerImpl::Create(host_impl_->active_tree(), 6,
                                            VERTICAL, 5, 5, true, true);
   scrollbar->SetScrollLayerId(root_scroll->id());
   scrollbar->SetDrawsContent(true);
   scrollbar->SetBounds(scrollbar_size);
   scrollbar->SetTouchEventHandlerRegion(gfx::Rect(scrollbar_size));
-  host_impl_->active_tree()->InnerViewportContainerLayer()->AddChild(
-      std::move(scrollbar));
+  host_impl_->active_tree()
+      ->InnerViewportContainerLayer()
+      ->test_properties()
+      ->AddChild(std::move(scrollbar));
   host_impl_->active_tree()->DidBecomeActive();
 
   DrawFrame();
   host_impl_->active_tree()->UpdateDrawProperties(false);
 
   ScrollbarAnimationControllerThinning* scrollbar_animation_controller =
       static_cast<ScrollbarAnimationControllerThinning*>(
           host_impl_->ScrollbarAnimationControllerForId(root_scroll->id()));
   scrollbar_animation_controller->set_mouse_move_distance_for_test(100.f);
 
@@ skipping 215 matching lines @@
 };
 
 TEST_F(LayerTreeHostImplTest, WillDrawReturningFalseDoesNotCall) {
   // The root layer is always drawn, so run this test on a child layer that
   // will be masked out by the root layer's bounds.
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
   DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(
       host_impl_->active_tree()->root_layer());
 
-  root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
+  root->test_properties()->AddChild(
+      DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
   root->test_properties()->force_render_surface = true;
   DidDrawCheckLayer* layer =
       static_cast<DidDrawCheckLayer*>(root->test_properties()->children[0]);
 
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
     host_impl_->DrawLayers(&frame);
     host_impl_->DidDrawAllLayers(frame);
 
@@ skipping 22 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, DidDrawNotCalledOnHiddenLayer) {
   // The root layer is always drawn, so run this test on a child layer that
   // will be masked out by the root layer's bounds.
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
   DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(
       host_impl_->active_tree()->root_layer());
   root->SetMasksToBounds(true);
   root->test_properties()->force_render_surface = true;
-  root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
+  root->test_properties()->AddChild(
+      DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
   DidDrawCheckLayer* layer =
       static_cast<DidDrawCheckLayer*>(root->test_properties()->children[0]);
   // Ensure visible_layer_rect for layer is empty.
   layer->SetPosition(gfx::PointF(100.f, 100.f));
   layer->SetBounds(gfx::Size(10, 10));
 
   LayerTreeHostImpl::FrameData frame;
 
   EXPECT_FALSE(layer->will_draw_called());
   EXPECT_FALSE(layer->did_draw_called());
@@ skipping 28 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, WillDrawNotCalledOnOccludedLayer) {
   gfx::Size big_size(1000, 1000);
   host_impl_->SetViewportSize(big_size);
 
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
   DidDrawCheckLayer* root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
 
-  root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
+  root->test_properties()->AddChild(
+      DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
   DidDrawCheckLayer* occluded_layer =
       static_cast<DidDrawCheckLayer*>(root->test_properties()->children[0]);
 
-  root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 3));
+  root->test_properties()->AddChild(
+      DidDrawCheckLayer::Create(host_impl_->active_tree(), 3));
   root->test_properties()->force_render_surface = true;
   DidDrawCheckLayer* top_layer =
       static_cast<DidDrawCheckLayer*>(root->test_properties()->children[1]);
   // This layer covers the occluded_layer above. Make this layer large so it can
   // occlude.
   top_layer->SetBounds(big_size);
   top_layer->SetContentsOpaque(true);
 
   LayerTreeHostImpl::FrameData frame;
 
@@ skipping 11 matching lines @@
   EXPECT_TRUE(top_layer->will_draw_called());
   EXPECT_TRUE(top_layer->did_draw_called());
 }
 
 TEST_F(LayerTreeHostImplTest, DidDrawCalledOnAllLayers) {
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
   DidDrawCheckLayer* root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
 
-  root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
+  root->test_properties()->AddChild(
+      DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
   root->test_properties()->force_render_surface = true;
   DidDrawCheckLayer* layer1 =
       static_cast<DidDrawCheckLayer*>(root->test_properties()->children[0]);
 
-  layer1->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 3));
+  layer1->test_properties()->AddChild(
+      DidDrawCheckLayer::Create(host_impl_->active_tree(), 3));
   DidDrawCheckLayer* layer2 =
       static_cast<DidDrawCheckLayer*>(layer1->test_properties()->children[0]);
 
   layer1->test_properties()->force_render_surface = true;
   layer1->test_properties()->should_flatten_transform = true;
 
   EXPECT_FALSE(root->did_draw_called());
   EXPECT_FALSE(layer1->did_draw_called());
   EXPECT_FALSE(layer2->did_draw_called());
 
@@ skipping 156 matching lines @@
   host_impl_->DidDrawAllLayers(frame);
   host_impl_->SwapBuffers(frame);
 
   for (size_t i = 0; i < cases.size(); ++i) {
     // Clean up host_impl_ state.
     const auto& testcase = cases[i];
     std::vector<LayerImpl*> to_remove;
     for (const auto& child : root->test_properties()->children)
       to_remove.push_back(child);
     for (auto* child : to_remove)
-      root->RemoveChildForTesting(child);
+      root->test_properties()->RemoveChild(child);
     timeline()->ClearPlayers();
 
     std::ostringstream scope;
     scope << "Test case: " << i;
     SCOPED_TRACE(scope.str());
 
-    root->AddChild(MissingTextureAnimatingLayer::Create(
+    root->test_properties()->AddChild(MissingTextureAnimatingLayer::Create(
         host_impl_->active_tree(), 2, testcase.layer_before.has_missing_tile,
         testcase.layer_before.has_incomplete_tile,
         testcase.layer_before.is_animating, host_impl_->resource_provider(),
         timeline()));
     DidDrawCheckLayer* before = static_cast<DidDrawCheckLayer*>(
         root->test_properties()->children.back());
     if (testcase.layer_before.has_copy_request)
       before->AddCopyRequest();
 
-    root->AddChild(MissingTextureAnimatingLayer::Create(
+    root->test_properties()->AddChild(MissingTextureAnimatingLayer::Create(
         host_impl_->active_tree(), 3, testcase.layer_between.has_missing_tile,
         testcase.layer_between.has_incomplete_tile,
         testcase.layer_between.is_animating, host_impl_->resource_provider(),
         timeline()));
     DidDrawCheckLayer* between = static_cast<DidDrawCheckLayer*>(
         root->test_properties()->children.back());
     if (testcase.layer_between.has_copy_request)
       between->AddCopyRequest();
 
-    root->AddChild(MissingTextureAnimatingLayer::Create(
+    root->test_properties()->AddChild(MissingTextureAnimatingLayer::Create(
         host_impl_->active_tree(), 4, testcase.layer_after.has_missing_tile,
         testcase.layer_after.has_incomplete_tile,
         testcase.layer_after.is_animating, host_impl_->resource_provider(),
         timeline()));
     DidDrawCheckLayer* after = static_cast<DidDrawCheckLayer*>(
         root->test_properties()->children.back());
     if (testcase.layer_after.has_copy_request)
       after->AddCopyRequest();
 
     if (testcase.high_res_required)
@@ skipping 47 matching lines @@
   SetNeedsRebuildPropertyTrees();
   host_impl_->OnDraw(external_transform, external_viewport, external_clip,
                      resourceless_software_draw);
 
   for (size_t i = 0; i < cases.size(); ++i) {
     const auto& testcase = cases[i];
     std::vector<LayerImpl*> to_remove;
     for (const auto& child : root->test_properties()->children)
       to_remove.push_back(child);
     for (auto* child : to_remove)
-      root->RemoveChildForTesting(child);
+      root->test_properties()->RemoveChild(child);
 
     std::ostringstream scope;
     scope << "Test case: " << i;
     SCOPED_TRACE(scope.str());
 
-    root->AddChild(MissingTextureAnimatingLayer::Create(
+    root->test_properties()->AddChild(MissingTextureAnimatingLayer::Create(
         host_impl_->active_tree(), 2, testcase.layer_before.has_missing_tile,
         testcase.layer_before.has_incomplete_tile,
         testcase.layer_before.is_animating, host_impl_->resource_provider(),
         timeline()));
     DidDrawCheckLayer* before = static_cast<DidDrawCheckLayer*>(
         root->test_properties()->children.back());
     if (testcase.layer_before.has_copy_request)
       before->AddCopyRequest();
 
-    root->AddChild(MissingTextureAnimatingLayer::Create(
+    root->test_properties()->AddChild(MissingTextureAnimatingLayer::Create(
         host_impl_->active_tree(), 3, testcase.layer_between.has_missing_tile,
         testcase.layer_between.has_incomplete_tile,
         testcase.layer_between.is_animating, host_impl_->resource_provider(),
         timeline()));
     DidDrawCheckLayer* between = static_cast<DidDrawCheckLayer*>(
         root->test_properties()->children.back());
     if (testcase.layer_between.has_copy_request)
       between->AddCopyRequest();
 
-    root->AddChild(MissingTextureAnimatingLayer::Create(
+    root->test_properties()->AddChild(MissingTextureAnimatingLayer::Create(
         host_impl_->active_tree(), 4, testcase.layer_after.has_missing_tile,
         testcase.layer_after.has_incomplete_tile,
         testcase.layer_after.is_animating, host_impl_->resource_provider(),
         timeline()));
     DidDrawCheckLayer* after = static_cast<DidDrawCheckLayer*>(
         root->test_properties()->children.back());
     if (testcase.layer_after.has_copy_request)
       after->AddCopyRequest();
 
     if (testcase.high_res_required)
@@ skipping 113 matching lines @@
     outer_scroll->SetBounds(scroll_layer_size);
     outer_scroll->SetPosition(gfx::PointF());
     outer_scroll->SetDrawsContent(false);
     outer_scroll->test_properties()->is_container_for_fixed_position_layers =
         true;
 
     int inner_viewport_scroll_layer_id = root->id();
     int outer_viewport_scroll_layer_id = outer_scroll->id();
     int page_scale_layer_id = page_scale->id();
 
-    outer_clip->AddChild(std::move(outer_scroll));
-    root->AddChild(std::move(outer_clip));
-    page_scale->AddChild(std::move(root));
-    root_clip->AddChild(std::move(page_scale));
+    outer_clip->test_properties()->AddChild(std::move(outer_scroll));
+    root->test_properties()->AddChild(std::move(outer_clip));
+    page_scale->test_properties()->AddChild(std::move(root));
+    root_clip->test_properties()->AddChild(std::move(page_scale));
 
     tree_impl->SetRootLayer(std::move(root_clip));
     tree_impl->SetViewportLayersFromIds(Layer::INVALID_ID, page_scale_layer_id,
                                         inner_viewport_scroll_layer_id,
                                         outer_viewport_scroll_layer_id);
     tree_impl->BuildLayerListAndPropertyTreesForTesting();
 
     host_impl_->SetViewportSize(inner_viewport_size);
     LayerImpl* root_clip_ptr = tree_impl->root_layer();
     EXPECT_EQ(inner_viewport_size, root_clip_ptr->bounds());
@@ skipping 15 matching lines @@
 // place.
 TEST_F(LayerTreeHostImplTopControlsTest,
     HidingTopControlsExpandsScrollableSize) {
   SetupTopControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(50, 50), gfx::Size(50, 50), gfx::Size(50, 50));
 
   LayerTreeImpl* active_tree = host_impl_->active_tree();
 
   // Create a content layer beneath the outer viewport scroll layer.
   int id = host_impl_->OuterViewportScrollLayer()->id();
-  host_impl_->OuterViewportScrollLayer()->AddChild(
+  host_impl_->OuterViewportScrollLayer()->test_properties()->AddChild(
       LayerImpl::Create(host_impl_->active_tree(), id + 2));
   LayerImpl* content =
       active_tree->OuterViewportScrollLayer()->test_properties()->children[0];
   content->SetBounds(gfx::Size(50, 50));
 
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   LayerImpl* inner_container = active_tree->InnerViewportContainerLayer();
   LayerImpl* outer_container = active_tree->OuterViewportContainerLayer();
@@ skipping 257 matching lines @@
 
   child_clip->SetBounds(sub_content_layer_size);
   child->SetScrollClipLayer(child_clip->id());
   child->SetBounds(sub_content_size);
   child->SetPosition(gfx::PointF());
   child->SetDrawsContent(true);
   child->test_properties()->is_container_for_fixed_position_layers = true;
 
   // scroll child to limit
   SetScrollOffsetDelta(child.get(), gfx::Vector2dF(0, 100.f));
-  child_clip->AddChild(std::move(child));
-  outer_viewport_scroll_layer->AddChild(std::move(child_clip));
+  child_clip->test_properties()->AddChild(std::move(child));
+  outer_viewport_scroll_layer->test_properties()->AddChild(
+      std::move(child_clip));
 
   // Scroll 25px to hide top controls
   gfx::Vector2dF scroll_delta(0.f, 25.f);
   host_impl_->active_tree()->property_trees()->needs_rebuild = true;
   host_impl_->active_tree()->BuildLayerListAndPropertyTreesForTesting();
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->ScrollBegin(BeginState(gfx::Point()).get(),
                               InputHandler::TOUCHSCREEN)
                 .thread);
@@ skipping 470 matching lines @@
 
   std::unique_ptr<LayerImpl> scroll_clip_layer =
       LayerImpl::Create(host_impl_->active_tree(), 3);
   scroll_clip_layer->SetBounds(surface_size);
 
   std::unique_ptr<LayerImpl> scroll_layer =
       LayerImpl::Create(host_impl_->active_tree(), 2);
   scroll_layer->SetScrollClipLayer(3);
   scroll_layer->SetBounds(contents_size);
   scroll_layer->SetPosition(gfx::PointF());
-  scroll_layer->AddChild(std::move(content_layer));
-  scroll_clip_layer->AddChild(std::move(scroll_layer));
+  scroll_layer->test_properties()->AddChild(std::move(content_layer));
+  scroll_clip_layer->test_properties()->AddChild(std::move(scroll_layer));
 
   scroll_clip_layer->test_properties()->force_render_surface = true;
   host_impl_->active_tree()->SetRootLayer(std::move(scroll_clip_layer));
   host_impl_->SetViewportSize(surface_size);
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point(5, 5)).get(),
                                     InputHandler::WHEEL)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), gfx::Vector2d(0, 10)).get());
   host_impl_->ScrollEnd(EndState().get());
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollChildCallsCommitAndRedraw) {
   gfx::Size surface_size(10, 10);
   gfx::Size contents_size(20, 20);
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(surface_size);
-  root->AddChild(CreateScrollableLayer(2, contents_size, root.get()));
+  root->test_properties()->AddChild(
+      CreateScrollableLayer(2, contents_size, root.get()));
   root->test_properties()->force_render_surface = true;
   host_impl_->active_tree()->SetRootLayer(std::move(root));
   host_impl_->SetViewportSize(surface_size);
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point(5, 5)).get(),
                                     InputHandler::WHEEL)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), gfx::Vector2d(0, 10)).get());
   host_impl_->ScrollEnd(EndState().get());
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollMissesChild) {
   gfx::Size surface_size(10, 10);
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl_->active_tree(), 1);
-  root->AddChild(CreateScrollableLayer(2, surface_size, root.get()));
+  root->test_properties()->AddChild(
+      CreateScrollableLayer(2, surface_size, root.get()));
   root->test_properties()->force_render_surface = true;
   host_impl_->active_tree()->SetRootLayer(std::move(root));
   host_impl_->SetViewportSize(surface_size);
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   // Scroll event is ignored because the input coordinate is outside the layer
   // boundaries.
   InputHandler::ScrollStatus status = host_impl_->ScrollBegin(
       BeginState(gfx::Point(15, 5)).get(), InputHandler::WHEEL);
@@ skipping 12 matching lines @@
   root->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, surface_size, root.get());
   host_impl_->SetViewportSize(surface_size);
 
   gfx::Transform matrix;
   matrix.RotateAboutXAxis(180.0);
   child->SetTransform(matrix);
   child->test_properties()->double_sided = false;
 
-  root->AddChild(std::move(child));
+  root->test_properties()->AddChild(std::move(child));
   host_impl_->active_tree()->SetRootLayer(std::move(root));
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   // Scroll event is ignored because the scrollable layer is not facing the
   // viewer and there is nothing scrollable behind it.
   InputHandler::ScrollStatus status = host_impl_->ScrollBegin(
       BeginState(gfx::Point(5, 5)).get(), InputHandler::WHEEL);
   EXPECT_EQ(InputHandler::SCROLL_IGNORED, status.thread);
   EXPECT_EQ(MainThreadScrollingReason::kNoScrollingLayer,
@@ skipping 10 matching lines @@
   std::unique_ptr<LayerImpl> content_layer =
       CreateScrollableLayer(1, surface_size, clip_layer.get());
   content_layer->set_main_thread_scrolling_reasons(
       MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
   content_layer->SetScrollClipLayer(Layer::INVALID_ID);
 
   // Note: we can use the same clip layer for both since both calls to
   // CreateScrollableLayer() use the same surface size.
   std::unique_ptr<LayerImpl> scroll_layer =
       CreateScrollableLayer(2, surface_size, clip_layer.get());
-  scroll_layer->AddChild(std::move(content_layer));
-  clip_layer->AddChild(std::move(scroll_layer));
+  scroll_layer->test_properties()->AddChild(std::move(content_layer));
+  clip_layer->test_properties()->AddChild(std::move(scroll_layer));
   clip_layer->test_properties()->force_render_surface = true;
 
   host_impl_->active_tree()->SetRootLayer(std::move(clip_layer));
   host_impl_->SetViewportSize(surface_size);
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   // Scrolling fails because the content layer is asking to be scrolled on the
   // main thread.
   InputHandler::ScrollStatus status = host_impl_->ScrollBegin(
@@ skipping 120 matching lines @@
   LayerImpl* scroll = SetupScrollAndContentsLayers(surface_size);
   scroll->SetDrawsContent(true);
   LayerImpl* root = host_impl_->active_tree()->root_layer();
   LayerImpl* child = scroll->test_properties()->children[0];
   child->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> scrollable_child_clip =
       LayerImpl::Create(host_impl_->active_tree(), 6);
   std::unique_ptr<LayerImpl> scrollable_child =
       CreateScrollableLayer(7, surface_size, scrollable_child_clip.get());
-  scrollable_child_clip->AddChild(std::move(scrollable_child));
-  child->AddChild(std::move(scrollable_child_clip));
+  scrollable_child_clip->test_properties()->AddChild(
+      std::move(scrollable_child));
+  child->test_properties()->AddChild(std::move(scrollable_child_clip));
   LayerImpl* grand_child = child->test_properties()->children[0];
   grand_child->SetDrawsContent(true);
 
   // Set new page scale on impl thread by pinching.
   SetNeedsRebuildPropertyTrees();
   RebuildPropertyTrees();
   host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                           InputHandler::TOUCHSCREEN);
   host_impl_->PinchGestureBegin();
   host_impl_->PinchGestureUpdate(new_page_scale, gfx::Point());
@@ skipping 68 matching lines @@
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(surface_size);
   root->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(3, content_size, root.get());
 
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root.get());
   LayerImpl* grand_child_layer = grand_child.get();
-  child->AddChild(std::move(grand_child));
+  child->test_properties()->AddChild(std::move(grand_child));
 
   LayerImpl* child_layer = child.get();
-  root->AddChild(std::move(child));
+  root->test_properties()->AddChild(std::move(child));
   host_impl_->active_tree()->SetRootLayer(std::move(root));
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
   grand_child_layer->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(grand_child_layer->id(),
                                                      gfx::ScrollOffset(0, 5));
   child_layer->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(child_layer->id(),
@@ skipping 39 matching lines @@
       CreateScrollableLayer(3, surface_size, root_clip.get());
   root_scrolling->test_properties()->is_container_for_fixed_position_layers =
       true;
 
   std::unique_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(5, surface_size, root_clip.get());
 
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(4, surface_size, root_clip.get());
   LayerImpl* grand_child_layer = grand_child.get();
-  child->AddChild(std::move(grand_child));
+  child->test_properties()->AddChild(std::move(grand_child));
 
   LayerImpl* child_layer = child.get();
-  root_scrolling->AddChild(std::move(child));
-  root_clip->AddChild(std::move(root_scrolling));
+  root_scrolling->test_properties()->AddChild(std::move(child));
+  root_clip->test_properties()->AddChild(std::move(root_scrolling));
   EXPECT_EQ(viewport_size, root_clip->bounds());
-  root_ptr->AddChild(std::move(root_clip));
+  root_ptr->test_properties()->AddChild(std::move(root_clip));
   host_impl_->active_tree()->SetRootLayer(std::move(root_ptr));
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 1, 3,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(viewport_size);
 
   grand_child_layer->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(grand_child_layer->id(),
                                                      gfx::ScrollOffset(0, 2));
@@ skipping 108 matching lines @@
   std::unique_ptr<LayerImpl> root_scroll =
       CreateScrollableLayer(1, content_size, root_clip.get());
   // Make 'root' the clip layer for child: since they have the same sizes the
   // child will have zero max_scroll_offset and scrolls will bubble.
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root_scroll.get());
   child->test_properties()->is_container_for_fixed_position_layers = true;
   root_scroll->SetBounds(content_size);
 
   int root_scroll_id = root_scroll->id();
-  root_scroll->AddChild(std::move(child));
-  root_clip->AddChild(std::move(root_scroll));
-  root_ptr->AddChild(std::move(root_clip));
+  root_scroll->test_properties()->AddChild(std::move(child));
+  root_clip->test_properties()->AddChild(std::move(root_scroll));
+  root_ptr->test_properties()->AddChild(std::move(root_clip));
 
   host_impl_->SetViewportSize(surface_size);
   host_impl_->active_tree()->SetRootLayer(std::move(root_ptr));
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 4, 2,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(0, 4);
@@ skipping 17 matching lines @@
 TEST_F(LayerTreeHostImplTest, ScrollBeforeRedraw) {
   gfx::Size surface_size(10, 10);
   std::unique_ptr<LayerImpl> root_ptr =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   std::unique_ptr<LayerImpl> root_clip =
       LayerImpl::Create(host_impl_->active_tree(), 2);
   std::unique_ptr<LayerImpl> root_scroll =
       CreateScrollableLayer(3, surface_size, root_clip.get());
   root_clip->test_properties()->force_render_surface = true;
   root_scroll->test_properties()->is_container_for_fixed_position_layers = true;
-  root_clip->AddChild(std::move(root_scroll));
-  root_ptr->AddChild(std::move(root_clip));
+  root_clip->test_properties()->AddChild(std::move(root_scroll));
+  root_ptr->test_properties()->AddChild(std::move(root_clip));
   host_impl_->active_tree()->SetRootLayer(std::move(root_ptr));
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 1, 3,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
 
   // Draw one frame and then immediately rebuild the layer tree to mimic a tree
   // synchronization.
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
   host_impl_->active_tree()->DetachLayers();
   std::unique_ptr<LayerImpl> root_ptr2 =
       LayerImpl::Create(host_impl_->active_tree(), 4);
   std::unique_ptr<LayerImpl> root_clip2 =
       LayerImpl::Create(host_impl_->active_tree(), 5);
   std::unique_ptr<LayerImpl> root_scroll2 =
       CreateScrollableLayer(6, surface_size, root_clip2.get());
   root_scroll2->test_properties()->is_container_for_fixed_position_layers =
       true;
-  root_clip2->AddChild(std::move(root_scroll2));
+  root_clip2->test_properties()->AddChild(std::move(root_scroll2));
   root_clip2->test_properties()->force_render_surface = true;
-  root_ptr2->AddChild(std::move(root_clip2));
+  root_ptr2->test_properties()->AddChild(std::move(root_clip2));
   host_impl_->active_tree()->SetRootLayer(std::move(root_ptr2));
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 4, 6,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
 
   // Scrolling should still work even though we did not draw yet.
   SetNeedsRebuildPropertyTrees();
   RebuildPropertyTrees();
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point(5, 5)).get(),
@@ skipping 66 matching lines @@
 
   // Only allow vertical scrolling.
   clip_layer->SetBounds(
       gfx::Size(child->bounds().width(), child->bounds().height() / 2));
   // The rotation depends on the layer's transform origin, and the child layer
   // is a different size than the clip, so make sure the clip layer's origin
   // lines up over the child.
   clip_layer->test_properties()->transform_origin = gfx::Point3F(
       clip_layer->bounds().width() * 0.5f, clip_layer->bounds().height(), 0.f);
   LayerImpl* child_ptr = child.get();
-  clip_layer->AddChild(std::move(child));
-  scroll_layer->AddChild(std::move(clip_layer));
+  clip_layer->test_properties()->AddChild(std::move(child));
+  scroll_layer->test_properties()->AddChild(std::move(clip_layer));
 
   gfx::Size surface_size(50, 50);
   host_impl_->SetViewportSize(surface_size);
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
   {
     // Scroll down in screen coordinates with a gesture.
     gfx::Vector2d gesture_scroll_delta(0, 10);
     EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
               host_impl_
@@ skipping 63 matching lines @@
   perspective_transform.Translate(50.0, 50.0);
   clip_layer->SetTransform(perspective_transform);
 
   clip_layer->SetBounds(gfx::Size(child_ptr->bounds().width() / 2,
                                   child_ptr->bounds().height() / 2));
   // The transform depends on the layer's transform origin, and the child layer
   // is a different size than the clip, so make sure the clip layer's origin
   // lines up over the child.
   clip_layer->test_properties()->transform_origin = gfx::Point3F(
       clip_layer->bounds().width(), clip_layer->bounds().height(), 0.f);
-  clip_layer->AddChild(std::move(child));
-  scroll_layer->AddChild(std::move(clip_layer));
+  clip_layer->test_properties()->AddChild(std::move(child));
+  scroll_layer->test_properties()->AddChild(std::move(clip_layer));
 
   gfx::Size surface_size(50, 50);
   host_impl_->SetViewportSize(surface_size);
 
   std::unique_ptr<ScrollAndScaleSet> scroll_info;
 
   gfx::Vector2d gesture_scroll_deltas[4];
   gesture_scroll_deltas[0] = gfx::Vector2d(4, 10);
   gesture_scroll_deltas[1] = gfx::Vector2d(4, 10);
   gesture_scroll_deltas[2] = gfx::Vector2d(10, 0);
@@ skipping 445 matching lines @@
 
   std::unique_ptr<LayerImpl> root =
       CreateScrollableLayer(1, surface_size, root_clip.get());
 
   std::unique_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(3, surface_size, root_clip.get());
 
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, surface_size, root_clip.get());
   LayerImpl* grand_child_layer = grand_child.get();
-  child->AddChild(std::move(grand_child));
+  child->test_properties()->AddChild(std::move(grand_child));
 
   LayerImpl* child_layer = child.get();
-  root->AddChild(std::move(child));
-  root_clip->AddChild(std::move(root));
+  root->test_properties()->AddChild(std::move(child));
+  root_clip->test_properties()->AddChild(std::move(root));
   child_layer->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(child_layer->id(),
                                                      gfx::ScrollOffset(0, 3));
   grand_child_layer->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(grand_child_layer->id(),
                                                      gfx::ScrollOffset(0, 2));
   host_impl_->active_tree()->SetRootLayer(std::move(root_clip));
   host_impl_->active_tree()->DidBecomeActive();
@@ skipping 259 matching lines @@
   {
     std::unique_ptr<LayerImpl> root =
         LayerImpl::Create(host_impl_->active_tree(), 1);
     root->SetBounds(gfx::Size(10, 10));
     root->SetDrawsContent(false);
     root->test_properties()->force_render_surface = true;
     host_impl_->active_tree()->SetRootLayer(std::move(root));
   }
   LayerImpl* root = host_impl_->active_tree()->root_layer();
 
-  root->AddChild(
-      BlendStateCheckLayer::Create(host_impl_->active_tree(),
-                                   2,
-                                   host_impl_->resource_provider()));
+  root->test_properties()->AddChild(BlendStateCheckLayer::Create(
+      host_impl_->active_tree(), 2, host_impl_->resource_provider()));
   BlendStateCheckLayer* layer1 =
       static_cast<BlendStateCheckLayer*>(root->test_properties()->children[0]);
   layer1->SetPosition(gfx::PointF(2.f, 2.f));
 
   LayerTreeHostImpl::FrameData frame;
 
   // Opaque layer, drawn without blending.
   layer1->SetContentsOpaque(true);
   layer1->SetExpectation(false, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
@@ skipping 30 matching lines @@
   layer1->test_properties()->opacity = 0.5f;
   layer1->NoteLayerPropertyChanged();
   layer1->SetExpectation(true, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   SetNeedsRebuildPropertyTrees();
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
   host_impl_->DrawLayers(&frame);
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 
-  layer1->AddChild(
-      BlendStateCheckLayer::Create(host_impl_->active_tree(),
-                                   3,
-                                   host_impl_->resource_provider()));
+  layer1->test_properties()->AddChild(BlendStateCheckLayer::Create(
+      host_impl_->active_tree(), 3, host_impl_->resource_provider()));
   BlendStateCheckLayer* layer2 = static_cast<BlendStateCheckLayer*>(
       layer1->test_properties()->children[0]);
   layer2->SetPosition(gfx::PointF(4.f, 4.f));
 
   // 2 opaque layers, drawn without blending.
   layer1->SetContentsOpaque(true);
   layer1->test_properties()->opacity = 1.f;
   layer1->NoteLayerPropertyChanged();
   layer1->SetExpectation(false, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
@@ skipping 187 matching lines @@
   }
 
   void SetupActiveTreeLayers() {
     host_impl_->active_tree()->set_background_color(SK_ColorGRAY);
     host_impl_->active_tree()->SetRootLayer(
         LayerImpl::Create(host_impl_->active_tree(), 1));
     host_impl_->active_tree()
         ->root_layer()
         ->test_properties()
         ->force_render_surface = true;
-    host_impl_->active_tree()->root_layer()->AddChild(
-        BlendStateCheckLayer::Create(host_impl_->active_tree(),
-                                     2,
+    host_impl_->active_tree()->root_layer()->test_properties()->AddChild(
+        BlendStateCheckLayer::Create(host_impl_->active_tree(), 2,
                                      host_impl_->resource_provider()));
     child_ = static_cast<BlendStateCheckLayer*>(host_impl_->active_tree()
                                                     ->root_layer()
                                                     ->test_properties()
                                                     ->children[0]);
     child_->SetExpectation(false, false);
     child_->SetContentsOpaque(true);
   }
 
   // Expect no gutter rects.
@@ skipping 356 matching lines @@
   std::unique_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(layer_tree_host_impl->active_tree(), 1);
   root->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> child =
       FakeDrawableLayerImpl::Create(layer_tree_host_impl->active_tree(), 2);
   child->SetPosition(gfx::PointF(12.f, 13.f));
   child->SetBounds(gfx::Size(14, 15));
   child->SetDrawsContent(true);
   root->SetBounds(gfx::Size(500, 500));
   root->SetDrawsContent(true);
-  root->AddChild(std::move(child));
+  root->test_properties()->AddChild(std::move(child));
   layer_tree_host_impl->active_tree()->SetRootLayer(std::move(root));
 
   LayerTreeHostImpl::FrameData frame;
 
   // First frame, the entire screen should get swapped.
   layer_tree_host_impl->active_tree()
       ->BuildLayerListAndPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, layer_tree_host_impl->PrepareToDraw(&frame));
   layer_tree_host_impl->DrawLayers(&frame);
   layer_tree_host_impl->DidDrawAllLayers(frame);
@@ skipping 48 matching lines @@
 TEST_F(LayerTreeHostImplTest, RootLayerDoesntCreateExtraSurface) {
   std::unique_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 1);
   std::unique_ptr<LayerImpl> child =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 2);
   child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
   root->SetBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->test_properties()->force_render_surface = true;
-  root->AddChild(std::move(child));
+  root->test_properties()->AddChild(std::move(child));
 
   host_impl_->active_tree()->SetRootLayer(std::move(root));
 
   LayerTreeHostImpl::FrameData frame;
 
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
   EXPECT_EQ(1u, frame.render_surface_layer_list->size());
   EXPECT_EQ(1u, frame.render_passes.size());
   host_impl_->DidDrawAllLayers(frame);
 }
@@ skipping 249 matching lines @@
   child->SetBounds(gfx::Size(child_rect.width(), child_rect.height()));
   child->draw_properties().visible_layer_rect = child_rect;
   child->SetDrawsContent(false);
   child->test_properties()->force_render_surface = true;
 
   grand_child->SetPosition(gfx::PointF(grand_child_rect.origin()));
   grand_child->SetBounds(grand_child_rect.size());
   grand_child->draw_properties().visible_layer_rect = grand_child_rect;
   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));
 
   my_host_impl->active_tree()->SetRootLayer(std::move(root));
   my_host_impl->active_tree()->BuildLayerListAndPropertyTreesForTesting();
   return my_host_impl;
 }
 
 TEST_F(LayerTreeHostImplTest, ContributingLayerEmptyScissorPartialSwap) {
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   scoped_refptr<TestContextProvider> provider(TestContextProvider::Create());
@@ skipping 68 matching lines @@
 
   scoped_refptr<VideoFrame> softwareFrame =
       media::VideoFrame::CreateColorFrame(
           gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta());
   FakeVideoFrameProvider provider;
   provider.set_frame(softwareFrame);
   std::unique_ptr<VideoLayerImpl> video_layer = VideoLayerImpl::Create(
       host_impl_->active_tree(), 4, &provider, media::VIDEO_ROTATION_0);
   video_layer->SetBounds(gfx::Size(10, 10));
   video_layer->SetDrawsContent(true);
-  root_layer->AddChild(std::move(video_layer));
+  root_layer->test_properties()->AddChild(std::move(video_layer));
 
   host_impl_->active_tree()->SetRootLayer(std::move(root_layer));
 
   EXPECT_EQ(0u, context3d->NumTextures());
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
   host_impl_->DrawLayers(&frame);
   host_impl_->DidDrawAllLayers(frame);
   host_impl_->SwapBuffers(frame);
@@ skipping 103 matching lines @@
   root->SetBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->test_properties()->force_render_surface = true;
 
   // Child layer is in the bottom right corner.
   std::unique_ptr<SolidColorLayerImpl> child =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 2);
   child->SetPosition(gfx::PointF(9.f, 9.f));
   child->SetBounds(gfx::Size(1, 1));
   child->SetDrawsContent(true);
-  root->AddChild(std::move(child));
+  root->test_properties()->AddChild(std::move(child));
 
   host_impl_->active_tree()->SetRootLayer(std::move(root));
 
   // Draw a frame. In the first frame, the entire viewport should be damaged.
   gfx::Rect full_frame_damage(host_impl_->DrawViewportSize());
   DrawFrameAndTestDamage(full_frame_damage);
 
   // The second frame has damage that doesn't touch the child layer. Its quads
   // should still be generated.
   gfx::Rect small_damage = gfx::Rect(0, 0, 1, 1);
@@ skipping 35 matching lines @@
   std::unique_ptr<LayerImpl> scoped_root =
       LayerImpl::Create(host_impl_->pending_tree(), 1);
   LayerImpl* root = scoped_root.get();
   root->test_properties()->force_render_surface = true;
 
   host_impl_->pending_tree()->SetRootLayer(std::move(scoped_root));
 
   std::unique_ptr<LayerImpl> scoped_scrolling_layer =
       LayerImpl::Create(host_impl_->pending_tree(), 2);
   LayerImpl* scrolling_layer = scoped_scrolling_layer.get();
-  root->AddChild(std::move(scoped_scrolling_layer));
+  root->test_properties()->AddChild(std::move(scoped_scrolling_layer));
 
   gfx::Size content_layer_bounds(100000, 100);
   scoped_refptr<FakeRasterSource> raster_source(
       FakeRasterSource::CreateFilled(content_layer_bounds));
 
   std::unique_ptr<FakePictureLayerImpl> scoped_content_layer =
       FakePictureLayerImpl::CreateWithRasterSource(host_impl_->pending_tree(),
                                                    3, raster_source);
   LayerImpl* content_layer = scoped_content_layer.get();
-  scrolling_layer->AddChild(std::move(scoped_content_layer));
+  scrolling_layer->test_properties()->AddChild(std::move(scoped_content_layer));
   content_layer->SetBounds(content_layer_bounds);
   content_layer->SetDrawsContent(true);
 
   root->SetBounds(root_size);
 
   gfx::ScrollOffset scroll_offset(100000, 0);
   scrolling_layer->SetScrollClipLayer(root->id());
   scrolling_layer->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(scrolling_layer->id(),
@@ skipping 121 matching lines @@
   // SolidColorLayerImpl will be drawn.
   std::unique_ptr<SolidColorLayerImpl> root_layer =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
 
   // VideoLayerImpl will not be drawn.
   FakeVideoFrameProvider provider;
   std::unique_ptr<VideoLayerImpl> video_layer = VideoLayerImpl::Create(
       host_impl_->active_tree(), 2, &provider, media::VIDEO_ROTATION_0);
   video_layer->SetBounds(gfx::Size(10, 10));
   video_layer->SetDrawsContent(true);
-  root_layer->AddChild(std::move(video_layer));
+  root_layer->test_properties()->AddChild(std::move(video_layer));
   SetupRootLayerImpl(std::move(root_layer));
 
   host_impl_->OnDraw(external_transform, external_viewport, external_clip,
                      resourceless_software_draw);
 
   EXPECT_EQ(1u, last_on_draw_frame_->will_draw_layers.size());
   EXPECT_EQ(host_impl_->active_tree()->root_layer(),
             last_on_draw_frame_->will_draw_layers[0]);
 }
 
@@ skipping 200 matching lines @@
   std::unique_ptr<LayerImpl> root_clip =
       LayerImpl::Create(host_impl_->active_tree(), 3);
   root_clip->test_properties()->force_render_surface = true;
 
   std::unique_ptr<LayerImpl> root_scroll =
       CreateScrollableLayer(1, content_size, root_clip.get());
   root_scroll->test_properties()->is_container_for_fixed_position_layers = true;
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root_clip.get());
 
-  root_scroll->AddChild(std::move(child));
+  root_scroll->test_properties()->AddChild(std::move(child));
   int root_id = root_scroll->id();
-  root_clip->AddChild(std::move(root_scroll));
-  root_ptr->AddChild(std::move(root_clip));
+  root_clip->test_properties()->AddChild(std::move(root_scroll));
+  root_ptr->test_properties()->AddChild(std::move(root_clip));
 
   host_impl_->SetViewportSize(surface_size);
   host_impl_->active_tree()->SetRootLayer(std::move(root_ptr));
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 4, 1,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
   {
     EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
@@ skipping 36 matching lines @@
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(grand_child->id(),
                                                      gfx::ScrollOffset(0, 2));
 
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(3, surface_size, root.get());
   child->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(child->id(),
                                                      gfx::ScrollOffset(0, 4));
-  child->AddChild(std::move(grand_child));
+  child->test_properties()->AddChild(std::move(grand_child));
 
-  root_scrolling->AddChild(std::move(child));
-  root->AddChild(std::move(root_scrolling));
+  root_scrolling->test_properties()->AddChild(std::move(child));
+  root->test_properties()->AddChild(std::move(root_scrolling));
   host_impl_->active_tree()->SetRootLayer(std::move(root));
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
   {
     std::unique_ptr<ScrollAndScaleSet> scroll_info;
     LayerImpl* child = host_impl_->active_tree()
                            ->root_layer()
                            ->test_properties()
@@ skipping 59 matching lines @@
   gfx::Size content_size(20, 20);
   std::unique_ptr<LayerImpl> root_clip =
       LayerImpl::Create(host_impl_->active_tree(), 3);
   root_clip->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> root_scroll =
       CreateScrollableLayer(1, content_size, root_clip.get());
   int root_scroll_id = root_scroll->id();
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root_clip.get());
 
-  root_scroll->AddChild(std::move(child));
-  root_clip->AddChild(std::move(root_scroll));
+  root_scroll->test_properties()->AddChild(std::move(child));
+  root_clip->test_properties()->AddChild(std::move(root_scroll));
 
   host_impl_->SetViewportSize(surface_size);
   host_impl_->active_tree()->SetRootLayer(std::move(root_clip));
   host_impl_->active_tree()->DidBecomeActive();
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
   {
     EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
               host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                       InputHandler::WHEEL)
@@ skipping 33 matching lines @@
       host_impl_->active_tree()->LayerById(page_scale_layer_id);
 
   int occluder_layer_id = 6;
   std::unique_ptr<LayerImpl> occluder_layer =
       LayerImpl::Create(host_impl_->active_tree(), occluder_layer_id);
   occluder_layer->SetDrawsContent(true);
   occluder_layer->SetBounds(content_size);
   occluder_layer->SetPosition(gfx::PointF());
 
   // The parent of the occluder is *above* the scroller.
-  page_scale_layer->AddChild(std::move(occluder_layer));
+  page_scale_layer->test_properties()->AddChild(std::move(occluder_layer));
 
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   InputHandler::ScrollStatus status = host_impl_->ScrollBegin(
       BeginState(gfx::Point()).get(), InputHandler::WHEEL);
   EXPECT_EQ(InputHandler::SCROLL_UNKNOWN, status.thread);
   EXPECT_EQ(MainThreadScrollingReason::kFailedHitTest,
             status.main_thread_scrolling_reasons);
 }
@@ skipping 20 matching lines @@
   int child_scroll_clip_layer_id = 7;
   std::unique_ptr<LayerImpl> child_scroll_clip =
       LayerImpl::Create(host_impl_->active_tree(), child_scroll_clip_layer_id);
 
   int child_scroll_layer_id = 8;
   std::unique_ptr<LayerImpl> child_scroll = CreateScrollableLayer(
       child_scroll_layer_id, content_size, child_scroll_clip.get());
 
   child_scroll->SetPosition(gfx::PointF(10.f, 10.f));
 
-  child_scroll->AddChild(std::move(occluder_layer));
-  child_scroll_clip->AddChild(std::move(child_scroll));
-  scroll_layer->AddChild(std::move(child_scroll_clip));
+  child_scroll->test_properties()->AddChild(std::move(occluder_layer));
+  child_scroll_clip->test_properties()->AddChild(std::move(child_scroll));
+  scroll_layer->test_properties()->AddChild(std::move(child_scroll_clip));
 
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   InputHandler::ScrollStatus status = host_impl_->ScrollBegin(
       BeginState(gfx::Point()).get(), InputHandler::WHEEL);
   EXPECT_EQ(InputHandler::SCROLL_UNKNOWN, status.thread);
   EXPECT_EQ(MainThreadScrollingReason::kFailedHitTest,
             status.main_thread_scrolling_reasons);
 }
 
 TEST_F(LayerTreeHostImplTest, NotScrollInvisibleScroller) {
   gfx::Size content_size(100, 100);
   SetupScrollAndContentsLayers(content_size);
 
   LayerImpl* root = host_impl_->active_tree()->LayerById(1);
 
   int scroll_layer_id = 2;
   LayerImpl* scroll_layer =
       host_impl_->active_tree()->LayerById(scroll_layer_id);
 
   int child_scroll_layer_id = 7;
   std::unique_ptr<LayerImpl> child_scroll =
       CreateScrollableLayer(child_scroll_layer_id, content_size, root);
   child_scroll->SetDrawsContent(false);
 
-  scroll_layer->AddChild(std::move(child_scroll));
+  scroll_layer->test_properties()->AddChild(std::move(child_scroll));
 
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   // We should not have scrolled |child_scroll| even though we technically "hit"
   // it. The reason for this is that if the scrolling the scroll would not move
   // any layer that is a drawn RSLL member, then we can ignore the hit.
   //
   // Why SCROLL_STARTED? In this case, it's because we've bubbled out and
   // started scrolling the inner viewport.
@@ skipping 20 matching lines @@
       LayerImpl::Create(host_impl_->active_tree(), 8);
   child_layer->SetDrawsContent(false);
 
   std::unique_ptr<LayerImpl> grand_child_layer =
       LayerImpl::Create(host_impl_->active_tree(), 9);
   grand_child_layer->SetDrawsContent(true);
   grand_child_layer->SetBounds(content_size);
   // Move the grand child so it's not hit by our test point.
   grand_child_layer->SetPosition(gfx::PointF(10.f, 10.f));
 
-  child_layer->AddChild(std::move(grand_child_layer));
-  invisible_scroll_layer->AddChild(std::move(child_layer));
-  root_scroll_layer->AddChild(std::move(invisible_scroll_layer));
+  child_layer->test_properties()->AddChild(std::move(grand_child_layer));
+  invisible_scroll_layer->test_properties()->AddChild(std::move(child_layer));
+  root_scroll_layer->test_properties()->AddChild(
+      std::move(invisible_scroll_layer));
 
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   // We should have scrolled |invisible_scroll_layer| as it was hit and it has
   // a descendant which is a drawn RSLL member.
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                     InputHandler::WHEEL)
                 .thread);
@@ skipping 33 matching lines @@
       LayerImpl::Create(host_impl_->active_tree(), container_id);
 
   std::unique_ptr<std::set<LayerImpl*>> scroll_children(
       new std::set<LayerImpl*>);
   scroll_children->insert(scroll_child.get());
   invisible_scroll->test_properties()->scroll_children.reset(
       scroll_children.release());
 
   scroll_child->test_properties()->scroll_parent = invisible_scroll.get();
 
-  container->AddChild(std::move(invisible_scroll));
-  container->AddChild(std::move(scroll_child));
+  container->test_properties()->AddChild(std::move(invisible_scroll));
+  container->test_properties()->AddChild(std::move(scroll_child));
 
-  scroll_layer->AddChild(std::move(container));
+  scroll_layer->test_properties()->AddChild(std::move(container));
 
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   // We should have scrolled |child_scroll| even though it is invisible.
   // The reason for this is that if the scrolling the scroll would move a layer
   // that is a drawn RSLL member, then we should accept this hit.
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                     InputHandler::WHEEL)
@@ skipping 735 matching lines @@
         ->scroll_tree.UpdateScrollOffsetBaseForTesting(outer_scroll->id(),
                                                        gfx::ScrollOffset());
     outer_scroll->SetBounds(content_size);
     outer_scroll->SetPosition(gfx::PointF());
 
     std::unique_ptr<LayerImpl> contents = LayerImpl::Create(layer_tree_impl, 8);
     contents->SetDrawsContent(true);
     contents->SetBounds(content_size);
     contents->SetPosition(gfx::PointF());
 
-    outer_scroll->AddChild(std::move(contents));
-    outer_clip->AddChild(std::move(outer_scroll));
-    inner_scroll->AddChild(std::move(outer_clip));
-    page_scale->AddChild(std::move(inner_scroll));
-    inner_clip->AddChild(std::move(page_scale));
+    outer_scroll->test_properties()->AddChild(std::move(contents));
+    outer_clip->test_properties()->AddChild(std::move(outer_scroll));
+    inner_scroll->test_properties()->AddChild(std::move(outer_clip));
+    page_scale->test_properties()->AddChild(std::move(inner_scroll));
+    inner_clip->test_properties()->AddChild(std::move(page_scale));
 
     inner_clip->test_properties()->force_render_surface = true;
     layer_tree_impl->SetRootLayer(std::move(inner_clip));
     layer_tree_impl->SetViewportLayersFromIds(
         Layer::INVALID_ID, kPageScaleLayerId, kInnerViewportScrollLayerId,
         kOuterViewportScrollLayerId);
 
     host_impl_->active_tree()->DidBecomeActive();
   }
 };
@@ skipping 163 matching lines @@
   gfx::Size inner_viewport = gfx::Size(25, 40);
 
   SetupVirtualViewportLayers(content_size, outer_viewport, inner_viewport);
 
   LayerImpl* outer_scroll = host_impl_->OuterViewportScrollLayer();
   LayerImpl* inner_scroll = host_impl_->InnerViewportScrollLayer();
 
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(10, outer_viewport, outer_scroll);
   LayerImpl* child_scroll = child.get();
-  outer_scroll->test_properties()->children[0]->AddChild(std::move(child));
+  outer_scroll->test_properties()->children[0]->test_properties()->AddChild(
+      std::move(child));
 
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
   {
     std::unique_ptr<ScrollAndScaleSet> scroll_info;
 
     gfx::Vector2d scroll_delta(0, inner_viewport.height());
     EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
               host_impl_
                   ->ScrollBegin(BeginState(gfx::Point()).get(),
@@ skipping 47 matching lines @@
   gfx::Size inner_viewport = gfx::Size(25, 40);
 
   SetupVirtualViewportLayers(content_size, outer_viewport, inner_viewport);
 
   LayerImpl* outer_scroll = host_impl_->OuterViewportScrollLayer();
   LayerImpl* inner_scroll = host_impl_->InnerViewportScrollLayer();
 
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(10, outer_viewport, outer_scroll);
   LayerImpl* child_scroll = child.get();
-  outer_scroll->test_properties()->children[0]->AddChild(std::move(child));
+  outer_scroll->test_properties()->children[0]->test_properties()->AddChild(
+      std::move(child));
 
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_
                 ->RootScrollBegin(BeginState(gfx::Point()).get(),
                                   InputHandler::TOUCHSCREEN)
                 .thread);
   EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), inner_scroll);
@@ skipping 336 matching lines @@
   EXPECT_EQ(gfx::Rect(50, 50), content_layer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostImplTest, ExternalTransformAffectsSublayerScaleFactor) {
   const gfx::Size layer_size(100, 100);
   SetupScrollAndContentsLayers(layer_size);
   LayerImpl* content_layer = host_impl_->active_tree()
                                  ->OuterViewportScrollLayer()
                                  ->test_properties()
                                  ->children[0];
-  content_layer->AddChild(LayerImpl::Create(host_impl_->active_tree(), 100));
+  content_layer->test_properties()->AddChild(
+      LayerImpl::Create(host_impl_->active_tree(), 100));
   LayerImpl* test_layer = host_impl_->active_tree()->LayerById(100);
   test_layer->test_properties()->force_render_surface = true;
   test_layer->SetDrawsContent(true);
   test_layer->SetBounds(layer_size);
   gfx::Transform perspective_transform;
   perspective_transform.ApplyPerspectiveDepth(2);
   test_layer->SetTransform(perspective_transform);
 
   SetNeedsRebuildPropertyTrees();
   RebuildPropertyTrees();
@@ skipping 1073 matching lines @@
           page_scale_layer->transform_tree_index());
   EXPECT_EQ(active_tree_node->data.post_local_scale_factor, 2.f);
 }
 
 TEST_F(LayerTreeHostImplTest, SubLayerScaleForNodeInSubtreeOfPageScaleLayer) {
   // Checks that the sublayer scale of a transform node in the subtree of the
   // page scale layer is updated without a property tree rebuild.
   host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 1.f, 3.f);
   CreateScrollAndContentsLayers(host_impl_->active_tree(), gfx::Size(100, 100));
   LayerImpl* page_scale_layer = host_impl_->active_tree()->PageScaleLayer();
-  page_scale_layer->AddChild(LayerImpl::Create(host_impl_->active_tree(), 100));
+  page_scale_layer->test_properties()->AddChild(
+      LayerImpl::Create(host_impl_->active_tree(), 100));
 
   LayerImpl* in_subtree_of_page_scale_layer =
       host_impl_->active_tree()->LayerById(100);
   in_subtree_of_page_scale_layer->test_properties()->force_render_surface =
       true;
   SetNeedsRebuildPropertyTrees();
   RebuildPropertyTrees();
   DrawFrame();
   TransformNode* node =
       host_impl_->active_tree()->property_trees()->transform_tree.Node(
@@ skipping 97 matching lines @@
 
   // Re-initialize with a software output surface.
   output_surface_ = FakeOutputSurface::CreateSoftware(
       base::WrapUnique(new SoftwareOutputDevice));
   host_impl_->InitializeRenderer(output_surface_.get());
   EXPECT_FALSE(host_impl_->use_gpu_rasterization());
 }
 
 }  // namespace
 }  // namespace cc