cc: Add mask and replica layer ids to the effect tree

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 655 matching lines @@
                                gfx::Size(10, 12), true, false, false);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(16, 18), true, false,
                                true);
   SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(-0.5f, -0.5f), gfx::Size(1, 1), true,
                                false, false);
   SetLayerPropertiesForTesting(child_replica.get(), replica_layer_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(), true,
                                false, false);
-  child->SetReplicaLayer(std::move(child_replica));
+  child->test_properties()->SetReplicaLayer(std::move(child_replica));
 
   ExecuteCalculateDrawProperties(root);
 
   // Render surface should have been created now.
   ASSERT_TRUE(child->render_surface());
   ASSERT_EQ(child->render_surface(), child->render_target());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       replica_composite_transform,
       child->render_target()->replica_draw_transform());
@@ skipping 121 matching lines @@
   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);
-  render_surface1->SetReplicaLayer(std::move(replica_of_rs1));
-  render_surface2->SetReplicaLayer(std::move(replica_of_rs2));
+  render_surface1->test_properties()->SetReplicaLayer(
+      std::move(replica_of_rs1));
+  render_surface2->test_properties()->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());
 
   ASSERT_TRUE(render_surface1->render_surface());
   ASSERT_FALSE(child_of_rs1->render_surface());
@@ skipping 4094 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);
-  child->SetReplicaLayer(std::move(replica));
+  child->test_properties()->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);
 
   float device_scale_factor = 1.5f;
@@ skipping 90 matching lines @@
                                gfx::PointF(), gfx::Size(13, 11), false, true,
                                true);
 
   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(), gfx::Size(13, 11), false, true,
                                false);
-  child->SetReplicaLayer(std::move(replica));
+  child->test_properties()->SetReplicaLayer(std::move(replica));
 
   float device_scale_factor = 1.7f;
   ExecuteCalculateDrawProperties(parent, device_scale_factor);
 
   // We should have two render surfaces. The root's render surface and child's
   // render surface (it needs one because it has a replica layer).
   EXPECT_EQ(2u, render_surface_layer_list_impl()->size());
 
   gfx::Transform identity_transform;
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_transform,
@@ skipping 2507 matching lines @@
   for (LayerIterator it = LayerIterator::Begin(rsll),
                      end = LayerIterator::End(rsll);
        it != end; ++it) {
     LayerImpl* layer = *it;
     if (it.represents_itself())
       drawn_layers->insert(layer);
 
     if (!it.represents_contributing_render_surface())
       continue;
 
-    if (layer->mask_layer())
-      drawn_layers->insert(layer->mask_layer());
-    if (layer->replica_layer() && layer->replica_layer()->mask_layer())
-      drawn_layers->insert(layer->replica_layer()->mask_layer());
+    if (layer->render_surface()->MaskLayer())
+      drawn_layers->insert(layer->render_surface()->MaskLayer());
+    if (layer->render_surface()->ReplicaMaskLayer())
+      drawn_layers->insert(layer->render_surface()->ReplicaMaskLayer());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceLayerListMembership) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
   gfx::Transform identity_matrix;
@@ skipping 108 matching lines @@
   EXPECT_TRUE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   expected.clear();
   expected.insert(grand_child2_raw);
 
   actual.clear();
   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
   EXPECT_EQ(expected, actual);
 
   // Add a mask layer to child.
-  child_raw->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 6));
+  child_raw->test_properties()->SetMaskLayer(
+      LayerImpl::Create(host_impl.active_tree(), 6));
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member());
-  EXPECT_TRUE(
-      child_raw->mask_layer()->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(child_raw->test_properties()
+                  ->mask_layer->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   expected.clear();
   expected.insert(grand_child2_raw);
-  expected.insert(child_raw->mask_layer());
+  expected.insert(child_raw->test_properties()->mask_layer);
 
   expected.clear();
   expected.insert(grand_child2_raw);
-  expected.insert(child_raw->mask_layer());
+  expected.insert(child_raw->test_properties()->mask_layer);
 
   actual.clear();
   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
   EXPECT_EQ(expected, actual);
 
   // Add replica mask layer.
   std::unique_ptr<LayerImpl> replica_layer =
       LayerImpl::Create(host_impl.active_tree(), 20);
-  replica_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 21));
-  child_raw->SetReplicaLayer(std::move(replica_layer));
+  replica_layer->test_properties()->SetMaskLayer(
+      LayerImpl::Create(host_impl.active_tree(), 21));
+  child_raw->test_properties()->SetReplicaLayer(std::move(replica_layer));
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member());
-  EXPECT_TRUE(
-      child_raw->mask_layer()->is_drawn_render_surface_layer_list_member());
-  EXPECT_TRUE(child_raw->replica_layer()
-                  ->mask_layer()
-                  ->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(child_raw->test_properties()
+                  ->mask_layer->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(child_raw->test_properties()
+                  ->replica_layer->test_properties()
+                  ->mask_layer->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   expected.clear();
   expected.insert(grand_child2_raw);
-  expected.insert(child_raw->mask_layer());
-  expected.insert(child_raw->replica_layer()->mask_layer());
+  expected.insert(child_raw->test_properties()->mask_layer);
+  expected.insert(child_raw->test_properties()
+                      ->replica_layer->test_properties()
+                      ->mask_layer);
 
   actual.clear();
   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
   EXPECT_EQ(expected, actual);
 
-  child_raw->TakeReplicaLayerForTesting();
+  child_raw->test_properties()->SetReplicaLayer(nullptr);
+  child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   // With nothing drawing, we should have no layers.
   grand_child2_raw->SetDrawsContent(false);
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member());
-  EXPECT_FALSE(
-      child_raw->mask_layer()->is_drawn_render_surface_layer_list_member());
+  EXPECT_FALSE(child_raw->test_properties()
+                   ->mask_layer->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   expected.clear();
   actual.clear();
   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
   EXPECT_EQ(expected, actual);
 
   // Child itself draws means that we should have the child and the mask in the
   // list.
   child_raw->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(child_raw->is_drawn_render_surface_layer_list_member());
-  EXPECT_TRUE(
-      child_raw->mask_layer()->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(child_raw->test_properties()
+                  ->mask_layer->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   expected.clear();
   expected.insert(child_raw);
-  expected.insert(child_raw->mask_layer());
+  expected.insert(child_raw->test_properties()->mask_layer);
   actual.clear();
   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
   EXPECT_EQ(expected, actual);
 
-  child_raw->TakeMaskLayer();
+  child_raw->test_properties()->SetMaskLayer(nullptr);
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   // Now everyone's a member!
   grand_parent_raw->SetDrawsContent(true);
   parent_raw->SetDrawsContent(true);
   child_raw->SetDrawsContent(true);
   grand_child1_raw->SetDrawsContent(true);
   grand_child2_raw->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
@@ skipping 46 matching lines @@
   scale_transform_child1.Scale(2, 3);
   scale_transform_child2.Scale(4, 5);
 
   SetLayerPropertiesForTesting(root_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 1), true, false,
                                true);
   SetLayerPropertiesForTesting(child1_layer, scale_transform_child1,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 1),
                                true, false, false);
 
-  child1_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4));
+  child1_layer->test_properties()->SetMaskLayer(
+      LayerImpl::Create(host_impl.active_tree(), 4));
   child1_layer->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> replica_layer =
       LayerImpl::Create(host_impl.active_tree(), 5);
-  replica_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 6));
-  child1_layer->SetReplicaLayer(std::move(replica_layer));
+  replica_layer->test_properties()->SetMaskLayer(
+      LayerImpl::Create(host_impl.active_tree(), 6));
+  child1_layer->test_properties()->SetReplicaLayer(std::move(replica_layer));
   child1_layer->SetHasRenderSurface(true);
 
   ExecuteCalculateDrawProperties(root_layer);
 
   TransformOperations scale;
   scale.AppendScale(5.f, 8.f, 3.f);
 
   scoped_refptr<AnimationTimeline> timeline =
       AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
   AddAnimatedTransformToLayerWithPlayer(child2_layer->id(), timeline, 1.0,
                                         TransformOperations(), scale);
 
   SetLayerPropertiesForTesting(child2_layer, scale_transform_child2,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 1),
                                true, false, false);
   child2_layer->SetDrawsContent(true);
 
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_layer);
 
   EXPECT_FLOAT_EQ(1.f, root_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(3.f, child1_layer->GetIdealContentsScale());
-  EXPECT_FLOAT_EQ(3.f, child1_layer->mask_layer()->GetIdealContentsScale());
+  EXPECT_FLOAT_EQ(
+      3.f,
+      child1_layer->test_properties()->mask_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(5.f, child2_layer->GetIdealContentsScale());
 
   EXPECT_FLOAT_EQ(
       0.f, root_layer->draw_properties().maximum_animation_contents_scale);
   EXPECT_FLOAT_EQ(
       0.f, child1_layer->draw_properties().maximum_animation_contents_scale);
-  EXPECT_FLOAT_EQ(0.f,
-                  child1_layer->mask_layer()
-                      ->draw_properties()
-                      .maximum_animation_contents_scale);
-  EXPECT_FLOAT_EQ(0.f,
-                  child1_layer->replica_layer()
-                      ->mask_layer()
-                      ->draw_properties()
-                      .maximum_animation_contents_scale);
   EXPECT_FLOAT_EQ(
       8.f, child2_layer->draw_properties().maximum_animation_contents_scale);
 
   // Changing page-scale would affect ideal_contents_scale and
   // maximum_animation_contents_scale.
 
   float page_scale_factor = 3.f;
   float device_scale_factor = 1.0f;
   std::vector<LayerImpl*> render_surface_layer_list;
   gfx::Size device_viewport_size =
       gfx::Size(root_layer->bounds().width() * device_scale_factor,
                 root_layer->bounds().height() * device_scale_factor);
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, device_viewport_size, &render_surface_layer_list);
 
   inputs.page_scale_factor = page_scale_factor;
   inputs.can_adjust_raster_scales = true;
   inputs.page_scale_layer = root_layer;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   EXPECT_FLOAT_EQ(3.f, root_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(9.f, child1_layer->GetIdealContentsScale());
-  EXPECT_FLOAT_EQ(9.f, child1_layer->mask_layer()->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(
       9.f,
-      child1_layer->replica_layer()->mask_layer()->GetIdealContentsScale());
+      child1_layer->test_properties()->mask_layer->GetIdealContentsScale());
+  EXPECT_FLOAT_EQ(9.f, child1_layer->test_properties()
+                           ->replica_layer->test_properties()
+                           ->mask_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(15.f, child2_layer->GetIdealContentsScale());
 
   EXPECT_FLOAT_EQ(
       0.f, root_layer->draw_properties().maximum_animation_contents_scale);
   EXPECT_FLOAT_EQ(
       0.f, child1_layer->draw_properties().maximum_animation_contents_scale);
-  EXPECT_FLOAT_EQ(0.f,
-                  child1_layer->mask_layer()
-                      ->draw_properties()
-                      .maximum_animation_contents_scale);
-  EXPECT_FLOAT_EQ(0.f,
-                  child1_layer->replica_layer()
-                      ->mask_layer()
-                      ->draw_properties()
-                      .maximum_animation_contents_scale);
   EXPECT_FLOAT_EQ(
       24.f, child2_layer->draw_properties().maximum_animation_contents_scale);
 
   // Changing device-scale would affect ideal_contents_scale and
   // maximum_animation_contents_scale.
 
   device_scale_factor = 4.0f;
   inputs.device_scale_factor = device_scale_factor;
   inputs.can_adjust_raster_scales = true;
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   EXPECT_FLOAT_EQ(12.f, root_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(36.f, child1_layer->GetIdealContentsScale());
-  EXPECT_FLOAT_EQ(36.f, child1_layer->mask_layer()->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(
       36.f,
-      child1_layer->replica_layer()->mask_layer()->GetIdealContentsScale());
+      child1_layer->test_properties()->mask_layer->GetIdealContentsScale());
+  EXPECT_FLOAT_EQ(36.f, child1_layer->test_properties()
+                            ->replica_layer->test_properties()
+                            ->mask_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(60.f, child2_layer->GetIdealContentsScale());
 
   EXPECT_FLOAT_EQ(
       0.f, root_layer->draw_properties().maximum_animation_contents_scale);
   EXPECT_FLOAT_EQ(
       0.f, child1_layer->draw_properties().maximum_animation_contents_scale);
-  EXPECT_FLOAT_EQ(0.f,
-                  child1_layer->mask_layer()
-                      ->draw_properties()
-                      .maximum_animation_contents_scale);
-  EXPECT_FLOAT_EQ(0.f,
-                  child1_layer->replica_layer()
-                      ->mask_layer()
-                      ->draw_properties()
-                      .maximum_animation_contents_scale);
   EXPECT_FLOAT_EQ(
       96.f, child2_layer->draw_properties().maximum_animation_contents_scale);
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectInChildRenderSurface) {
   LayerImpl* root = root_layer();
   LayerImpl* clip = AddChild<LayerImpl>(root);
   LayerImpl* content = AddChild<LayerImpl>(clip);
 
   const gfx::Transform identity_matrix;
@@ skipping 1684 matching lines @@
   EXPECT_EQ(gfx::Rect(-10, -10, 30, 30), render_surface2->clip_rect());
   // A clip node is created for every render surface and for layers that have
   // local clip. So, here it should be craeted for every layer.
   EXPECT_EQ(root->layer_tree_impl()->property_trees()->clip_tree.size(), 5u);
 }
 
 TEST_F(LayerTreeHostCommonTest, MaskLayerDrawProperties) {
   // Tests that a mask layer's draw properties are computed correctly.
   LayerImpl* root = root_layer();
   LayerImpl* child = AddChild<LayerImpl>(root);
-  child->SetMaskLayer(LayerImpl::Create(root->layer_tree_impl(), 100));
+  child->test_properties()->SetMaskLayer(
+      LayerImpl::Create(root->layer_tree_impl(), 100));
+  LayerImpl* mask = child->test_properties()->mask_layer;
 
   const gfx::Transform identity_matrix;
   gfx::Transform transform;
   transform.Translate(10, 10);
 
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(40, 40), true, false,
                                true);
   SetLayerPropertiesForTesting(child, transform, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(30, 30), true, false, false);
-  SetLayerPropertiesForTesting(child->mask_layer(), identity_matrix,
-                               gfx::Point3F(), gfx::PointF(), gfx::Size(20, 20),
-                               true, false, false);
+  SetLayerPropertiesForTesting(mask, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(20, 20), true, false,
+                               false);
   root->SetDrawsContent(true);
   child->SetDrawsContent(false);
   ExecuteCalculateDrawProperties(root);
 
   // The render surface created for the mask has no contributing content, so the
   // mask isn't a drawn RSLL member. This means it has an empty visible rect,
   // but its screen space transform can still be computed correctly on-demand.
-  EXPECT_FALSE(
-      child->mask_layer()->is_drawn_render_surface_layer_list_member());
-  EXPECT_EQ(gfx::Rect(), child->mask_layer()->visible_layer_rect());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(transform,
-                                  child->mask_layer()->ScreenSpaceTransform());
+  EXPECT_FALSE(mask->is_drawn_render_surface_layer_list_member());
+  EXPECT_EQ(gfx::Rect(), mask->visible_layer_rect());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(transform, mask->ScreenSpaceTransform());
 
   // Make the child's render surface have contributing content.
   child->SetDrawsContent(true);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
-  EXPECT_TRUE(child->mask_layer()->is_drawn_render_surface_layer_list_member());
-  EXPECT_EQ(gfx::Rect(20, 20), child->mask_layer()->visible_layer_rect());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(transform,
-                                  child->mask_layer()->ScreenSpaceTransform());
+  EXPECT_TRUE(mask->is_drawn_render_surface_layer_list_member());
+  EXPECT_EQ(gfx::Rect(20, 20), mask->visible_layer_rect());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(transform, mask->ScreenSpaceTransform());
 
   transform.Translate(10, 10);
   child->SetTransform(transform);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
-  EXPECT_TRANSFORMATION_MATRIX_EQ(transform,
-                                  child->mask_layer()->ScreenSpaceTransform());
-  EXPECT_EQ(gfx::Rect(20, 20), child->mask_layer()->visible_layer_rect());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(transform, mask->ScreenSpaceTransform());
+  EXPECT_EQ(gfx::Rect(20, 20), mask->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, ReplicaMaskLayerDrawProperties) {
   // Tests that a replica mask layer's draw properties are computed correctly.
   LayerImpl* root = root_layer();
   LayerImpl* child = AddChild<LayerImpl>(root);
-  child->SetReplicaLayer(LayerImpl::Create(root->layer_tree_impl(), 100));
-  child->replica_layer()->SetParent(child);
-  child->replica_layer()->SetMaskLayer(
+  child->test_properties()->SetReplicaLayer(
+      LayerImpl::Create(root->layer_tree_impl(), 100));
+  LayerImpl* replica = child->test_properties()->replica_layer;
+  replica->SetParent(child);
+  replica->test_properties()->SetMaskLayer(
       LayerImpl::Create(root->layer_tree_impl(), 200));
+  LayerImpl* replica_mask = replica->test_properties()->mask_layer;
 
   const gfx::Transform identity_matrix;
   gfx::Transform transform;
   transform.Translate(10, 10);
 
   gfx::PointF replica_position(3.f, 3.f);
 
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(40, 40), true, false,
                                true);
   SetLayerPropertiesForTesting(child, transform, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(30, 30), true, false, false);
-  SetLayerPropertiesForTesting(child->replica_layer(), identity_matrix,
-                               gfx::Point3F(), replica_position,
-                               gfx::Size(30, 30), true, false, false);
-  SetLayerPropertiesForTesting(child->replica_layer()->mask_layer(),
-                               identity_matrix, gfx::Point3F(), gfx::PointF(),
-                               gfx::Size(20, 20), true, false, false);
+  SetLayerPropertiesForTesting(replica, identity_matrix, gfx::Point3F(),
+                               replica_position, gfx::Size(30, 30), true, false,
+                               false);
+  SetLayerPropertiesForTesting(replica_mask, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(20, 20), true, false,
+                               false);
   root->SetDrawsContent(true);
   child->SetDrawsContent(false);
   ExecuteCalculateDrawProperties(root);
 
   // The render surface created for the replica has no contributing content, so
   // the replica's mask isn't a drawn RSLL member. This means it has an empty
   // visible rect, but its screen space transform can still be computed
   // correctly on-demand.
-  EXPECT_FALSE(child->replica_layer()
-                   ->mask_layer()
-                   ->is_drawn_render_surface_layer_list_member());
-  EXPECT_EQ(gfx::Rect(),
-            child->replica_layer()->mask_layer()->visible_layer_rect());
+  EXPECT_FALSE(replica_mask->is_drawn_render_surface_layer_list_member());
+  EXPECT_EQ(gfx::Rect(), replica_mask->visible_layer_rect());
 
   gfx::Transform expected_screen_space_transform = transform;
   expected_screen_space_transform.Translate(replica_position.x(),
                                             replica_position.y());
 
-  EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected_screen_space_transform,
-      child->replica_layer()->mask_layer()->ScreenSpaceTransform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(expected_screen_space_transform,
+                                  replica_mask->ScreenSpaceTransform());
 
   // Make the child's render surface have contributing content.
   child->SetDrawsContent(true);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
-  EXPECT_TRUE(child->replica_layer()
-                  ->mask_layer()
-                  ->is_drawn_render_surface_layer_list_member());
-  EXPECT_EQ(gfx::Rect(20, 20),
-            child->replica_layer()->mask_layer()->visible_layer_rect());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected_screen_space_transform,
-      child->replica_layer()->mask_layer()->ScreenSpaceTransform());
+  EXPECT_TRUE(replica_mask->is_drawn_render_surface_layer_list_member());
+  EXPECT_EQ(gfx::Rect(20, 20), replica_mask->visible_layer_rect());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(expected_screen_space_transform,
+                                  replica_mask->ScreenSpaceTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        SublayerScaleWithTransformNodeBetweenTwoTargets) {
   LayerImpl* root = root_layer();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
   LayerImpl* between_targets = AddChild<LayerImpl>(render_surface1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(between_targets);
   LayerImpl* test_layer = AddChild<LayerImpl>(render_surface2);
   const gfx::Transform identity_matrix;
@@ skipping 473 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