cc: Move LayerImpl::AddChild and RemoveChild to LayerImplTestProperties

cc/trees/layer_tree_host_common_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 310 matching lines @@
       LayerImpl::Create(host_impl.active_tree(), 4));
   LayerImpl* clip_layer = clip_layer_scoped_ptr.get();
 
   scroll_layer->SetScrollClipLayer(clip_layer->id());
   clip_layer->SetBounds(
       gfx::Size(scroll_layer->bounds().width() + kMaxScrollOffset.x(),
                 scroll_layer->bounds().height() + kMaxScrollOffset.y()));
   scroll_layer->SetScrollClipLayer(clip_layer->id());
   SetScrollOffsetDelta(scroll_layer, kScrollDelta);
   gfx::Transform impl_transform;
-  scroll_layer->AddChild(std::move(sublayer_scoped_ptr));
+  scroll_layer->test_properties()->AddChild(std::move(sublayer_scoped_ptr));
   LayerImpl* scroll_layer_raw_ptr = scroll_layer_scoped_ptr.get();
-  clip_layer->AddChild(std::move(scroll_layer_scoped_ptr));
+  clip_layer->test_properties()->AddChild(std::move(scroll_layer_scoped_ptr));
   scroll_layer_raw_ptr->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(scroll_layer_raw_ptr->id(),
                                                      kScrollOffset);
 
   std::unique_ptr<LayerImpl> root(
       LayerImpl::Create(host_impl.active_tree(), 3));
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(3, 4), true, false,
                                false);
-  root->AddChild(std::move(clip_layer_scoped_ptr));
+  root->test_properties()->AddChild(std::move(clip_layer_scoped_ptr));
   root->SetHasRenderSurface(true);
   LayerImpl* root_layer = root.get();
   host_impl.active_tree()->SetRootLayer(std::move(root));
 
   ExecuteCalculateDrawProperties(root_layer, kDeviceScale, page_scale,
                                  scroll_layer->test_properties()->parent);
   gfx::Transform expected_transform = identity_matrix;
   gfx::PointF sub_layer_screen_position = kScrollLayerPosition - kScrollDelta;
   expected_transform.Translate(MathUtil::Round(sub_layer_screen_position.x() *
                                                page_scale * kDeviceScale),
@@ skipping 3343 matching lines @@
                                false, true, false);
   SetLayerPropertiesForTesting(grand_child.get(), rotation, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(200, 200), false, true,
                                false);
   SetLayerPropertiesForTesting(occluding_child.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(),
                                gfx::Size(200, 200), false, false, false);
 
   host_impl.SetViewportSize(root->bounds());
 
-  child->AddChild(std::move(grand_child));
-  root->AddChild(std::move(child));
-  root->AddChild(std::move(occluding_child));
+  child->test_properties()->AddChild(std::move(grand_child));
+  root->test_properties()->AddChild(std::move(child));
+  root->test_properties()->AddChild(std::move(occluding_child));
   host_impl.active_tree()->SetRootLayer(std::move(root));
   host_impl.SetVisible(true);
   host_impl.InitializeRenderer(output_surface.get());
   host_impl.active_tree()->BuildLayerListAndPropertyTreesForTesting();
   bool update_lcd_text = false;
   host_impl.active_tree()->UpdateDrawProperties(update_lcd_text);
 
   LayerImpl* grand_child_ptr = host_impl.active_tree()
                                    ->root_layer()
                                    ->test_properties()
@@ skipping 1415 matching lines @@
 
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl.pending_tree(), 2);
   SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
   child->SetDrawsContent(true);
   child->test_properties()->opacity = 0.0f;
 
   const int child_id = child->id();
-  root->AddChild(std::move(child));
+  root->test_properties()->AddChild(std::move(child));
   root->SetHasRenderSurface(true);
   LayerImpl* root_layer = root.get();
   host_impl.pending_tree()->SetRootLayer(std::move(root));
   host_impl.pending_tree()->BuildLayerListAndPropertyTreesForTesting();
   // Add opacity animation.
   scoped_refptr<AnimationTimeline> timeline =
       AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
   AddOpacityTransitionToLayerWithPlayer(child_id, timeline, 10.0, 0.0f, 1.0f,
@@ skipping 98 matching lines @@
     std::unique_ptr<LayerImpl> child_ptr =
         LayerImpl::Create(host_impl_.active_tree(), 2);
     std::unique_ptr<LayerImpl> grand_child_ptr =
         LayerImpl::Create(host_impl_.active_tree(), 3);
 
     // Stash raw pointers to look at later.
     root_ = root_ptr.get();
     child_ = child_ptr.get();
     grand_child_ = grand_child_ptr.get();
 
-    child_->AddChild(std::move(grand_child_ptr));
-    root_->AddChild(std::move(child_ptr));
+    child_->test_properties()->AddChild(std::move(grand_child_ptr));
+    root_->test_properties()->AddChild(std::move(child_ptr));
     host_impl_.active_tree()->SetRootLayer(std::move(root_ptr));
 
     root_->SetContentsOpaque(true);
     child_->SetContentsOpaque(true);
     grand_child_->SetContentsOpaque(true);
 
     root_->SetDrawsContent(true);
     child_->SetDrawsContent(true);
     grand_child_->SetDrawsContent(true);
 
@@ skipping 191 matching lines @@
   child->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> grand_child =
       LayerImpl::Create(host_impl.pending_tree(), 3);
   SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false, false);
   grand_child->SetDrawsContent(true);
   grand_child->test_properties()->hide_layer_and_subtree = 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));
   root->SetHasRenderSurface(true);
   host_impl.pending_tree()->SetRootLayer(std::move(root));
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, root_layer->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // We should have one render surface and two layers. The grand child has
@@ skipping 29 matching lines @@
   child->SetDrawsContent(true);
   child->test_properties()->hide_layer_and_subtree = true;
 
   std::unique_ptr<LayerImpl> grand_child =
       LayerImpl::Create(host_impl.pending_tree(), 3);
   SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false, false);
   grand_child->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.pending_tree()->SetRootLayer(std::move(root));
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, root_layer->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // We should have one render surface and one layers. The child has
   // hidden itself and the grand child.
@@ skipping 72 matching lines @@
 
   std::unique_ptr<LayerImpl> copy_grand_parent_sibling_after =
       LayerImpl::Create(host_impl.pending_tree(), 8);
   SetLayerPropertiesForTesting(copy_grand_parent_sibling_after.get(),
                                identity_matrix, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(40, 40), true, false, false);
   copy_grand_parent_sibling_after->SetDrawsContent(true);
   LayerImpl* copy_grand_parent_sibling_after_layer =
       copy_grand_parent_sibling_after.get();
 
-  copy_child->AddChild(std::move(copy_grand_child));
-  copy_request->AddChild(std::move(copy_child));
-  copy_parent->AddChild(std::move(copy_request));
-  copy_grand_parent->AddChild(std::move(copy_parent));
-  root->AddChild(std::move(copy_grand_parent_sibling_before));
-  root->AddChild(std::move(copy_grand_parent));
-  root->AddChild(std::move(copy_grand_parent_sibling_after));
+  copy_child->test_properties()->AddChild(std::move(copy_grand_child));
+  copy_request->test_properties()->AddChild(std::move(copy_child));
+  copy_parent->test_properties()->AddChild(std::move(copy_request));
+  copy_grand_parent->test_properties()->AddChild(std::move(copy_parent));
+  root->test_properties()->AddChild(
+      std::move(copy_grand_parent_sibling_before));
+  root->test_properties()->AddChild(std::move(copy_grand_parent));
+  root->test_properties()->AddChild(std::move(copy_grand_parent_sibling_after));
   host_impl.pending_tree()->SetRootLayer(std::move(root));
 
   // Hide the copy_grand_parent and its subtree. But make a copy request in that
   // hidden subtree on copy_layer. Also hide the copy grand child and its
   // subtree.
   copy_grand_parent_layer->test_properties()->hide_layer_and_subtree = true;
   copy_grand_parent_sibling_before_layer->test_properties()
       ->hide_layer_and_subtree = true;
   copy_grand_parent_sibling_after_layer->test_properties()
       ->hide_layer_and_subtree = true;
@@ skipping 99 matching lines @@
   std::unique_ptr<LayerImpl> copy_child =
       LayerImpl::Create(host_impl.pending_tree(), 4);
   SetLayerPropertiesForTesting(copy_child.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(20, 20),
                                true, false, false);
   copy_child->SetDrawsContent(true);
 
   copy_layer->test_properties()->copy_requests.push_back(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
 
-  copy_layer->AddChild(std::move(copy_child));
-  copy_parent->AddChild(std::move(copy_layer));
-  root->AddChild(std::move(copy_parent));
+  copy_layer->test_properties()->AddChild(std::move(copy_child));
+  copy_parent->test_properties()->AddChild(std::move(copy_layer));
+  root->test_properties()->AddChild(std::move(copy_parent));
 
   LayerImplList render_surface_layer_list;
   LayerImpl* root_layer = root.get();
   root_layer->layer_tree_impl()->SetRootLayer(std::move(root));
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, root_layer->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // We should have two render surface, as the others are clipped out.
@@ skipping 560 matching lines @@
   SetLayerPropertiesForTesting(child2.get(), identity_matrix, transform_origin,
                                position, bounds, true, false, true);
   child2->SetDrawsContent(true);
   SetLayerPropertiesForTesting(child3.get(), identity_matrix, transform_origin,
                                position, bounds, true, false, false);
   child3->SetDrawsContent(true);
 
   child2->Set3dSortingContextId(1);
   child3->Set3dSortingContextId(1);
 
-  child2->AddChild(std::move(child3));
-  child1->AddChild(std::move(child2));
-  root->AddChild(std::move(child1));
+  child2->test_properties()->AddChild(std::move(child3));
+  child1->test_properties()->AddChild(std::move(child2));
+  root->test_properties()->AddChild(std::move(child1));
   LayerImpl* root_layer = root.get();
   root_layer->layer_tree_impl()->SetRootLayer(std::move(root));
 
   {
     LayerImplList render_surface_layer_list;
     FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(root_layer);
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root_layer, root_layer->bounds(), &render_surface_layer_list);
     inputs.can_render_to_separate_surface = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
@@ skipping 777 matching lines @@
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false, false);
   SetLayerPropertiesForTesting(fixed.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
 
   root->SetDrawsContent(true);
   container->SetDrawsContent(true);
   scroller->SetDrawsContent(true);
   fixed->SetDrawsContent(true);
-  scroller->AddChild(std::move(fixed));
-  container->AddChild(std::move(scroller));
-  root->AddChild(std::move(container));
+  scroller->test_properties()->AddChild(std::move(fixed));
+  container->test_properties()->AddChild(std::move(scroller));
+  root->test_properties()->AddChild(std::move(container));
 
   // Rounded to integers already.
   {
     root->layer_tree_impl()->SetRootLayer(std::move(root_ptr));
     root->layer_tree_impl()->BuildLayerListAndPropertyTreesForTesting();
 
     gfx::Vector2dF scroll_delta(3.0, 5.0);
     SetScrollOffsetDelta(scroll_layer, scroll_delta);
 
     LayerImplList render_surface_layer_list;
@@ skipping 159 matching lines @@
   std::unique_ptr<AnimationScaleFactorTrackingLayerImpl> child =
       AnimationScaleFactorTrackingLayerImpl::Create(host_impl.active_tree(), 3);
   std::unique_ptr<AnimationScaleFactorTrackingLayerImpl> grand_child =
       AnimationScaleFactorTrackingLayerImpl::Create(host_impl.active_tree(), 4);
 
   AnimationScaleFactorTrackingLayerImpl* parent_raw = parent.get();
   AnimationScaleFactorTrackingLayerImpl* child_raw = child.get();
   AnimationScaleFactorTrackingLayerImpl* grand_child_raw = grand_child.get();
   AnimationScaleFactorTrackingLayerImpl* grand_parent_raw = grand_parent.get();
 
-  child->AddChild(std::move(grand_child));
-  parent->AddChild(std::move(child));
-  grand_parent->AddChild(std::move(parent));
+  child->test_properties()->AddChild(std::move(grand_child));
+  parent->test_properties()->AddChild(std::move(child));
+  grand_parent->test_properties()->AddChild(std::move(parent));
 
   SetLayerPropertiesForTesting(grand_parent_raw, identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
                                true, false, true);
   SetLayerPropertiesForTesting(parent_raw, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
   SetLayerPropertiesForTesting(child_raw, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
@@ skipping 333 matching lines @@
       LayerImpl::Create(host_impl.active_tree(), 7);
   std::unique_ptr<LayerImpl> grand_child2 =
       LayerImpl::Create(host_impl.active_tree(), 9);
 
   LayerImpl* grand_parent_raw = grand_parent.get();
   LayerImpl* parent_raw = parent.get();
   LayerImpl* child_raw = child.get();
   LayerImpl* grand_child1_raw = grand_child1.get();
   LayerImpl* grand_child2_raw = grand_child2.get();
 
-  child->AddChild(std::move(grand_child1));
-  child->AddChild(std::move(grand_child2));
-  parent->AddChild(std::move(child));
-  grand_parent->AddChild(std::move(parent));
+  child->test_properties()->AddChild(std::move(grand_child1));
+  child->test_properties()->AddChild(std::move(grand_child2));
+  parent->test_properties()->AddChild(std::move(child));
+  grand_parent->test_properties()->AddChild(std::move(parent));
   host_impl.active_tree()->SetRootLayer(std::move(grand_parent));
 
   SetLayerPropertiesForTesting(grand_parent_raw, identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
                                true, false, true);
   SetLayerPropertiesForTesting(parent_raw, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
 
   SetLayerPropertiesForTesting(child_raw, identity_matrix, gfx::Point3F(),
@@ skipping 225 matching lines @@
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 1);
   LayerImpl* root_layer = root.get();
   std::unique_ptr<LayerImpl> child1 =
       LayerImpl::Create(host_impl.active_tree(), 2);
   LayerImpl* child1_layer = child1.get();
   std::unique_ptr<LayerImpl> child2 =
       LayerImpl::Create(host_impl.active_tree(), 3);
   LayerImpl* child2_layer = child2.get();
 
-  root->AddChild(std::move(child1));
-  root->AddChild(std::move(child2));
+  root->test_properties()->AddChild(std::move(child1));
+  root->test_properties()->AddChild(std::move(child2));
   root->test_properties()->force_render_surface = true;
   root->SetDrawsContent(true);
   host_impl.active_tree()->SetRootLayer(std::move(root));
 
   gfx::Transform identity_matrix, scale_transform_child1,
       scale_transform_child2;
   scale_transform_child1.Scale(2, 3);
   scale_transform_child2.Scale(4, 5);
 
   SetLayerPropertiesForTesting(root_layer, identity_matrix, gfx::Point3F(),
@@ skipping 174 matching lines @@
   SetLayerPropertiesForTesting(root,
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                root_size,
                                false,
                                false,
                                true);
   root->SetMasksToBounds(true);
 
-  root->AddChild(LayerImpl::Create(host_impl.active_tree(), 2));
+  root->test_properties()->AddChild(
+      LayerImpl::Create(host_impl.active_tree(), 2));
 
   LayerImpl* sublayer = root->test_properties()->children[0];
   SetLayerPropertiesForTesting(sublayer,
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                sublayer_size,
                                false,
                                false,
                                false);
@@ skipping 696 matching lines @@
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
   SetLayerPropertiesForTesting(grandchild.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
 
   LayerImpl* root_ptr = root.get();
   LayerImpl* child_ptr = child.get();
   LayerImpl* grandchild_ptr = grandchild.get();
 
-  child->AddChild(std::move(grandchild));
-  root->AddChild(std::move(child));
+  child->test_properties()->AddChild(std::move(grandchild));
+  root->test_properties()->AddChild(std::move(child));
   host_impl.active_tree()->SetRootLayer(std::move(root));
 
   // Check the non-skipped case.
   // ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   // EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   // Now we will reset the visible rect from property trees for the grandchild,
   // and we will configure |child| in several ways that should force the subtree
   // to be skipped. The visible content rect for |grandchild| should, therefore,
   // remain empty.
@@ skipping 183 matching lines @@
   SetLayerPropertiesForTesting(child.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
   SetLayerPropertiesForTesting(grandchild.get(), identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
 
   LayerImpl* root_ptr = root.get();
   LayerImpl* grandchild_ptr = grandchild.get();
 
-  child->AddChild(std::move(grandchild));
-  root->AddChild(std::move(child));
+  child->test_properties()->AddChild(std::move(grandchild));
+  root->test_properties()->AddChild(std::move(child));
 
   host_impl.pending_tree()->SetRootLayer(std::move(root));
 
   // Check the non-skipped case.
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   std::unique_ptr<KeyframedFloatAnimationCurve> curve(
       KeyframedFloatAnimationCurve::Create());
   std::unique_ptr<TimingFunction> func =
@@ skipping 1275 matching lines @@
   EXPECT_EQ(scroll_child6.id, grand_child10->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent3->scroll_tree_index());
   EXPECT_EQ(scroll_child7.id, child8->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent4->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, child9->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, grand_child12->scroll_tree_index());
 }
 
 }  // namespace
 }  // namespace cc