cc : Move LayerImpl::parent to test properties

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 329 matching lines @@
       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->SetHasRenderSurface(true);
   LayerImpl* root_layer = root.get();
   host_impl.active_tree()->SetRootLayer(std::move(root));
 
   ExecuteCalculateDrawProperties(root_layer, kDeviceScale, page_scale,
-                                 scroll_layer->parent());
+                                 scroll_layer->test_properties()->parent);
   gfx::Transform expected_transform = identity_matrix;
   gfx::PointF sub_layer_screen_position = kScrollLayerPosition - kScrollDelta;
   expected_transform.Translate(MathUtil::Round(sub_layer_screen_position.x() *
                                                page_scale * kDeviceScale),
                                MathUtil::Round(sub_layer_screen_position.y() *
                                                page_scale * kDeviceScale));
   expected_transform.Scale(page_scale * kDeviceScale,
                            page_scale * kDeviceScale);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
                                   sublayer->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
                                   sublayer->ScreenSpaceTransform());
 
   gfx::Transform arbitrary_translate;
   const float kTranslateX = 10.6f;
   const float kTranslateY = 20.6f;
   arbitrary_translate.Translate(kTranslateX, kTranslateY);
   SetLayerPropertiesForTesting(scroll_layer, arbitrary_translate,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(10, 20),
                                true, false, false);
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_layer, kDeviceScale, page_scale,
-                                 scroll_layer->parent());
+                                 scroll_layer->test_properties()->parent);
   expected_transform.MakeIdentity();
   expected_transform.Translate(
       MathUtil::Round(kTranslateX * page_scale * kDeviceScale +
                       sub_layer_screen_position.x() * page_scale *
                           kDeviceScale),
       MathUtil::Round(kTranslateY * page_scale * kDeviceScale +
                       sub_layer_screen_position.y() * page_scale *
                           kDeviceScale));
   expected_transform.Scale(page_scale * kDeviceScale,
                            page_scale * kDeviceScale);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
                                   sublayer->DrawTransform());
 
   // Test that page scale is updated even when we don't rebuild property trees.
   page_scale = 1.888f;
   root_layer->layer_tree_impl()->SetViewportLayersFromIds(
-      Layer::INVALID_ID, scroll_layer->parent()->id(), Layer::INVALID_ID,
-      Layer::INVALID_ID);
+      Layer::INVALID_ID, scroll_layer->test_properties()->parent->id(),
+      Layer::INVALID_ID, Layer::INVALID_ID);
   root_layer->layer_tree_impl()->SetPageScaleOnActiveTree(page_scale);
   EXPECT_FALSE(root_layer->layer_tree_impl()->property_trees()->needs_rebuild);
   ExecuteCalculateDrawProperties(root_layer, kDeviceScale, page_scale,
-                                 scroll_layer->parent());
+                                 scroll_layer->test_properties()->parent);
 
   expected_transform.MakeIdentity();
   expected_transform.Translate(
       MathUtil::Round(kTranslateX * page_scale * kDeviceScale +
                       sub_layer_screen_position.x() * page_scale *
                           kDeviceScale),
       MathUtil::Round(kTranslateY * page_scale * kDeviceScale +
                       sub_layer_screen_position.y() * page_scale *
                           kDeviceScale));
   expected_transform.Scale(page_scale * kDeviceScale,
@@ skipping 400 matching lines @@
                                gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
                                gfx::Size(10, 10), true, false, false);
   SetLayerPropertiesForTesting(replica_of_rs1.get(), replica_layer_transform,
                                gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
                                gfx::Size(), true, false, false);
   SetLayerPropertiesForTesting(replica_of_rs2.get(), replica_layer_transform,
                                gfx::Point3F(2.5f, 0.f, 0.f), gfx::PointF(),
                                gfx::Size(), true, false, false);
 
   // We need to set parent on replica layers for property tree building.
-  replica_of_rs1->SetParent(render_surface1);
-  replica_of_rs2->SetParent(render_surface2);
+  replica_of_rs1->test_properties()->parent = render_surface1;
+  replica_of_rs2->test_properties()->parent = render_surface2;
   render_surface1->SetReplicaLayer(std::move(replica_of_rs1));
   render_surface2->SetReplicaLayer(std::move(replica_of_rs2));
   ExecuteCalculateDrawProperties(root);
 
   // Only layers that are associated with render surfaces should have an actual
   // RenderSurface() value.
   ASSERT_TRUE(root->render_surface());
   ASSERT_FALSE(child_of_root->render_surface());
   ASSERT_FALSE(grand_child_of_root->render_surface());
 
@@ skipping 4095 matching lines @@
 
   gfx::Transform replica_transform;
   replica_transform.Scale(1.0, -1.0);
 
   std::unique_ptr<LayerImpl> replica =
       LayerImpl::Create(host_impl()->active_tree(), 7);
   SetLayerPropertiesForTesting(replica.get(), replica_transform, gfx::Point3F(),
                                gfx::PointF(2.f, 2.f), gfx::Size(10, 10), false,
                                true, false);
   // We need to set parent on replica layer for property tree building.
-  replica->SetParent(child);
+  replica->test_properties()->parent = child;
   child->SetReplicaLayer(std::move(replica));
 
   // This layer should end up in the same surface as child, with the same draw
   // and screen space transforms.
   LayerImpl* duplicate_child_non_owner = AddChild<LayerImpl>(child);
   duplicate_child_non_owner->SetDrawsContent(true);
   SetLayerPropertiesForTesting(duplicate_child_non_owner, identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
                                false, true, false);
 
@@ skipping 4788 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(transform,
                                   child->mask_layer()->ScreenSpaceTransform());
   EXPECT_EQ(gfx::Rect(20, 20), child->mask_layer()->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, ReplicaMaskLayerDrawProperties) {
   // Tests that a replica mask layer's draw properties are computed correctly.
   LayerImpl* root = root_layer();
   LayerImpl* child = AddChild<LayerImpl>(root);
   child->SetReplicaLayer(LayerImpl::Create(root->layer_tree_impl(), 100));
-  child->replica_layer()->SetParent(child);
+  child->replica_layer()->test_properties()->parent = child;
   child->replica_layer()->SetMaskLayer(
       LayerImpl::Create(root->layer_tree_impl(), 200));
 
   const gfx::Transform identity_matrix;
   gfx::Transform transform;
   transform.Translate(10, 10);
 
   gfx::PointF replica_position(3.f, 3.f);
 
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
@@ skipping 527 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