cc : Stop pushing properties not used by LayerImpl to LayerImpl (4)

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 3801 matching lines @@
   EXPECT_EQ(gfx::Rect(100, 100), render_surface2->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipChildWithSingularTransform) {
   LayerImpl* root = root_layer();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* intervening = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(intervening);
 
   clip_child->SetDrawsContent(true);
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
-  clip_parent->SetClipChildren(clip_children.release());
+  clip_parent->test_properties()->clip_children.reset(clip_children.release());
 
   gfx::Transform identity_matrix;
   gfx::Transform singular_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
   ASSERT_FALSE(singular_matrix.IsInvertible());
 
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                true);
   SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
@@ skipping 13 matching lines @@
        VisibleRectsWhenClipChildIsBetweenTwoRenderSurfaces) {
   LayerImpl* root = root_layer();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(clip_child);
 
   render_surface1->SetDrawsContent(true);
   render_surface2->SetDrawsContent(true);
   clip_child->SetDrawsContent(true);
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
-  clip_parent->SetClipChildren(clip_children.release());
+  clip_parent->test_properties()->clip_children.reset(clip_children.release());
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                true);
   SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
   SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(20, 20), true, false,
@@ skipping 16 matching lines @@
 TEST_F(LayerTreeHostCommonTest, ClipRectOfSurfaceWhoseParentIsAClipChild) {
   LayerImpl* root = root_layer();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(clip_child);
 
   render_surface1->SetDrawsContent(true);
   render_surface2->SetDrawsContent(true);
   clip_child->SetDrawsContent(true);
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
-  clip_parent->SetClipChildren(clip_children.release());
+  clip_parent->test_properties()->clip_children.reset(clip_children.release());
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                true);
   SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(2.f, 2.f), gfx::Size(50, 50), true,
                                false, false);
   SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(20, 20), true, false,
@@ skipping 46 matching lines @@
   LayerImpl* root = root_layer();
   LayerImpl* unclipped_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* clip_parent = AddChild<LayerImpl>(unclipped_surface);
   LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(unclipped_desc_surface);
   LayerImpl* clipped_surface = AddChild<LayerImpl>(clip_child);
 
   unclipped_surface->SetDrawsContent(true);
   unclipped_desc_surface->SetDrawsContent(true);
   clipped_surface->SetDrawsContent(true);
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
-  clip_parent->SetClipChildren(clip_children.release());
+  clip_parent->test_properties()->clip_children.reset(clip_children.release());
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                true);
   SetLayerPropertiesForTesting(unclipped_surface, identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false, true);
   SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
@@ skipping 22 matching lines @@
   LayerImpl* root = root_layer();
   LayerImpl* unclipped_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* clip_parent = AddChild<LayerImpl>(unclipped_surface);
   LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(unclipped_desc_surface);
   LayerImpl* clipped_surface = AddChild<LayerImpl>(clip_child);
 
   unclipped_surface->SetDrawsContent(true);
   unclipped_desc_surface->SetDrawsContent(true);
   clipped_surface->SetDrawsContent(true);
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
-  clip_parent->SetClipChildren(clip_children.release());
+  clip_parent->test_properties()->clip_children.reset(clip_children.release());
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                true);
   SetLayerPropertiesForTesting(unclipped_surface, identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
                                true, false, true);
   SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
@@ skipping 1869 matching lines @@
   // The render surface should be resized correctly and the clip child should
   // inherit the right clip rect.
   LayerImpl* root = root_layer();
   LayerImpl* render_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* clip_parent = AddChild<LayerImpl>(render_surface);
   clip_parent->SetDrawsContent(true);
   LayerImpl* intervening = AddChild<LayerImpl>(clip_parent);
   intervening->SetDrawsContent(true);
   LayerImpl* clip_child = AddChild<LayerImpl>(intervening);
   clip_child->SetDrawsContent(true);
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
-  clip_parent->SetClipChildren(clip_children.release());
+  clip_parent->test_properties()->clip_children.reset(clip_children.release());
 
   intervening->SetMasksToBounds(true);
   clip_parent->SetMasksToBounds(true);
 
   gfx::Transform scale_transform;
   scale_transform.Scale(2, 2);
 
   gfx::Transform identity_transform;
 
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
@@ skipping 51 matching lines @@
   LayerImpl* root = root_layer();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_parent);
   LayerImpl* intervening = AddChild<LayerImpl>(render_surface1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(intervening);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface2);
   render_surface1->SetDrawsContent(true);
   render_surface2->SetDrawsContent(true);
   clip_child->SetDrawsContent(true);
 
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
 
   intervening->SetMasksToBounds(true);
   clip_parent->SetMasksToBounds(true);
 
   gfx::Transform translation_transform;
   translation_transform.Translate(2, 2);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
@@ skipping 68 matching lines @@
   LayerImpl* root = root_layer();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_parent);
   LayerImpl* intervening = AddChild<LayerImpl>(render_surface1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(intervening);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface2);
   render_surface1->SetDrawsContent(true);
   render_surface2->SetDrawsContent(true);
   clip_child->SetDrawsContent(true);
 
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
 
   intervening->SetMasksToBounds(true);
   clip_parent->SetMasksToBounds(true);
   intervening->SetScrollClipLayer(clip_parent->id());
   intervening->SetCurrentScrollOffset(gfx::ScrollOffset(3, 3));
 
   gfx::Transform translation_transform;
   translation_transform.Translate(2, 2);
 
   gfx::Transform identity_transform;
@@ skipping 65 matching lines @@
   //          + child
   //
   LayerImpl* root = root_layer();
   LayerImpl* clip_parent = AddChild<LayerImpl>(root);
   LayerImpl* intervening = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(intervening);
   LayerImpl* child = AddChild<LayerImpl>(clip_child);
   clip_child->SetDrawsContent(true);
   child->SetDrawsContent(true);
 
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
-  clip_parent->SetClipChildren(clip_children.release());
+  clip_parent->test_properties()->clip_children.reset(clip_children.release());
 
   intervening->SetMasksToBounds(true);
   clip_parent->SetMasksToBounds(true);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   SetLayerPropertiesForTesting(clip_parent, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(40, 40), true, false,
@@ skipping 37 matching lines @@
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_parent);
   render_surface1->SetDrawsContent(true);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface1);
   clip_child->SetDrawsContent(true);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(clip_parent);
   render_surface2->SetDrawsContent(true);
   LayerImpl* non_clip_child = AddChild<LayerImpl>(render_surface2);
   non_clip_child->SetDrawsContent(true);
 
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
-  clip_parent->SetClipChildren(clip_children.release());
+  clip_parent->test_properties()->clip_children.reset(clip_children.release());
 
   clip_parent->SetMasksToBounds(true);
   render_surface1->SetMasksToBounds(true);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(15, 15), true, false,
                                true);
   SetLayerPropertiesForTesting(clip_parent, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
@@ skipping 379 matching lines @@
   LayerImpl* root = root_layer();
   LayerImpl* scroll_parent_border = AddChildToRoot<LayerImpl>();
   LayerImpl* scroll_parent_clip = AddChild<LayerImpl>(scroll_parent_border);
   LayerImpl* scroll_parent = AddChild<LayerImpl>(scroll_parent_clip);
   LayerImpl* scroll_child = AddChild<LayerImpl>(root);
 
   scroll_parent->SetDrawsContent(true);
   scroll_child->SetDrawsContent(true);
   scroll_parent_clip->SetMasksToBounds(true);
 
-  scroll_child->SetScrollParent(scroll_parent);
+  scroll_child->test_properties()->scroll_parent = scroll_parent;
   std::unique_ptr<std::set<LayerImpl*>> scroll_children(
       new std::set<LayerImpl*>);
   scroll_children->insert(scroll_child);
-  scroll_parent->SetScrollChildren(scroll_children.release());
+  scroll_parent->test_properties()->scroll_children.reset(
+      scroll_children.release());
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   SetLayerPropertiesForTesting(scroll_parent_border, identity_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
                                true, false, false);
   SetLayerPropertiesForTesting(scroll_parent_clip, identity_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
@@ skipping 18 matching lines @@
   // target is different from its scroll parent's target.
   LayerImpl* root = root_layer();
   LayerImpl* scroll_child_target = AddChildToRoot<LayerImpl>();
   LayerImpl* scroll_child = AddChild<LayerImpl>(scroll_child_target);
   LayerImpl* scroll_parent_target = AddChild<LayerImpl>(scroll_child_target);
   LayerImpl* scroll_parent = AddChild<LayerImpl>(scroll_parent_target);
 
   scroll_parent->SetDrawsContent(true);
   scroll_child->SetDrawsContent(true);
 
-  scroll_child->SetScrollParent(scroll_parent);
+  scroll_child->test_properties()->scroll_parent = scroll_parent;
   std::unique_ptr<std::set<LayerImpl*>> scroll_children(
       new std::set<LayerImpl*>);
   scroll_children->insert(scroll_child);
-  scroll_parent->SetScrollChildren(scroll_children.release());
+  scroll_parent->test_properties()->scroll_children.reset(
+      scroll_children.release());
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   SetLayerPropertiesForTesting(scroll_child_target, identity_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
                                true, false, true);
   SetLayerPropertiesForTesting(scroll_child, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
@@ skipping 83 matching lines @@
   LayerImpl* scroll_parent_border = AddChild<LayerImpl>(root);
   LayerImpl* scroll_parent_clip = AddChild<LayerImpl>(scroll_parent_border);
   LayerImpl* scroll_parent = AddChild<LayerImpl>(scroll_parent_clip);
   LayerImpl* scroll_child = AddChild<LayerImpl>(root);
 
   scroll_parent->SetDrawsContent(true);
   scroll_child->SetDrawsContent(true);
 
   scroll_parent_clip->SetMasksToBounds(true);
 
-  scroll_child->SetScrollParent(scroll_parent);
+  scroll_child->test_properties()->scroll_parent = scroll_parent;
   std::unique_ptr<std::set<LayerImpl*>> scroll_children(
       new std::set<LayerImpl*>);
   scroll_children->insert(scroll_child);
-  scroll_parent->SetScrollChildren(scroll_children.release());
+  scroll_parent->test_properties()->scroll_children.reset(
+      scroll_children.release());
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   SetLayerPropertiesForTesting(scroll_parent_border, identity_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
                                true, false, false);
   SetLayerPropertiesForTesting(scroll_parent_clip, identity_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
@@ skipping 36 matching lines @@
       AddChild<LayerImpl>(scroll_grandparent_border);
   LayerImpl* scroll_grandparent = AddChild<LayerImpl>(scroll_grandparent_clip);
 
   scroll_parent->SetDrawsContent(true);
   scroll_grandparent->SetDrawsContent(true);
   scroll_child->SetDrawsContent(true);
 
   scroll_parent_clip->SetMasksToBounds(true);
   scroll_grandparent_clip->SetMasksToBounds(true);
 
-  scroll_child->SetScrollParent(scroll_parent);
+  scroll_child->test_properties()->scroll_parent = scroll_parent;
   std::unique_ptr<std::set<LayerImpl*>> scroll_children(
       new std::set<LayerImpl*>);
   scroll_children->insert(scroll_child);
-  scroll_parent->SetScrollChildren(scroll_children.release());
+  scroll_parent->test_properties()->scroll_children.reset(
+      scroll_children.release());
 
-  scroll_parent_border->SetScrollParent(scroll_grandparent);
+  scroll_parent_border->test_properties()->scroll_parent = scroll_grandparent;
   scroll_children.reset(new std::set<LayerImpl*>);
   scroll_children->insert(scroll_parent_border);
-  scroll_grandparent->SetScrollChildren(scroll_children.release());
+  scroll_grandparent->test_properties()->scroll_children.reset(
+      scroll_children.release());
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   SetLayerPropertiesForTesting(scroll_grandparent_border, identity_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
                                true, false, false);
   SetLayerPropertiesForTesting(scroll_grandparent_clip, identity_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(20, 20),
@@ skipping 60 matching lines @@
   LayerImpl* render_surface1 = AddChild<LayerImpl>(scroll_grandparent);
 
   scroll_parent->SetDrawsContent(true);
   render_surface1->SetDrawsContent(true);
   scroll_grandparent->SetDrawsContent(true);
   render_surface2->SetDrawsContent(true);
 
   scroll_parent_clip->SetMasksToBounds(true);
   scroll_grandparent_clip->SetMasksToBounds(true);
 
-  scroll_child->SetScrollParent(scroll_parent);
+  scroll_child->test_properties()->scroll_parent = scroll_parent;
   std::unique_ptr<std::set<LayerImpl*>> scroll_children(
       new std::set<LayerImpl*>);
   scroll_children->insert(scroll_child);
-  scroll_parent->SetScrollChildren(scroll_children.release());
+  scroll_parent->test_properties()->scroll_children.reset(
+      scroll_children.release());
 
-  scroll_parent_border->SetScrollParent(scroll_grandparent);
+  scroll_parent_border->test_properties()->scroll_parent = scroll_grandparent;
   scroll_children.reset(new std::set<LayerImpl*>);
   scroll_children->insert(scroll_parent_border);
-  scroll_grandparent->SetScrollChildren(scroll_children.release());
+  scroll_grandparent->test_properties()->scroll_children.reset(
+      scroll_children.release());
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   SetLayerPropertiesForTesting(scroll_grandparent_border, identity_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
                                true, false, false);
   SetLayerPropertiesForTesting(scroll_grandparent_clip, identity_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(20, 20),
@@ skipping 1696 matching lines @@
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(5, 5, 5, 5), child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, UpdateScrollChildPosition) {
   LayerImpl* root = root_layer();
   LayerImpl* scroll_parent = AddChild<LayerImpl>(root);
   LayerImpl* scroll_child = AddChild<LayerImpl>(scroll_parent);
 
   scroll_child->SetDrawsContent(true);
-  scroll_child->SetScrollParent(scroll_parent);
+  scroll_child->test_properties()->scroll_parent = scroll_parent;
   std::unique_ptr<std::set<LayerImpl*>> scroll_children(
       new std::set<LayerImpl*>);
   scroll_children->insert(scroll_child);
-  scroll_parent->SetScrollChildren(scroll_children.release());
+  scroll_parent->test_properties()->scroll_children.reset(
+      scroll_children.release());
   scroll_parent->SetDrawsContent(true);
 
   gfx::Transform identity_transform;
   gfx::Transform scale;
   scale.Scale(2.f, 2.f);
   SetLayerPropertiesForTesting(root, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   SetLayerPropertiesForTesting(scroll_child, scale, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(40, 40), true, false,
@@ skipping 650 matching lines @@
   LayerImpl* render_surface =
       AddChild<LayerImpl>(between_clip_parent_and_child);
   LayerImpl* test_layer = AddChild<LayerImpl>(render_surface);
 
   const gfx::Transform identity_matrix;
   gfx::Transform translate;
   translate.Translate(2.0, 2.0);
 
   clip_parent->SetMasksToBounds(true);
   test_layer->SetDrawsContent(true);
-  render_surface->SetClipParent(clip_parent);
+  render_surface->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(render_surface);
-  clip_parent->SetClipChildren(clip_children.release());
+  clip_parent->test_properties()->clip_children.reset(clip_children.release());
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   SetLayerPropertiesForTesting(clip_parent, translate, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                false);
   SetLayerPropertiesForTesting(between_clip_parent_and_child, translate,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false, false);
   SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
@@ skipping 19 matching lines @@
   LayerImpl* root = root_layer();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface);
   LayerImpl* child = AddChild<LayerImpl>(render_surface);
 
   const gfx::Transform identity_matrix;
 
   clip_child->SetDrawsContent(true);
   child->SetDrawsContent(true);
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
-  clip_parent->SetClipChildren(clip_children.release());
+  clip_parent->test_properties()->clip_children.reset(clip_children.release());
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 10), true, false,
                                true);
   SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                false);
   SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 15), true, false,
                                true);
   SetLayerPropertiesForTesting(clip_child, identity_matrix, gfx::Point3F(),
@@ skipping 16 matching lines @@
   LayerImpl* clip_child = AddChild<LayerImpl>(test_layer1);
   LayerImpl* test_layer2 = AddChild<LayerImpl>(clip_child);
 
   const gfx::Transform identity_matrix;
   root->SetMasksToBounds(true);
   render_surface->SetMasksToBounds(true);
   render_surface->SetDrawsContent(true);
   clip_child->SetDrawsContent(true);
   test_layer1->SetDrawsContent(true);
   test_layer2->SetDrawsContent(true);
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
-  clip_parent->SetClipChildren(clip_children.release());
+  clip_parent->test_properties()->clip_children.reset(clip_children.release());
 
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                false);
   SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
@@ skipping 19 matching lines @@
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface);
 
   const gfx::Transform identity_matrix;
   clip_parent->SetDrawsContent(true);
   render_surface->SetMasksToBounds(true);
   render_surface->SetDrawsContent(true);
   clip_child->SetDrawsContent(true);
 
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
-  clip_parent->SetClipChildren(clip_children.release());
+  clip_parent->test_properties()->clip_children.reset(clip_children.release());
 
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
   SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
@@ skipping 20 matching lines @@
   LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* unclipped_desc_surface2 =
       AddChild<LayerImpl>(unclipped_desc_surface);
   LayerImpl* clip_child = AddChild<LayerImpl>(unclipped_desc_surface2);
   LayerImpl* clipped_surface = AddChild<LayerImpl>(clip_child);
 
   unclipped_surface->SetDrawsContent(true);
   unclipped_desc_surface->SetDrawsContent(true);
   unclipped_desc_surface2->SetDrawsContent(true);
   clipped_surface->SetDrawsContent(true);
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
-  clip_parent->SetClipChildren(clip_children.release());
+  clip_parent->test_properties()->clip_children.reset(clip_children.release());
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(80, 80), true, false,
                                true);
   SetLayerPropertiesForTesting(unclipped_surface, identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
                                true, false, true);
   SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
@@ skipping 30 matching lines @@
   // clips between the clip parent's target and clip child's target.
   LayerImpl* root = root_layer();
   LayerImpl* surface = AddChildToRoot<LayerImpl>();
   LayerImpl* clip_layer = AddChild<LayerImpl>(surface);
   LayerImpl* clip_parent = AddChild<LayerImpl>(clip_layer);
   LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(unclipped_desc_surface);
 
   clip_child->SetDrawsContent(true);
   unclipped_desc_surface->SetDrawsContent(true);
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
-  clip_parent->SetClipChildren(clip_children.release());
+  clip_parent->test_properties()->clip_children.reset(clip_children.release());
 
   gfx::Transform identity_matrix;
   gfx::Transform translate;
   translate.Translate(10, 10);
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                true);
   SetLayerPropertiesForTesting(surface, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                true);
@@ skipping 21 matching lines @@
 TEST_F(LayerTreeHostCommonTest, VisibleRectForDescendantOfScaledSurface) {
   LayerImpl* root = root_layer();
   LayerImpl* surface = AddChildToRoot<LayerImpl>();
   LayerImpl* clip_layer = AddChild<LayerImpl>(surface);
   LayerImpl* clip_parent = AddChild<LayerImpl>(clip_layer);
   LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(unclipped_desc_surface);
 
   clip_child->SetDrawsContent(true);
   unclipped_desc_surface->SetDrawsContent(true);
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
-  clip_parent->SetClipChildren(clip_children.release());
+  clip_parent->test_properties()->clip_children.reset(clip_children.release());
 
   gfx::Transform identity_matrix;
   gfx::Transform scale;
   scale.Scale(2, 2);
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                true);
   SetLayerPropertiesForTesting(surface, scale, gfx::Point3F(), gfx::PointF(),
                                gfx::Size(100, 100), true, false, true);
   SetLayerPropertiesForTesting(clip_layer, identity_matrix, gfx::Point3F(),
@@ skipping 47 matching lines @@
   LayerImpl* root = root_layer();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface);
 
   const gfx::Transform identity_matrix;
   clip_parent->SetMasksToBounds(true);
   render_surface->SetMasksToBounds(true);
   render_surface->SetDrawsContent(true);
   clip_child->SetDrawsContent(true);
-  clip_child->SetClipParent(clip_parent);
+  clip_child->test_properties()->clip_parent = clip_parent;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
-  clip_parent->SetClipChildren(clip_children.release());
+  clip_parent->test_properties()->clip_children.reset(clip_children.release());
 
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   SetLayerPropertiesForTesting(clip_parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(10.f, 10.f), gfx::Size(40, 40), true,
                                false, false);
   SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
@@ skipping 60 matching lines @@
   EXPECT_FALSE(test->IsHidden());
 }
 
 TEST_F(LayerTreeHostCommonTest, TwoUnclippedRenderSurfaces) {
   LayerImpl* root = root_layer();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface2);
 
   const gfx::Transform identity_matrix;
-  clip_child->SetClipParent(root);
+  clip_child->test_properties()->clip_parent = root;
   std::unique_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
-  root->SetClipChildren(clip_children.release());
+  root->test_properties()->clip_children.reset(clip_children.release());
   root->SetMasksToBounds(true);
   render_surface1->SetDrawsContent(true);
   render_surface2->SetDrawsContent(true);
 
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
                                gfx::PointF(10, 10), gfx::Size(30, 30), true,
                                false, true);
@@ skipping 363 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