cc : Delete LayerImpl::transform

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 323 matching lines @@
     root->SetDrawsContent(true);
     target->SetDrawsContent(true);
     target->SetMasksToBounds(true);
     drawing_layer->SetDrawsContent(true);
 
     root->SetBounds(gfx::Size(500, 500));
     root->test_properties()->force_render_surface = true;
     target->SetPosition(gfx::PointF(target_rect.origin()));
     target->SetBounds(target_rect.size());
     target->test_properties()->force_render_surface = true;
-    drawing_layer->SetTransform(layer_transform);
+    drawing_layer->test_properties()->transform = layer_transform;
     drawing_layer->SetPosition(gfx::PointF(layer_rect.origin()));
     drawing_layer->SetBounds(layer_rect.size());
     drawing_layer->test_properties()->should_flatten_transform = false;
 
     host_impl()->active_tree()->property_trees()->needs_rebuild = true;
     ExecuteCalculateDrawProperties(root);
 
     return drawing_layer;
   }
 };
@@ skipping 89 matching lines @@
       draw_property_utils::DrawTransform(layer, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       position_transform,
       draw_property_utils::ScreenSpaceTransform(layer, transform_tree));
 
   // Case 4: In the correct sequence of transforms, the layer transform should
   // pre-multiply the translation-to-center. This is easily tested by using a
   // scale transform, because scale and translation are not commutative.
   gfx::Transform layer_transform;
   layer_transform.Scale3d(2.0, 2.0, 1.0);
-  layer->SetTransform(layer_transform);
+  layer->test_properties()->transform = layer_transform;
   layer->test_properties()->transform_origin = gfx::Point3F();
   layer->SetPosition(gfx::PointF());
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       layer_transform,
       draw_property_utils::DrawTransform(layer, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       layer_transform,
       draw_property_utils::ScreenSpaceTransform(layer, transform_tree));
@@ skipping 93 matching lines @@
                            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);
-  scroll_layer->SetTransform(arbitrary_translate);
+  scroll_layer->test_properties()->transform = arbitrary_translate;
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_layer, kDeviceScale, page_scale,
                                  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 *
@@ skipping 81 matching lines @@
       draw_property_utils::ScreenSpaceTransform(grand_child, transform_tree));
 
   // Case 3: parent's local transform affects child and grandchild
   gfx::Transform parent_layer_transform;
   parent_layer_transform.Scale3d(2.0, 2.0, 1.0);
   gfx::Transform parent_translation_to_anchor;
   parent_translation_to_anchor.Translate(2.5, 3.0);
   gfx::Transform parent_composite_transform =
       parent_translation_to_anchor * parent_layer_transform *
       Inverse(parent_translation_to_anchor);
-  parent->SetTransform(parent_layer_transform);
+  parent->test_properties()->transform = parent_layer_transform;
   parent->SetPosition(gfx::PointF());
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_composite_transform,
       draw_property_utils::DrawTransform(child, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_composite_transform,
       draw_property_utils::ScreenSpaceTransform(child, transform_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
@@ skipping 22 matching lines @@
   gfx::Vector2dF parent_composite_scale =
       MathUtil::ComputeTransform2dScaleComponents(parent_composite_transform,
                                                   1.f);
   gfx::Transform surface_sublayer_transform;
   surface_sublayer_transform.Scale(parent_composite_scale.x(),
                                    parent_composite_scale.y());
   gfx::Transform surface_sublayer_composite_transform =
       parent_composite_transform * Inverse(surface_sublayer_transform);
 
   root->SetBounds(gfx::Size(1, 2));
-  parent->SetTransform(parent_layer_transform);
+  parent->test_properties()->transform = parent_layer_transform;
   parent->test_properties()->transform_origin = gfx::Point3F(2.5f, 30.f, 0.f);
   parent->SetBounds(gfx::Size(100, 120));
   child->SetBounds(gfx::Size(16, 18));
   child->test_properties()->force_render_surface = true;
   grand_child->SetBounds(gfx::Size(8, 10));
   grand_child->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
   // Render surface should have been created now.
   ASSERT_TRUE(child->render_surface());
@@ skipping 25 matching lines @@
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   gfx::Transform parent_transform;
   parent_transform.Translate(10.0, 10.0);
 
   gfx::Transform child_transform;
   child_transform.Rotate(45.0);
 
   root->SetBounds(gfx::Size(100, 100));
-  parent->SetTransform(parent_transform);
+  parent->test_properties()->transform = parent_transform;
   parent->SetBounds(gfx::Size(10, 10));
-  child->SetTransform(child_transform);
+  child->test_properties()->transform = child_transform;
   child->SetBounds(gfx::Size(10, 10));
   child->test_properties()->force_render_surface = true;
   grand_child->SetPosition(gfx::PointF(2.f, 2.f));
   grand_child->SetBounds(gfx::Size(20, 20));
   grand_child->SetDrawsContent(true);
 
   gfx::Transform expected_grand_child_screen_space_transform;
   expected_grand_child_screen_space_transform.Translate(10.0, 10.0);
   expected_grand_child_screen_space_transform.Rotate(45.0);
   expected_grand_child_screen_space_transform.Translate(2.0, 2.0);
@@ skipping 41 matching lines @@
                                                   1.f);
   gfx::Transform surface_sublayer_transform;
   surface_sublayer_transform.Scale(parent_composite_scale.x(),
                                    parent_composite_scale.y());
   gfx::Transform replica_composite_transform =
       parent_composite_transform * replica_layer_transform *
       Inverse(surface_sublayer_transform);
 
   root->SetBounds(gfx::Size(1, 2));
   parent->test_properties()->transform_origin = gfx::Point3F(2.5f, 3.0f, 0.f);
-  parent->SetTransform(parent_layer_transform);
+  parent->test_properties()->transform = parent_layer_transform;
   parent->SetBounds(gfx::Size(10, 12));
   child->SetBounds(gfx::Size(16, 18));
   child->test_properties()->force_render_surface = true;
   grand_child->SetPosition(gfx::PointF(-0.5f, -0.5f));
   grand_child->SetBounds(gfx::Size(1, 1));
 
-  child_replica->SetTransform(replica_layer_transform);
+  child_replica->test_properties()->transform = replica_layer_transform;
   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,
@@ skipping 81 matching lines @@
                                     surface2_parent_transform_scale.y());
 
   // SS2 = transform given to the subtree of render_surface2
   gfx::Transform SS2 = surface2_sublayer_transform;
   // S2 = transform to move from render_surface2 pixels to the layer space of
   // the owning layer
   gfx::Transform S2 = Inverse(surface2_sublayer_transform);
 
   root->SetBounds(gfx::Size(1, 2));
   parent->test_properties()->transform_origin = gfx::Point3F(2.5f, 0.f, 0.f);
-  parent->SetTransform(layer_transform);
+  parent->test_properties()->transform = layer_transform;
   parent->SetBounds(gfx::Size(10, 10));
   render_surface1->test_properties()->transform_origin =
       gfx::Point3F(2.5f, 0.f, 0.f);
-  render_surface1->SetTransform(layer_transform);
+  render_surface1->test_properties()->transform = layer_transform;
   render_surface1->SetBounds(gfx::Size(10, 10));
   render_surface1->test_properties()->force_render_surface = true;
   render_surface2->test_properties()->transform_origin =
       gfx::Point3F(2.5f, 0.f, 0.f);
-  render_surface2->SetTransform(layer_transform);
+  render_surface2->test_properties()->transform = layer_transform;
   render_surface2->SetBounds(gfx::Size(10, 10));
   render_surface2->test_properties()->force_render_surface = true;
   child_of_root->test_properties()->transform_origin =
       gfx::Point3F(2.5f, 0.f, 0.f);
-  child_of_root->SetTransform(layer_transform);
+  child_of_root->test_properties()->transform = layer_transform;
   child_of_root->SetBounds(gfx::Size(10, 10));
   child_of_rs1->test_properties()->transform_origin =
       gfx::Point3F(2.5f, 0.f, 0.f);
-  child_of_rs1->SetTransform(layer_transform);
+  child_of_rs1->test_properties()->transform = layer_transform;
   child_of_rs1->SetBounds(gfx::Size(10, 10));
   child_of_rs2->test_properties()->transform_origin =
       gfx::Point3F(2.5f, 0.f, 0.f);
-  child_of_rs2->SetTransform(layer_transform);
+  child_of_rs2->test_properties()->transform = layer_transform;
   child_of_rs2->SetBounds(gfx::Size(10, 10));
   grand_child_of_root->test_properties()->transform_origin =
       gfx::Point3F(2.5f, 0.f, 0.f);
-  grand_child_of_root->SetTransform(layer_transform);
+  grand_child_of_root->test_properties()->transform = layer_transform;
   grand_child_of_root->SetBounds(gfx::Size(10, 10));
   grand_child_of_rs1->test_properties()->transform_origin =
       gfx::Point3F(2.5f, 0.f, 0.f);
-  grand_child_of_rs1->SetTransform(layer_transform);
+  grand_child_of_rs1->test_properties()->transform = layer_transform;
   grand_child_of_rs1->SetBounds(gfx::Size(10, 10));
   grand_child_of_rs2->test_properties()->transform_origin =
       gfx::Point3F(2.5f, 0.f, 0.f);
-  grand_child_of_rs2->SetTransform(layer_transform);
+  grand_child_of_rs2->test_properties()->transform = layer_transform;
   grand_child_of_rs2->SetBounds(gfx::Size(10, 10));
   replica_of_rs1->test_properties()->transform_origin =
       gfx::Point3F(2.5f, 0.f, 0.f);
-  replica_of_rs1->SetTransform(replica_layer_transform);
+  replica_of_rs1->test_properties()->transform = replica_layer_transform;
   replica_of_rs2->test_properties()->transform_origin =
       gfx::Point3F(2.5f, 0.f, 0.f);
-  replica_of_rs2->SetTransform(replica_layer_transform);
+  replica_of_rs2->test_properties()->transform = replica_layer_transform;
 
   // We need to set parent on replica layers for property tree building.
   replica_of_rs1->test_properties()->parent = render_surface1;
   replica_of_rs2->test_properties()->parent = render_surface2;
   render_surface1->test_properties()->SetReplicaLayer(
       std::move(replica_of_rs1));
   render_surface2->test_properties()->SetReplicaLayer(
       std::move(replica_of_rs2));
   ExecuteCalculateDrawProperties(root);
 
@@ skipping 126 matching lines @@
   child->SetDrawsContent(true);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   grand_child->SetDrawsContent(true);
   LayerImpl* great_grand_child = AddChild<LayerImpl>(grand_child);
   great_grand_child->SetDrawsContent(true);
 
   gfx::Transform rotation_about_y_axis;
   rotation_about_y_axis.RotateAboutYAxis(30.0);
 
   root->SetBounds(gfx::Size(100, 100));
-  child->SetTransform(rotation_about_y_axis);
+  child->test_properties()->transform = rotation_about_y_axis;
   child->SetBounds(gfx::Size(10, 10));
   child->test_properties()->force_render_surface = true;
-  grand_child->SetTransform(rotation_about_y_axis);
+  grand_child->test_properties()->transform = rotation_about_y_axis;
   grand_child->SetBounds(gfx::Size(10, 10));
   great_grand_child->SetBounds(gfx::Size(10, 10));
 
   // No layers in this test should preserve 3d.
   ASSERT_TRUE(root->test_properties()->should_flatten_transform);
   ASSERT_TRUE(child->test_properties()->should_flatten_transform);
   ASSERT_TRUE(grand_child->test_properties()->should_flatten_transform);
   ASSERT_TRUE(great_grand_child->test_properties()->should_flatten_transform);
 
   gfx::Transform expected_child_draw_transform = rotation_about_y_axis;
@@ skipping 38 matching lines @@
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   gfx::Transform child_transform;
   child_transform.Translate(50.0, 50.0);
   child_transform.RotateAboutZAxis(30.0);
 
   gfx::Transform grand_child_transform;
   grand_child_transform.RotateAboutYAxis(90.0);
 
   root->SetBounds(gfx::Size(200, 200));
-  child->SetTransform(child_transform);
+  child->test_properties()->transform = child_transform;
   child->SetBounds(gfx::Size(10, 10));
-  grand_child->SetTransform(grand_child_transform);
+  grand_child->test_properties()->transform = grand_child_transform;
   grand_child->SetBounds(gfx::Size(100, 100));
   grand_child->test_properties()->should_flatten_transform = false;
   grand_child->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
   // Mapping grand_child's bounds to target space produces a non-empty rect
   // that is fully contained within the target's bounds, so grand_child should
   // be considered fully visible.
   EXPECT_EQ(gfx::Rect(grand_child->bounds()),
             grand_child->visible_layer_rect());
@@ skipping 34 matching lines @@
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceWithSublayerScale) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(render_surface);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   gfx::Transform translate;
   translate.Translate3d(5, 5, 5);
 
   root->SetBounds(gfx::Size(100, 100));
-  render_surface->SetTransform(translate);
+  render_surface->test_properties()->transform = translate;
   render_surface->SetBounds(gfx::Size(100, 100));
   render_surface->test_properties()->force_render_surface = true;
-  child->SetTransform(translate);
+  child->test_properties()->transform = translate;
   child->SetBounds(gfx::Size(100, 100));
-  grand_child->SetTransform(translate);
+  grand_child->test_properties()->transform = translate;
   grand_child->SetBounds(gfx::Size(100, 100));
   grand_child->SetDrawsContent(true);
 
   // render_surface will have a sublayer scale because of device scale factor.
   float device_scale_factor = 2.0f;
   LayerImplList render_surface_layer_list_impl;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root, root->bounds(), translate, &render_surface_layer_list_impl);
   inputs.device_scale_factor = device_scale_factor;
   inputs.property_trees->needs_rebuild = true;
@@ skipping 121 matching lines @@
     page_scaled_translate.Scale(page_scale_factor, page_scale_factor);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         page_scaled_translate, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         page_scaled_translate, child->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                     root->render_surface()->draw_transform());
   }
 
   // Verify that it composes correctly with transforms directly on root layer.
-  root->SetTransform(composite);
+  root->test_properties()->transform = composite;
 
   {
     LayerImplList render_surface_layer_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), composite, &render_surface_layer_list_impl);
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     gfx::Transform compositeSquared = composite;
     compositeSquared.ConcatTransform(composite);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
@@ skipping 112 matching lines @@
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceListForFilter) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child1 = AddChild<LayerImpl>(parent);
   LayerImpl* child2 = AddChild<LayerImpl>(parent);
 
   gfx::Transform scale_matrix;
   scale_matrix.Scale(2.0f, 2.0f);
 
   root->SetBounds(gfx::Size(100, 100));
-  parent->SetTransform(scale_matrix);
+  parent->test_properties()->transform = scale_matrix;
   FilterOperations filters;
   filters.Append(FilterOperation::CreateBlurFilter(10.0f));
   parent->test_properties()->filters = filters;
   parent->test_properties()->force_render_surface = true;
   child1->SetBounds(gfx::Size(25, 25));
   child1->SetDrawsContent(true);
   child1->test_properties()->force_render_surface = true;
   child2->SetPosition(gfx::PointF(25, 25));
   child2->SetBounds(gfx::Size(25, 25));
   child2->SetDrawsContent(true);
@@ skipping 208 matching lines @@
   // always flatten the target-to-screen space transform seen by descendants.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   gfx::Transform rotation_about_y_axis;
   rotation_about_y_axis.RotateAboutYAxis(30.0);
 
   root->SetBounds(gfx::Size(100, 100));
-  parent->SetTransform(rotation_about_y_axis);
+  parent->test_properties()->transform = rotation_about_y_axis;
   parent->SetBounds(gfx::Size(10, 10));
   parent->test_properties()->force_render_surface = true;
   child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
   grand_child->SetBounds(gfx::Size(10, 10));
   grand_child->SetDrawsContent(true);
   grand_child->test_properties()->should_flatten_transform = false;
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(parent->render_surface());
@@ skipping 771 matching lines @@
   grand_child_of_rs1->SetDrawsContent(true);
   render_surface2->SetDrawsContent(true);
   child_of_rs2->SetDrawsContent(true);
   grand_child_of_rs2->SetDrawsContent(true);
   child_of_root->SetDrawsContent(true);
   grand_child_of_root->SetDrawsContent(true);
 
   gfx::Transform layer_transform;
   layer_transform.Translate(1.0, 1.0);
 
-  root->SetTransform(layer_transform);
+  root->test_properties()->transform = layer_transform;
   root->SetPosition(gfx::PointF(2.5f, 0.f));
   root->SetBounds(gfx::Size(10, 10));
   root->test_properties()->transform_origin = gfx::Point3F(0.25f, 0.f, 0.f);
-  render_surface1->SetTransform(layer_transform);
+  render_surface1->test_properties()->transform = layer_transform;
   render_surface1->SetPosition(gfx::PointF(2.5f, 0.f));
   render_surface1->SetBounds(gfx::Size(10, 10));
   render_surface1->test_properties()->transform_origin =
       gfx::Point3F(0.25f, 0.f, 0.f);
   render_surface1->test_properties()->force_render_surface = true;
-  render_surface2->SetTransform(layer_transform);
+  render_surface2->test_properties()->transform = layer_transform;
   render_surface2->SetPosition(gfx::PointF(2.5f, 0.f));
   render_surface2->SetBounds(gfx::Size(10, 10));
   render_surface2->test_properties()->transform_origin =
       gfx::Point3F(0.25f, 0.f, 0.f);
   render_surface2->test_properties()->force_render_surface = true;
-  child_of_root->SetTransform(layer_transform);
+  child_of_root->test_properties()->transform = layer_transform;
   child_of_root->SetPosition(gfx::PointF(2.5f, 0.f));
   child_of_root->SetBounds(gfx::Size(10, 10));
   child_of_root->test_properties()->transform_origin =
       gfx::Point3F(0.25f, 0.f, 0.f);
-  child_of_rs1->SetTransform(layer_transform);
+  child_of_rs1->test_properties()->transform = layer_transform;
   child_of_rs1->SetPosition(gfx::PointF(2.5f, 0.f));
   child_of_rs1->SetBounds(gfx::Size(10, 10));
   child_of_rs1->test_properties()->transform_origin =
       gfx::Point3F(0.25f, 0.f, 0.f);
-  child_of_rs2->SetTransform(layer_transform);
+  child_of_rs2->test_properties()->transform = layer_transform;
   child_of_rs2->SetPosition(gfx::PointF(2.5f, 0.f));
   child_of_rs2->SetBounds(gfx::Size(10, 10));
   child_of_rs2->test_properties()->transform_origin =
       gfx::Point3F(0.25f, 0.f, 0.f);
-  grand_child_of_root->SetTransform(layer_transform);
+  grand_child_of_root->test_properties()->transform = layer_transform;
   grand_child_of_root->SetPosition(gfx::PointF(2.5f, 0.f));
   grand_child_of_root->SetBounds(gfx::Size(10, 10));
   grand_child_of_root->test_properties()->transform_origin =
       gfx::Point3F(0.25f, 0.f, 0.f);
-  grand_child_of_rs1->SetTransform(layer_transform);
+  grand_child_of_rs1->test_properties()->transform = layer_transform;
   grand_child_of_rs1->SetPosition(gfx::PointF(2.5f, 0.f));
   grand_child_of_rs1->SetBounds(gfx::Size(10, 10));
   grand_child_of_rs1->test_properties()->transform_origin =
       gfx::Point3F(0.25f, 0.f, 0.f);
-  grand_child_of_rs2->SetTransform(layer_transform);
+  grand_child_of_rs2->test_properties()->transform = layer_transform;
   grand_child_of_rs2->SetPosition(gfx::PointF(2.5f, 0.f));
   grand_child_of_rs2->SetBounds(gfx::Size(10, 10));
   grand_child_of_rs2->test_properties()->transform_origin =
       gfx::Point3F(0.25f, 0.f, 0.f);
 
   root->layer_tree_impl()->BuildLayerListAndPropertyTreesForTesting();
   SetElementIdsForTesting();
 
   // Put an animated opacity on the render surface.
   AddOpacityTransitionToElementWithPlayer(
@@ skipping 84 matching lines @@
 
 TEST_F(LayerTreeHostCommonTest, LargeTransforms) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   gfx::Transform large_transform;
   large_transform.Scale(SkDoubleToMScalar(1e37), SkDoubleToMScalar(1e37));
 
   root->SetBounds(gfx::Size(10, 10));
-  child->SetTransform(large_transform);
+  child->test_properties()->transform = large_transform;
   child->SetBounds(gfx::Size(10, 10));
-  grand_child->SetTransform(large_transform);
+  grand_child->test_properties()->transform = large_transform;
   grand_child->SetBounds(gfx::Size(10, 10));
   grand_child->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(), grand_child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        ScreenSpaceTransformIsAnimatingWithDelayedAnimation) {
   LayerImpl* root = root_layer_for_testing();
@@ skipping 436 matching lines @@
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   gfx::Transform child_scale_matrix;
   child_scale_matrix.Scale(0.25f, 0.25f);
   gfx::Transform grand_child_scale_matrix;
   grand_child_scale_matrix.Scale(0.246f, 0.246f);
 
   root->SetBounds(gfx::Size(100, 100));
-  child->SetTransform(child_scale_matrix);
+  child->test_properties()->transform = child_scale_matrix;
   child->SetBounds(gfx::Size(10, 10));
   child->SetMasksToBounds(true);
-  grand_child->SetTransform(grand_child_scale_matrix);
+  grand_child->test_properties()->transform = grand_child_scale_matrix;
   grand_child->SetBounds(gfx::Size(100, 100));
   grand_child->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
   // The visible rect is expanded to integer coordinates.
   EXPECT_EQ(gfx::Rect(41, 41), grand_child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsForLayersInUnclippedRenderSurface) {
@@ skipping 268 matching lines @@
 
   root->SetBounds(gfx::Size(100, 100));
   child->SetPosition(gfx::PointF(5.f, 5.f));
   child->SetBounds(gfx::Size(50, 50));
   child->SetDrawsContent(true);
 
   // Case 1: a truly degenerate matrix
   gfx::Transform uninvertible_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
 
-  child->SetTransform(uninvertible_matrix);
+  child->test_properties()->transform = uninvertible_matrix;
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(child->visible_layer_rect().IsEmpty());
   EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
 
   // Case 2: a matrix with flattened z, uninvertible and not visible according
   // to the CSS spec.
   uninvertible_matrix.MakeIdentity();
   uninvertible_matrix.matrix().set(2, 2, 0.0);
   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
 
-  child->SetTransform(uninvertible_matrix);
+  child->test_properties()->transform = uninvertible_matrix;
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(child->visible_layer_rect().IsEmpty());
   EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
 
   // Case 3: a matrix with flattened z, also uninvertible and not visible.
   uninvertible_matrix.MakeIdentity();
   uninvertible_matrix.Translate(500.0, 0.0);
   uninvertible_matrix.matrix().set(2, 2, 0.0);
   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
 
-  child->SetTransform(uninvertible_matrix);
+  child->test_properties()->transform = uninvertible_matrix;
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(child->visible_layer_rect().IsEmpty());
   EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleContentRectForLayerWithUninvertibleDrawTransform) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   gfx::Transform perspective;
   perspective.ApplyPerspectiveDepth(SkDoubleToMScalar(1e-12));
 
   gfx::Transform rotation;
   rotation.RotateAboutYAxis(45.0);
 
   root->SetBounds(gfx::Size(100, 100));
-  child->SetTransform(perspective);
+  child->test_properties()->transform = perspective;
   child->SetPosition(gfx::PointF(10.f, 10.f));
   child->SetBounds(gfx::Size(100, 100));
   child->SetDrawsContent(true);
   child->Set3dSortingContextId(1);
   child->test_properties()->should_flatten_transform = false;
-  grand_child->SetTransform(rotation);
+  grand_child->test_properties()->transform = rotation;
   grand_child->SetBounds(gfx::Size(100, 100));
   grand_child->SetDrawsContent(true);
   grand_child->Set3dSortingContextId(1);
   grand_child->test_properties()->should_flatten_transform = false;
   ExecuteCalculateDrawProperties(root);
 
   // Though all layers have invertible transforms, matrix multiplication using
   // floating-point math makes the draw transform uninvertible.
   EXPECT_FALSE(root->layer_tree_impl()
                    ->property_trees()
@@ skipping 34 matching lines @@
   surface->SetContentsOpaque(true);
   surface_child->SetContentsOpaque(true);
   surface_sibling->SetContentsOpaque(true);
   surface_child_mask->SetContentsOpaque(true);
 
   gfx::Transform translate;
   translate.Translate(20.f, 20.f);
 
   root->SetBounds(gfx::Size(1000, 1000));
   child->SetBounds(gfx::Size(300, 300));
-  surface->SetTransform(translate);
+  surface->test_properties()->transform = translate;
   surface->SetBounds(gfx::Size(300, 300));
   surface->test_properties()->force_render_surface = true;
   surface_child->SetBounds(gfx::Size(300, 300));
   surface_child->test_properties()->force_render_surface = true;
   surface_sibling->SetBounds(gfx::Size(200, 200));
 
   LayerImpl* surface_ptr = surface.get();
   LayerImpl* surface_child_ptr = surface_child.get();
   LayerImpl* surface_child_mask_ptr = surface_child_mask.get();
 
@@ skipping 46 matching lines @@
   std::unique_ptr<LayerImpl> occluding_child =
       LayerImpl::Create(host_impl.active_tree(), 4);
 
   gfx::Transform perspective;
   perspective.ApplyPerspectiveDepth(SkDoubleToMScalar(1e-12));
 
   gfx::Transform rotation;
   rotation.RotateAboutYAxis(45.0);
 
   root->SetBounds(gfx::Size(1000, 1000));
-  child->SetTransform(perspective);
+  child->test_properties()->transform = perspective;
   child->SetPosition(gfx::PointF(10.f, 10.f));
   child->SetBounds(gfx::Size(300, 300));
   child->test_properties()->should_flatten_transform = false;
   child->Set3dSortingContextId(1);
-  grand_child->SetTransform(rotation);
+  grand_child->test_properties()->transform = rotation;
   grand_child->SetBounds(gfx::Size(200, 200));
   grand_child->test_properties()->should_flatten_transform = false;
   grand_child->Set3dSortingContextId(1);
   occluding_child->SetBounds(gfx::Size(200, 200));
   occluding_child->test_properties()->should_flatten_transform = false;
 
   child->SetDrawsContent(true);
   grand_child->SetDrawsContent(true);
   occluding_child->SetDrawsContent(true);
   occluding_child->SetContentsOpaque(true);
@@ skipping 350 matching lines @@
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* child1 = AddChild<LayerImpl>(render_surface);
 
   gfx::Transform child_rotation;
   child_rotation.Rotate(45.0);
 
   root->SetBounds(gfx::Size(100, 100));
   render_surface->SetBounds(gfx::Size(3, 4));
   render_surface->test_properties()->force_render_surface = true;
-  child1->SetTransform(child_rotation);
+  child1->test_properties()->transform = child_rotation;
   child1->SetPosition(gfx::PointF(25.f, 25.f));
   child1->SetBounds(gfx::Size(50, 50));
   child1->SetDrawsContent(true);
   child1->test_properties()->transform_origin = gfx::Point3F(25.f, 25.f, 0.f);
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(render_surface->render_surface());
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
@@ skipping 29 matching lines @@
   gfx::Transform child_rotation;
   child_rotation.Rotate(45.0);
 
   root->SetBounds(gfx::Size(50, 50));
   root->SetMasksToBounds(true);
   render_surface->SetBounds(gfx::Size(3, 4));
   render_surface->test_properties()->force_render_surface = true;
   child1->SetPosition(gfx::PointF(25.f, 25.f));
   child1->SetBounds(gfx::Size(50, 50));
   child1->SetDrawsContent(true);
-  child1->SetTransform(child_rotation);
+  child1->test_properties()->transform = child_rotation;
   child1->test_properties()->transform_origin = gfx::Point3F(25.f, 25.f, 0.f);
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(render_surface->render_surface());
 
   // The clipped surface clamps the DrawableContentRect that encloses the
   // rotated layer.
   int diagonal_radius = ceil(sqrt(2.0) * 25.0);
   gfx::Rect unclipped_surface_content = gfx::Rect(50 - diagonal_radius,
                                                   50 - diagonal_radius,
@@ skipping 133 matching lines @@
   front_facing_surface->SetBounds(gfx::Size(100, 100));
   back_facing_surface->SetBounds(gfx::Size(100, 100));
   front_facing_child_of_front_facing_surface->SetBounds(gfx::Size(100, 100));
   back_facing_child_of_front_facing_surface->SetBounds(gfx::Size(100, 100));
   front_facing_child_of_back_facing_surface->SetBounds(gfx::Size(100, 100));
   back_facing_child_of_back_facing_surface->SetBounds(gfx::Size(100, 100));
 
   front_facing_surface->test_properties()->force_render_surface = true;
   back_facing_surface->test_properties()->force_render_surface = true;
 
-  back_facing_child->SetTransform(backface_matrix);
-  back_facing_surface->SetTransform(backface_matrix);
-  back_facing_child_of_front_facing_surface->SetTransform(backface_matrix);
-  back_facing_child_of_back_facing_surface->SetTransform(backface_matrix);
+  back_facing_child->test_properties()->transform = backface_matrix;
+  back_facing_surface->test_properties()->transform = backface_matrix;
+  back_facing_child_of_front_facing_surface->test_properties()->transform =
+      backface_matrix;
+  back_facing_child_of_back_facing_surface->test_properties()->transform =
+      backface_matrix;
 
   // Note: No layers preserve 3d. According to current W3C CSS gfx::Transforms
   // spec, these layers should blindly use their own local transforms to
   // determine back-face culling.
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
 
   // Verify which render surfaces were created.
   EXPECT_FALSE(front_facing_child->has_render_surface());
   EXPECT_FALSE(back_facing_child->has_render_surface());
   EXPECT_TRUE(front_facing_surface->has_render_surface());
@@ skipping 72 matching lines @@
   root->SetBounds(gfx::Size(100, 100));
   front_facing_child->SetBounds(gfx::Size(100, 100));
   back_facing_child->SetBounds(gfx::Size(100, 100));
   front_facing_surface->SetBounds(gfx::Size(100, 100));
   back_facing_surface->SetBounds(gfx::Size(100, 100));
   front_facing_child_of_front_facing_surface->SetBounds(gfx::Size(100, 100));
   back_facing_child_of_front_facing_surface->SetBounds(gfx::Size(100, 100));
   front_facing_child_of_back_facing_surface->SetBounds(gfx::Size(100, 100));
   back_facing_child_of_back_facing_surface->SetBounds(gfx::Size(100, 100));
 
-  back_facing_child->SetTransform(backface_matrix);
-  back_facing_surface->SetTransform(backface_matrix);
-  back_facing_child_of_front_facing_surface->SetTransform(backface_matrix);
-  back_facing_child_of_back_facing_surface->SetTransform(backface_matrix);
+  back_facing_child->test_properties()->transform = backface_matrix;
+  back_facing_surface->test_properties()->transform = backface_matrix;
+  back_facing_child_of_front_facing_surface->test_properties()->transform =
+      backface_matrix;
+  back_facing_child_of_back_facing_surface->test_properties()->transform =
+      backface_matrix;
 
   // Each surface creates its own new 3d rendering context (as defined by W3C
   // spec).  According to current W3C CSS gfx::Transforms spec, layers in a 3d
   // rendering context should use the transform with respect to that context.
   // This 3d rendering context occurs when (a) parent's transform style is flat
   // and (b) the layer's transform style is preserve-3d.
   front_facing_surface->test_properties()->should_flatten_transform = false;
   front_facing_surface->Set3dSortingContextId(1);
   back_facing_surface->test_properties()->should_flatten_transform = false;
   back_facing_surface->Set3dSortingContextId(1);
@@ skipping 61 matching lines @@
 
   // Animate the transform on the render surface.
   AddAnimatedTransformToElementWithPlayer(animating_surface->element_id(),
                                           timeline_impl(), 10.0, 30, 0);
   // This is just an animating layer, not a surface.
   AddAnimatedTransformToElementWithPlayer(animating_child->element_id(),
                                           timeline_impl(), 10.0, 30, 0);
 
   root->SetBounds(gfx::Size(100, 100));
   child->SetBounds(gfx::Size(100, 100));
-  child->SetTransform(backface_matrix);
+  child->test_properties()->transform = backface_matrix;
   animating_surface->SetBounds(gfx::Size(100, 100));
-  animating_surface->SetTransform(backface_matrix);
+  animating_surface->test_properties()->transform = backface_matrix;
   animating_surface->test_properties()->force_render_surface = true;
   child_of_animating_surface->SetBounds(gfx::Size(100, 100));
-  child_of_animating_surface->SetTransform(backface_matrix);
+  child_of_animating_surface->test_properties()->transform = backface_matrix;
   animating_child->SetBounds(gfx::Size(100, 100));
-  animating_child->SetTransform(backface_matrix);
+  animating_child->test_properties()->transform = backface_matrix;
   child2->SetBounds(gfx::Size(100, 100));
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
 
   EXPECT_FALSE(child->has_render_surface());
   EXPECT_TRUE(animating_surface->has_render_surface());
   EXPECT_FALSE(child_of_animating_surface->has_render_surface());
   EXPECT_FALSE(animating_child->has_render_surface());
   EXPECT_FALSE(child2->has_render_surface());
 
@@ skipping 33 matching lines @@
 
   gfx::Transform backface_matrix;
   backface_matrix.Translate(50.0, 50.0);
   backface_matrix.RotateAboutYAxis(180.0);
   backface_matrix.Translate(-50.0, -50.0);
 
   root->SetBounds(gfx::Size(100, 100));
   front_facing_surface->SetBounds(gfx::Size(100, 100));
   front_facing_surface->test_properties()->force_render_surface = true;
   back_facing_surface->SetBounds(gfx::Size(100, 100));
-  back_facing_surface->SetTransform(backface_matrix);
+  back_facing_surface->test_properties()->transform = backface_matrix;
   back_facing_surface->test_properties()->force_render_surface = true;
   child1->SetBounds(gfx::Size(100, 100));
   child2->SetBounds(gfx::Size(100, 100));
 
   front_facing_surface->Set3dSortingContextId(1);
   back_facing_surface->Set3dSortingContextId(1);
 
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
 
   // Verify which render surfaces were created and used.
@@ skipping 107 matching lines @@
   LayerImpl* page_scale = AddChildToRoot<LayerImpl>();
   page_scale->SetBounds(gfx::Size(100, 100));
 
   LayerImpl* parent = AddChild<LayerImpl>(page_scale);
   parent->SetBounds(gfx::Size(100, 100));
   parent->SetDrawsContent(true);
 
   LayerImpl* perspective_surface = AddChild<LayerImpl>(parent);
   perspective_surface->SetPosition(gfx::PointF(2.f, 2.f));
   perspective_surface->SetBounds(gfx::Size(10, 10));
-  perspective_surface->SetTransform(perspective_matrix * scale_small_matrix);
+  perspective_surface->test_properties()->transform =
+      perspective_matrix * scale_small_matrix;
   perspective_surface->SetDrawsContent(true);
   perspective_surface->test_properties()->force_render_surface = true;
 
   LayerImpl* scale_surface = AddChild<LayerImpl>(parent);
   scale_surface->SetPosition(gfx::PointF(2.f, 2.f));
   scale_surface->SetBounds(gfx::Size(10, 10));
-  scale_surface->SetTransform(scale_small_matrix);
+  scale_surface->test_properties()->transform = scale_small_matrix;
   scale_surface->SetDrawsContent(true);
   scale_surface->test_properties()->force_render_surface = true;
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 3.f;
   root->layer_tree_impl()->SetViewportLayersFromIds(
       Layer::INVALID_ID, page_scale->id(), Layer::INVALID_ID,
       Layer::INVALID_ID);
   root->layer_tree_impl()->BuildLayerListAndPropertyTreesForTesting();
   root->layer_tree_impl()->SetPageScaleOnActiveTree(page_scale_factor);
@@ skipping 63 matching lines @@
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 0.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   LayerImpl* root = root_layer_for_testing();
   root->SetBounds(gfx::Size(100, 100));
 
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
   parent->SetBounds(gfx::Size(100, 100));
-  parent->SetTransform(parent_scale_matrix);
+  parent->test_properties()->transform = parent_scale_matrix;
   parent->SetDrawsContent(true);
 
   LayerImpl* child_scale = AddChild<LayerImpl>(parent);
   child_scale->SetPosition(gfx::PointF(2.f, 2.f));
   child_scale->SetBounds(gfx::Size(10, 10));
-  child_scale->SetTransform(child_scale_matrix);
+  child_scale->test_properties()->transform = child_scale_matrix;
   child_scale->SetDrawsContent(true);
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 0.01f;
 
   {
     ExecuteCalculateDrawProperties(root, device_scale_factor, page_scale_factor,
                                    root);
 
     // The ideal scale is able to go below 1.
@@ skipping 16 matching lines @@
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 1.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   LayerImpl* root = root_layer_for_testing();
   root->SetBounds(gfx::Size(100, 100));
 
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
   parent->SetBounds(gfx::Size(100, 100));
-  parent->SetTransform(parent_scale_matrix);
+  parent->test_properties()->transform = parent_scale_matrix;
   parent->SetDrawsContent(true);
 
   LayerImpl* child_scale = AddChild<LayerImpl>(parent);
   child_scale->SetBounds(gfx::Size(10, 10));
   child_scale->SetPosition(gfx::PointF(2.f, 2.f));
-  child_scale->SetTransform(child_scale_matrix);
+  child_scale->test_properties()->transform = child_scale_matrix;
   child_scale->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_FLOAT_EQ(initial_parent_scale, parent->GetIdealContentsScale());
   // Animating layers compute ideal scale in the same way as when
   // they are static.
   EXPECT_FLOAT_EQ(initial_child_scale * initial_parent_scale,
                   child_scale->GetIdealContentsScale());
 }
@@ skipping 10 matching lines @@
   child->SetPosition(gfx::PointF(2.f, 2.f));
   child->SetDrawsContent(true);
   child->test_properties()->force_render_surface = true;
 
   gfx::Transform replica_transform;
   replica_transform.Scale(1.0, -1.0);
 
   std::unique_ptr<LayerImpl> replica =
       LayerImpl::Create(host_impl()->active_tree(), 7);
   replica->SetPosition(gfx::PointF(2.f, 2.f));
-  replica->SetTransform(replica_transform);
+  replica->test_properties()->transform = replica_transform;
 
   // We need to set parent on replica layer for property tree building.
   replica->test_properties()->parent = child;
   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->SetBounds(gfx::Size(10, 10));
   duplicate_child_non_owner->SetDrawsContent(true);
@@ skipping 84 matching lines @@
 
   LayerImpl* child = AddChildToRoot<LayerImpl>();
   child->SetBounds(gfx::Size(13, 11));
   child->SetDrawsContent(true);
   child->test_properties()->force_render_surface = true;
 
   gfx::Transform replica_transform;
   replica_transform.Scale(1.0, -1.0);
   std::unique_ptr<LayerImpl> replica =
       LayerImpl::Create(host_impl()->active_tree(), 7);
-  replica->SetTransform(replica_transform);
+  replica->test_properties()->transform = replica_transform;
   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());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
@@ skipping 235 matching lines @@
 
   // Case 1: Identity transform.
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, nullptr);
   EXPECT_EQ(expect_lcd_text, root_->CanUseLCDText());
   EXPECT_EQ(expect_lcd_text, child_->CanUseLCDText());
   EXPECT_EQ(expect_lcd_text, grand_child_->CanUseLCDText());
 
   // Case 2: Integral translation.
   gfx::Transform integral_translation;
   integral_translation.Translate(1.0, 2.0);
-  child_->SetTransform(integral_translation);
+  child_->test_properties()->transform = integral_translation;
   child_->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, nullptr);
   EXPECT_EQ(expect_lcd_text, root_->CanUseLCDText());
   EXPECT_EQ(expect_lcd_text, child_->CanUseLCDText());
   EXPECT_EQ(expect_lcd_text, grand_child_->CanUseLCDText());
 
   // Case 3: Non-integral translation.
   gfx::Transform non_integral_translation;
   non_integral_translation.Translate(1.5, 2.5);
-  child_->SetTransform(non_integral_translation);
+  child_->test_properties()->transform = non_integral_translation;
   child_->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, nullptr);
   EXPECT_EQ(expect_lcd_text, root_->CanUseLCDText());
   EXPECT_EQ(expect_not_lcd_text, child_->CanUseLCDText());
   EXPECT_EQ(expect_not_lcd_text, grand_child_->CanUseLCDText());
 
   // Case 4: Rotation.
   gfx::Transform rotation;
   rotation.Rotate(10.0);
-  child_->SetTransform(rotation);
+  child_->test_properties()->transform = rotation;
   child_->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, nullptr);
   EXPECT_EQ(expect_lcd_text, root_->CanUseLCDText());
   EXPECT_EQ(expect_not_lcd_text, child_->CanUseLCDText());
   EXPECT_EQ(expect_not_lcd_text, grand_child_->CanUseLCDText());
 
   // Case 5: Scale.
   gfx::Transform scale;
   scale.Scale(2.0, 2.0);
-  child_->SetTransform(scale);
+  child_->test_properties()->transform = scale;
   child_->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, nullptr);
   EXPECT_EQ(expect_lcd_text, root_->CanUseLCDText());
   EXPECT_EQ(expect_not_lcd_text, child_->CanUseLCDText());
   EXPECT_EQ(expect_not_lcd_text, grand_child_->CanUseLCDText());
 
   // Case 6: Skew.
   gfx::Transform skew;
   skew.Skew(10.0, 0.0);
-  child_->SetTransform(skew);
+  child_->test_properties()->transform = skew;
   child_->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, nullptr);
   EXPECT_EQ(expect_lcd_text, root_->CanUseLCDText());
   EXPECT_EQ(expect_not_lcd_text, child_->CanUseLCDText());
   EXPECT_EQ(expect_not_lcd_text, grand_child_->CanUseLCDText());
 
   // Case 7: Translucent.
-  child_->SetTransform(gfx::Transform());
+  child_->test_properties()->transform = gfx::Transform();
   child_->layer_tree_impl()->property_trees()->needs_rebuild = true;
   child_->test_properties()->opacity = 0.5f;
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, nullptr);
   EXPECT_EQ(expect_lcd_text, root_->CanUseLCDText());
   EXPECT_EQ(expect_not_lcd_text, child_->CanUseLCDText());
   EXPECT_EQ(expect_not_lcd_text, grand_child_->CanUseLCDText());
 
   // Case 8: Sanity check: restore transform and opacity.
-  child_->SetTransform(gfx::Transform());
+  child_->test_properties()->transform = gfx::Transform();
   child_->layer_tree_impl()->property_trees()->needs_rebuild = true;
   child_->test_properties()->opacity = 1.f;
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, nullptr);
   EXPECT_EQ(expect_lcd_text, root_->CanUseLCDText());
   EXPECT_EQ(expect_lcd_text, child_->CanUseLCDText());
   EXPECT_EQ(expect_lcd_text, grand_child_->CanUseLCDText());
 
   // Case 9: Non-opaque content.
   child_->SetContentsOpaque(false);
   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, nullptr);
@@ skipping 470 matching lines @@
 
   intervening->SetMasksToBounds(true);
   clip_parent->SetMasksToBounds(true);
 
   gfx::Transform scale_transform;
   scale_transform.Scale(2, 2);
 
   root->SetBounds(gfx::Size(50, 50));
   render_surface->SetBounds(gfx::Size(10, 10));
   render_surface->test_properties()->force_render_surface = true;
-  clip_parent->SetTransform(scale_transform);
+  clip_parent->test_properties()->transform = scale_transform;
   clip_parent->SetPosition(gfx::PointF(1.f, 1.f));
   clip_parent->SetBounds(gfx::Size(10, 10));
   intervening->SetPosition(gfx::PointF(1.f, 1.f));
   intervening->SetBounds(gfx::Size(5, 5));
   clip_child->SetPosition(gfx::PointF(1.f, 1.f));
   clip_child->SetBounds(gfx::Size(10, 10));
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(root->render_surface());
   ASSERT_TRUE(render_surface->render_surface());
@@ skipping 123 matching lines @@
 
   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);
 
   root->SetBounds(gfx::Size(50, 50));
-  clip_parent->SetTransform(translation_transform);
+  clip_parent->test_properties()->transform = translation_transform;
   clip_parent->SetPosition(gfx::PointF(1.f, 1.f));
   clip_parent->SetBounds(gfx::Size(40, 40));
   render_surface1->SetBounds(gfx::Size(10, 10));
   render_surface1->test_properties()->force_render_surface = true;
   intervening->SetPosition(gfx::PointF(1.f, 1.f));
   intervening->SetBounds(gfx::Size(5, 5));
   render_surface2->SetBounds(gfx::Size(10, 10));
   render_surface2->test_properties()->force_render_surface = true;
   clip_child->SetPosition(gfx::PointF(-10.f, -10.f));
   clip_child->SetBounds(gfx::Size(60, 60));
@@ skipping 336 matching lines @@
                     .size());
   EXPECT_EQ(1u, render_surface_layer_list_impl()
                     ->at(1)
                     ->render_surface()
                     ->layer_list()
                     .size());
 
   gfx::Transform rotation_transform;
   rotation_transform.RotateAboutXAxis(180.0);
 
-  back_facing->SetTransform(rotation_transform);
+  back_facing->test_properties()->transform = rotation_transform;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
 
   // render_surface1 is in the same 3d rendering context as back_facing and is
   // not double sided, so it should not be in RSLL. render_surface2 is also not
   // double-sided, but will still be in RSLL as it's in a different 3d rendering
   // context.
   EXPECT_EQ(2u, render_surface_layer_list_impl()->size());
   EXPECT_EQ(1u, render_surface_layer_list_impl()
@@ skipping 32 matching lines @@
   EXPECT_FALSE(grand_child->should_check_backface_visibility());
   // As there are no 3d rendering contexts, all layers should use their local
   // transform for backface visibility.
   EXPECT_TRUE(root->use_local_transform_for_backface_visibility());
   EXPECT_TRUE(child->use_local_transform_for_backface_visibility());
   EXPECT_TRUE(grand_child->use_local_transform_for_backface_visibility());
 
   gfx::Transform rotation_transform;
   rotation_transform.RotateAboutXAxis(180.0);
 
-  child->SetTransform(rotation_transform);
+  child->test_properties()->transform = rotation_transform;
   child->Set3dSortingContextId(1);
   grand_child->Set3dSortingContextId(1);
   child->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(1u, render_surface_layer_list_impl()->size());
   EXPECT_EQ(0u, render_surface_layer_list_impl()
                     ->at(0)
                     ->render_surface()
                     ->layer_list()
@@ skipping 43 matching lines @@
   LayerImpl* back_facing = AddChild<LayerImpl>(root);
   LayerImpl* render_surface1 = AddChild<LayerImpl>(back_facing);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(back_facing);
 
   gfx::Transform rotate_about_y;
   rotate_about_y.RotateAboutYAxis(180.0);
 
   root->SetBounds(gfx::Size(50, 50));
   root->Set3dSortingContextId(1);
   root->test_properties()->should_flatten_transform = false;
-  back_facing->SetTransform(rotate_about_y);
+  back_facing->test_properties()->transform = rotate_about_y;
   back_facing->SetBounds(gfx::Size(50, 50));
   back_facing->Set3dSortingContextId(1);
   back_facing->test_properties()->should_flatten_transform = false;
   render_surface1->SetBounds(gfx::Size(30, 30));
   render_surface1->Set3dSortingContextId(1);
   render_surface1->test_properties()->should_flatten_transform = false;
   render_surface1->test_properties()->double_sided = false;
   render_surface1->test_properties()->force_render_surface = true;
   render_surface2->SetBounds(gfx::Size(30, 30));
   render_surface2->Set3dSortingContextId(1);
@@ skipping 123 matching lines @@
   child->Set3dSortingContextId(1);
   child->test_properties()->force_render_surface = true;
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(3u, render_surface_layer_list_impl()->size());
 
   gfx::Transform singular_transform;
   singular_transform.Scale3d(
       SkDoubleToMScalar(1.0), SkDoubleToMScalar(1.0), SkDoubleToMScalar(0.0));
 
-  child->SetTransform(singular_transform);
+  child->test_properties()->transform = singular_transform;
 
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(2u, render_surface_layer_list_impl()->size());
 
   // Ensure that the entire subtree under a layer with singular transform does
   // not get rendered.
-  parent->SetTransform(singular_transform);
-  child->SetTransform(gfx::Transform());
+  parent->test_properties()->transform = singular_transform;
+  child->test_properties()->transform = gfx::Transform();
 
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(1u, render_surface_layer_list_impl()->size());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClippedByOutOfOrderScrollParent) {
   // Checks that clipping by a scroll parent that follows you in paint order
   // still results in correct clipping.
@@ skipping 277 matching lines @@
   constraint.set_is_fixed_position(true);
   fixed->test_properties()->position_constraint = constraint;
 
   scroller->SetScrollClipLayer(container->id());
 
   gfx::Transform container_transform;
   container_transform.Translate3d(10.0, 20.0, 0.0);
   gfx::Vector2dF container_offset = container_transform.To2dTranslation();
 
   root->SetBounds(gfx::Size(50, 50));
-  container->SetTransform(container_transform);
+  container->test_properties()->transform = container_transform;
   container->SetBounds(gfx::Size(40, 40));
   container->SetDrawsContent(true);
   scroller->SetBounds(gfx::Size(30, 30));
   scroller->SetDrawsContent(true);
   fixed->SetBounds(gfx::Size(50, 50));
   fixed->SetDrawsContent(true);
 
   scroller->test_properties()->AddChild(std::move(fixed));
   container->test_properties()->AddChild(std::move(scroller));
   root->test_properties()->AddChild(std::move(container));
@@ skipping 45 matching lines @@
     EXPECT_VECTOR_EQ(scroll_layer->draw_properties()
                          .screen_space_transform.To2dTranslation(),
                      container_offset - rounded_scroll_delta);
   }
 
   // Scale is applied earlier in the tree.
   {
     SetScrollOffsetDelta(scroll_layer, gfx::Vector2dF());
     gfx::Transform scaled_container_transform = container_transform;
     scaled_container_transform.Scale3d(2.0, 2.0, 1.0);
-    container_layer->SetTransform(scaled_container_transform);
+    container_layer->test_properties()->transform = scaled_container_transform;
 
     root->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
     gfx::Vector2dF scroll_delta(4.5f, 8.5f);
     SetScrollOffsetDelta(scroll_layer, scroll_delta);
 
     LayerImplList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), &render_surface_layer_list);
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         container_layer->draw_properties().screen_space_transform,
         fixed_layer->draw_properties().screen_space_transform);
     EXPECT_VECTOR_EQ(
         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
         container_offset);
 
-    container_layer->SetTransform(container_transform);
+    container_layer->test_properties()->transform = container_transform;
   }
 }
 
 TEST_F(LayerTreeHostCommonTest,
        ScrollSnappingWithAnimatedScreenSpaceTransform) {
   // This test verifies that a scrolling layer whose screen space transform is
   // animating doesn't get snapped to integer coordinates.
   //
   // + root
   //   + animated layer
   //     + surface
   //       + container
   //         + scroller
   //
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* animated_layer = AddChildToRoot<FakePictureLayerImpl>();
   LayerImpl* surface = AddChild<LayerImpl>(animated_layer);
   LayerImpl* container = AddChild<LayerImpl>(surface);
   LayerImpl* scroller = AddChild<LayerImpl>(container);
 
   gfx::Transform start_scale;
   start_scale.Scale(1.5f, 1.5f);
 
   root->SetBounds(gfx::Size(50, 50));
-  animated_layer->SetTransform(start_scale);
+  animated_layer->test_properties()->transform = start_scale;
   animated_layer->SetBounds(gfx::Size(50, 50));
   surface->SetBounds(gfx::Size(50, 50));
   surface->test_properties()->force_render_surface = true;
   container->SetBounds(gfx::Size(50, 50));
   scroller->SetBounds(gfx::Size(100, 100));
   scroller->SetScrollClipLayer(container->id());
   scroller->SetDrawsContent(true);
 
   gfx::Transform end_scale;
   end_scale.Scale(2.f, 2.f);
@@ skipping 330 matching lines @@
 
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 
   AbortAnimationsOnElementWithPlayer(child_raw->element_id(), timeline,
                                      TargetProperty::TRANSFORM);
   gfx::Transform scale_matrix;
   scale_matrix.Scale(1.f, 2.f);
-  grand_parent_raw->SetTransform(scale_matrix);
-  parent_raw->SetTransform(scale_matrix);
+  grand_parent_raw->test_properties()->transform = scale_matrix;
+  parent_raw->test_properties()->transform = scale_matrix;
   grand_parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   AddAnimatedTransformToElementWithPlayer(parent_raw->element_id(), timeline,
                                           1.0, TransformOperations(), scale);
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |grand_parent| and |parent| each have scale 2.f. |parent| has a  scale
   // animation with maximum scale 5.f.
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
   EXPECT_EQ(10.f, GetMaximumAnimationScale(parent_raw));
   EXPECT_EQ(10.f, GetMaximumAnimationScale(child_raw));
   EXPECT_EQ(10.f, GetMaximumAnimationScale(grand_child_raw));
 
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
   EXPECT_EQ(2.f, GetStartingAnimationScale(parent_raw));
   EXPECT_EQ(2.f, GetStartingAnimationScale(child_raw));
   EXPECT_EQ(2.f, GetStartingAnimationScale(grand_child_raw));
 
   gfx::Transform perspective_matrix;
   perspective_matrix.ApplyPerspectiveDepth(2.f);
-  child_raw->SetTransform(perspective_matrix);
+  child_raw->test_properties()->transform = perspective_matrix;
   grand_parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |child| has a transform that's neither a translation nor a scale.
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
   EXPECT_EQ(10.f, GetMaximumAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
   EXPECT_EQ(2.f, GetStartingAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 
-  parent_raw->SetTransform(perspective_matrix);
+  parent_raw->test_properties()->transform = perspective_matrix;
   grand_parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |parent| and |child| have transforms that are neither translations nor
   // scales.
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 
-  parent_raw->SetTransform(gfx::Transform());
-  child_raw->SetTransform(gfx::Transform());
-  grand_parent_raw->SetTransform(perspective_matrix);
+  parent_raw->test_properties()->transform = gfx::Transform();
+  child_raw->test_properties()->transform = gfx::Transform();
+  grand_parent_raw->test_properties()->transform = perspective_matrix;
   grand_parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |grand_parent| has a transform that's neither a translation nor a scale.
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
@@ skipping 281 matching lines @@
   std::unique_ptr<LayerImpl> child2 =
       LayerImpl::Create(host_impl.active_tree(), 3);
   LayerImpl* child2_layer = child2.get();
 
   gfx::Transform scale_transform_child1, scale_transform_child2;
   scale_transform_child1.Scale(2, 3);
   scale_transform_child2.Scale(4, 5);
 
   root->SetBounds(gfx::Size(1, 1));
   root->SetDrawsContent(true);
-  child1_layer->SetTransform(scale_transform_child1);
+  child1_layer->test_properties()->transform = scale_transform_child1;
   child1_layer->SetBounds(gfx::Size(1, 1));
   child1_layer->SetDrawsContent(true);
 
   child1_layer->test_properties()->SetMaskLayer(
       LayerImpl::Create(host_impl.active_tree(), 4));
 
   std::unique_ptr<LayerImpl> replica_layer =
       LayerImpl::Create(host_impl.active_tree(), 5);
   replica_layer->test_properties()->SetMaskLayer(
       LayerImpl::Create(host_impl.active_tree(), 6));
   child1_layer->test_properties()->SetReplicaLayer(std::move(replica_layer));
 
   root->test_properties()->AddChild(std::move(child1));
   root->test_properties()->AddChild(std::move(child2));
   host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
   host_impl.active_tree()->SetElementIdsForTesting();
 
   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);
 
-  child2_layer->SetTransform(scale_transform_child2);
+  child2_layer->test_properties()->transform = scale_transform_child2;
   child2_layer->SetBounds(gfx::Size(1, 1));
   child2_layer->SetDrawsContent(true);
   AddAnimatedTransformToElementWithPlayer(child2_layer->element_id(), timeline,
                                           1.0, TransformOperations(), scale);
 
   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());
@@ skipping 84 matching lines @@
   child1_layer->test_properties()->AddChild(std::move(child2));
   host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
 
   host_impl.active_tree()->SetElementIdsForTesting();
 
   gfx::Transform scale_transform_child1, scale_transform_child2;
   scale_transform_child1.Scale(2, 3);
   scale_transform_child2.Scale(4, 5);
 
   root_layer->SetBounds(gfx::Size(1, 1));
-  child1_layer->SetTransform(scale_transform_child1);
+  child1_layer->test_properties()->transform = scale_transform_child1;
   child1_layer->SetBounds(gfx::Size(1, 1));
-  child2_layer->SetTransform(scale_transform_child2);
+  child2_layer->test_properties()->transform = scale_transform_child2;
   child2_layer->SetBounds(gfx::Size(1, 1));
 
   TransformOperations scale;
   scale.AppendScale(5.f, 8.f, 3.f);
 
   scoped_refptr<AnimationTimeline> timeline =
       AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
   AddAnimatedTransformToElementWithPlayer(child2_layer->element_id(), timeline,
                                           1.0, TransformOperations(), scale);
 
   // Correctly computes animation scale when rebuilding property trees.
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root_layer);
 
   EXPECT_FLOAT_EQ(0.f, GetMaximumAnimationScale(root_layer));
   EXPECT_FLOAT_EQ(0.f, GetMaximumAnimationScale(child1_layer));
   EXPECT_FLOAT_EQ(24.f, GetMaximumAnimationScale(child2_layer));
 
   EXPECT_FLOAT_EQ(0.f, GetStartingAnimationScale(root_layer));
   EXPECT_FLOAT_EQ(0.f, GetStartingAnimationScale(child1_layer));
   EXPECT_FLOAT_EQ(3.f, GetStartingAnimationScale(child2_layer));
 
   // Correctly updates animation scale when layer property changes.
-  child1_layer->SetTransform(gfx::Transform());
-  child1_layer->UpdatePropertyTreeTransform();
+  child1_layer->test_properties()->transform = gfx::Transform();
+  child1_layer->UpdatePropertyTreeTransform(gfx::Transform());
   root_layer->layer_tree_impl()->property_trees()->needs_rebuild = false;
   ExecuteCalculateDrawProperties(root_layer);
   EXPECT_FLOAT_EQ(8.f, GetMaximumAnimationScale(child2_layer));
   EXPECT_FLOAT_EQ(1.f, GetStartingAnimationScale(child2_layer));
 
   // Do not update animation scale if already updated.
   host_impl.active_tree()->property_trees()->SetAnimationScalesForTesting(
       child2_layer->transform_tree_index(), 100.f, 100.f);
   EXPECT_FLOAT_EQ(100.f, GetMaximumAnimationScale(child2_layer));
   EXPECT_FLOAT_EQ(100.f, GetStartingAnimationScale(child2_layer));
@@ skipping 20 matching lines @@
 
   root->test_properties()->AddChild(std::move(child));
   host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
 
   host_impl.active_tree()->SetElementIdsForTesting();
 
   gfx::Transform scale_transform_child;
   scale_transform_child.Scale(4, 5);
 
   root_layer->SetBounds(gfx::Size(1, 1));
-  child_layer->SetTransform(scale_transform_child);
+  child_layer->test_properties()->transform = scale_transform_child;
   child_layer->SetBounds(gfx::Size(1, 1));
 
   TransformOperations scale;
   scale.AppendScale(5.f, 8.f, 3.f);
 
   scoped_refptr<AnimationTimeline> timeline =
       AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
   AddAnimatedTransformToElementWithPlayer(child_layer->element_id(), timeline,
@@ skipping 191 matching lines @@
   animated->SetDrawsContent(true);
   surface->SetDrawsContent(true);
   descendant_of_animation->SetDrawsContent(true);
 
   gfx::Transform uninvertible_matrix;
   uninvertible_matrix.Scale3d(6.f, 6.f, 0.f);
 
   root->SetBounds(gfx::Size(100, 100));
   clip->SetBounds(gfx::Size(10, 10));
   clip->SetMasksToBounds(true);
-  animated->SetTransform(uninvertible_matrix);
+  animated->test_properties()->transform = uninvertible_matrix;
   animated->SetBounds(gfx::Size(120, 120));
   surface->SetBounds(gfx::Size(100, 100));
   surface->test_properties()->force_render_surface = true;
   descendant_of_animation->SetBounds(gfx::Size(200, 200));
 
   TransformOperations start_transform_operations;
   start_transform_operations.AppendMatrix(uninvertible_matrix);
   TransformOperations end_transform_operations;
 
   AddAnimatedTransformToElementWithPlayer(
@@ skipping 264 matching lines @@
 
 TEST_F(LayerTreeHostCommonTest, ChangeTransformOrigin) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
 
   gfx::Transform scale_matrix;
   scale_matrix.Scale(2.f, 2.f);
 
   root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
-  child->SetTransform(scale_matrix);
+  child->test_properties()->transform = scale_matrix;
   child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(10, 10), child->visible_layer_rect());
 
   child->test_properties()->transform_origin = gfx::Point3F(10.f, 10.f, 10.f);
 
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(5, 5, 5, 5), child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, UpdateScrollChildPosition) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* scroll_parent = AddChild<LayerImpl>(root);
   LayerImpl* scroll_child = AddChild<LayerImpl>(scroll_parent);
 
   gfx::Transform scale;
   scale.Scale(2.f, 2.f);
 
   root->SetBounds(gfx::Size(50, 50));
-  scroll_child->SetTransform(scale);
+  scroll_child->test_properties()->transform = scale;
   scroll_child->SetBounds(gfx::Size(40, 40));
   scroll_child->SetDrawsContent(true);
   scroll_parent->SetBounds(gfx::Size(30, 30));
   scroll_parent->SetDrawsContent(true);
 
   scroll_child->test_properties()->scroll_parent = scroll_parent;
   scroll_parent->test_properties()->scroll_children =
       base::MakeUnique<std::set<LayerImpl*>>();
   scroll_parent->test_properties()->scroll_children->insert(scroll_child);
 
@@ skipping 188 matching lines @@
   // different.
   singular.matrix().set(0, 1, 1);
 
   gfx::Transform rotate;
   rotate.Rotate(90);
 
   gfx::Transform rotate_back_and_translate;
   rotate_back_and_translate.RotateAboutYAxis(180);
   rotate_back_and_translate.Translate(-10, 0);
 
-  child_ptr->SetTransform(singular);
+  child_ptr->test_properties()->transform = singular;
   host_impl.active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
-  child_ptr->SetTransform(gfx::Transform());
+  child_ptr->test_properties()->transform = gfx::Transform();
 
   child_ptr->test_properties()->hide_layer_and_subtree = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   child_ptr->test_properties()->hide_layer_and_subtree = false;
 
   child_ptr->OnOpacityAnimated(0.f);
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   child_ptr->test_properties()->opacity = 1.f;
 
-  root_ptr->SetTransform(singular);
+  root_ptr->test_properties()->transform = singular;
   // Force transform tree to have a node for child, so that ancestor's
   // invertible transform can be tested.
-  child_ptr->SetTransform(rotate);
+  child_ptr->test_properties()->transform = rotate;
   host_impl.active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
-  root_ptr->SetTransform(gfx::Transform());
-  child_ptr->SetTransform(gfx::Transform());
+  root_ptr->test_properties()->transform = gfx::Transform();
+  child_ptr->test_properties()->transform = gfx::Transform();
 
   root_ptr->test_properties()->opacity = 0.f;
   child_ptr->test_properties()->opacity = 0.7f;
   host_impl.active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
   root_ptr->test_properties()->opacity = 1.f;
 
   child_ptr->test_properties()->opacity = 0.f;
   // Now, even though child has zero opacity, we will configure |grandchild| and
   // |greatgrandchild| in several ways that should force the subtree to be
   // processed anyhow.
   grandchild_ptr->test_properties()->copy_requests.push_back(
       CopyOutputRequest::CreateEmptyRequest());
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   host_impl.active_tree()->property_trees()->effect_tree.ClearCopyRequests();
   child_ptr->test_properties()->opacity = 1.f;
 
   // A double sided render surface with backface visible should not be skipped
   grandchild_ptr->set_visible_layer_rect(gfx::Rect());
   child_ptr->SetHasRenderSurface(true);
   child_ptr->test_properties()->double_sided = true;
-  child_ptr->SetTransform(rotate_back_and_translate);
+  child_ptr->test_properties()->transform = rotate_back_and_translate;
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
-  child_ptr->SetTransform(gfx::Transform());
+  child_ptr->test_properties()->transform = gfx::Transform();
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve(
       KeyframedTransformAnimationCurve::Create());
   TransformOperations start;
   start.AppendTranslate(1.f, 2.f, 3.f);
   gfx::Transform transform;
   transform.Scale3d(1.0, 2.0, 3.0);
   TransformOperations operation;
   operation.AppendMatrix(transform);
   curve->AddKeyframe(
       TransformKeyframe::Create(base::TimeDelta(), start, nullptr));
   curve->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(1.0), operation, nullptr));
   std::unique_ptr<Animation> transform_animation(
       Animation::Create(std::move(curve), 3, 3, TargetProperty::TRANSFORM));
   scoped_refptr<AnimationPlayer> player(AnimationPlayer::Create(1));
   host_impl.active_tree()->animation_host()->RegisterPlayerForElement(
       root_ptr->element_id(), player.get());
   host_impl.active_tree()
       ->animation_host()
       ->GetElementAnimationsForElementId(root_ptr->element_id())
       ->AddAnimation(std::move(transform_animation));
   grandchild_ptr->set_visible_layer_rect(gfx::Rect());
   child_ptr->SetScrollClipLayer(root_ptr->id());
-  root_ptr->SetTransform(singular);
-  child_ptr->SetTransform(singular);
+  root_ptr->test_properties()->transform = singular;
+  child_ptr->test_properties()->transform = singular;
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root_ptr);
   EXPECT_EQ(gfx::Rect(0, 0), grandchild_ptr->visible_layer_rect());
 
   host_impl.active_tree()->animation_host()->UnregisterPlayerForElement(
       root_ptr->element_id(), player.get());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerSkippingInSubtreeOfSingularTransform) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   SetElementIdsForTesting();
 
   gfx::Transform singular;
   singular.matrix().set(0, 0, 0);
   singular.matrix().set(0, 1, 1);
 
   root->SetBounds(gfx::Size(10, 10));
-  child->SetTransform(singular);
+  child->test_properties()->transform = singular;
   child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
   grand_child->SetBounds(gfx::Size(10, 10));
   grand_child->SetDrawsContent(true);
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve(
       KeyframedTransformAnimationCurve::Create());
   TransformOperations start;
   start.AppendTranslate(1.f, 2.f, 3.f);
   gfx::Transform transform;
@@ skipping 109 matching lines @@
 
   child->SetBounds(gfx::Size());
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
   child->SetBounds(gfx::Size(10, 10));
 
   gfx::Transform rotate;
   child->test_properties()->double_sided = false;
   rotate.RotateAboutXAxis(180.f);
-  child->SetTransform(rotate);
+  child->test_properties()->transform = rotate;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
   child->test_properties()->double_sided = true;
-  child->SetTransform(gfx::Transform());
+  child->test_properties()->transform = gfx::Transform();
 
   child->test_properties()->opacity = 0.f;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 0), child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerTreeRebuildTest) {
   // Ensure that the treewalk in LayerTreeHostCommom::
   // PreCalculateMetaInformation happens when its required.
@@ skipping 57 matching lines @@
   // formed for it.
   gfx::Transform transform1;
   transform1.RotateAboutYAxis(45);
   transform1.RotateAboutXAxis(30);
   // This transform should be a 3d transform as we want the render surface
   // to flatten the transform
   gfx::Transform transform2;
   transform2.Translate3d(10, 10, 10);
 
   root->SetBounds(gfx::Size(30, 30));
-  significant_transform->SetTransform(transform1);
+  significant_transform->test_properties()->transform = transform1;
   significant_transform->SetBounds(gfx::Size(30, 30));
   layer_clips_subtree->SetBounds(gfx::Size(30, 30));
   layer_clips_subtree->SetMasksToBounds(true);
   layer_clips_subtree->test_properties()->force_render_surface = true;
-  render_surface->SetTransform(transform2);
+  render_surface->test_properties()->transform = transform2;
   render_surface->SetBounds(gfx::Size(30, 30));
   render_surface->test_properties()->force_render_surface = true;
   test_layer->SetBounds(gfx::Size(30, 30));
   test_layer->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(root);
 
   TransformTree& transform_tree =
       root->layer_tree_impl()->property_trees()->transform_tree;
   TransformNode* transform_node =
@@ skipping 18 matching lines @@
   // target space and visible rects are calculated correctly.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_layer = AddChild<LayerImpl>(root);
   LayerImpl* target_layer = AddChild<LayerImpl>(clip_layer);
   LayerImpl* test_layer = AddChild<LayerImpl>(target_layer);
 
   gfx::Transform transform;
   transform.RotateAboutYAxis(45);
 
   root->SetBounds(gfx::Size(30, 30));
-  clip_layer->SetTransform(transform);
+  clip_layer->test_properties()->transform = transform;
   clip_layer->SetBounds(gfx::Size(30, 30));
   clip_layer->SetMasksToBounds(true);
-  target_layer->SetTransform(transform);
+  target_layer->test_properties()->transform = transform;
   target_layer->SetBounds(gfx::Size(30, 30));
   target_layer->SetMasksToBounds(true);
   test_layer->SetBounds(gfx::Size(30, 30));
   test_layer->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(30, 30), test_layer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceWithUnclippedDescendantsClipsSubtree) {
   // Ensure clip rect is calculated correctly when render surface has unclipped
   // descendants.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* between_clip_parent_and_child = AddChild<LayerImpl>(clip_parent);
   LayerImpl* render_surface =
       AddChild<LayerImpl>(between_clip_parent_and_child);
   LayerImpl* test_layer = AddChild<LayerImpl>(render_surface);
 
   gfx::Transform translate;
   translate.Translate(2.0, 2.0);
 
   root->SetBounds(gfx::Size(30, 30));
-  clip_parent->SetTransform(translate);
+  clip_parent->test_properties()->transform = translate;
   clip_parent->SetBounds(gfx::Size(30, 30));
   clip_parent->SetMasksToBounds(true);
-  between_clip_parent_and_child->SetTransform(translate);
+  between_clip_parent_and_child->test_properties()->transform = translate;
   between_clip_parent_and_child->SetBounds(gfx::Size(30, 30));
   render_surface->SetBounds(gfx::Size(30, 30));
   render_surface->test_properties()->force_render_surface = true;
   test_layer->SetBounds(gfx::Size(30, 30));
   test_layer->SetDrawsContent(true);
 
   render_surface->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
       base::MakeUnique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(render_surface);
@@ skipping 161 matching lines @@
   gfx::Transform translate;
   translate.Translate(10, 10);
 
   gfx::Transform rotate;
   rotate.RotateAboutXAxis(10);
 
   root->SetBounds(gfx::Size(100, 100));
   surface->SetBounds(gfx::Size(100, 100));
   surface->SetMasksToBounds(true);
   surface->test_properties()->force_render_surface = true;
-  surface->SetTransform(rotate);
+  surface->test_properties()->transform = rotate;
   clip_layer->SetBounds(gfx::Size(20, 20));
   clip_layer->SetMasksToBounds(true);
   clip_parent->SetBounds(gfx::Size(50, 50));
-  unclipped_desc_surface->SetTransform(translate);
+  unclipped_desc_surface->test_properties()->transform = translate;
   unclipped_desc_surface->SetBounds(gfx::Size(100, 100));
   unclipped_desc_surface->SetDrawsContent(true);
   unclipped_desc_surface->test_properties()->force_render_surface = true;
   clip_child->SetBounds(gfx::Size(100, 100));
   clip_child->SetDrawsContent(true);
 
   clip_child->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
       base::MakeUnique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
@@ skipping 10 matching lines @@
   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);
 
 
   gfx::Transform scale;
   scale.Scale(2, 2);
 
   root->SetBounds(gfx::Size(100, 100));
-  surface->SetTransform(scale);
+  surface->test_properties()->transform = scale;
   surface->SetBounds(gfx::Size(100, 100));
   surface->SetMasksToBounds(true);
   surface->test_properties()->force_render_surface = true;
   clip_layer->SetBounds(gfx::Size(20, 20));
   clip_layer->SetMasksToBounds(true);
   clip_parent->SetBounds(gfx::Size(50, 50));
   unclipped_desc_surface->SetBounds(gfx::Size(100, 100));
   unclipped_desc_surface->SetDrawsContent(true);
   unclipped_desc_surface->test_properties()->force_render_surface = true;
   clip_child->SetBounds(gfx::Size(100, 100));
@@ skipping 14 matching lines @@
   LayerImpl* render_surface = AddChild<LayerImpl>(root);
   LayerImpl* test_layer = AddChild<LayerImpl>(render_surface);
 
   gfx::Transform translation;
   translation.Translate(10, 10);
 
   root->SetBounds(gfx::Size(30, 30));
   render_surface->SetBounds(gfx::Size(30, 30));
   render_surface->SetMasksToBounds(true);
   render_surface->test_properties()->force_render_surface = true;
-  test_layer->SetTransform(translation);
+  test_layer->test_properties()->transform = translation;
   test_layer->SetBounds(gfx::Size(20, 20));
   test_layer->SetDrawsContent(true);
   test_layer->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 20, 20));
   test_layer->test_properties()->opacity = 0.f;
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(translation,
                                   test_layer->ScreenSpaceTransform());
 }
 
@@ skipping 103 matching lines @@
   LayerImpl* child = AddChild<LayerImpl>(root);
   child->test_properties()->SetMaskLayer(
       LayerImpl::Create(root->layer_tree_impl(), 100));
   LayerImpl* mask = child->test_properties()->mask_layer;
 
   gfx::Transform transform;
   transform.Translate(10, 10);
 
   root->SetBounds(gfx::Size(40, 40));
   root->SetDrawsContent(true);
-  child->SetTransform(transform);
+  child->test_properties()->transform = transform;
   child->SetBounds(gfx::Size(30, 30));
   child->SetDrawsContent(false);
   mask->SetBounds(gfx::Size(20, 20));
   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(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(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);
+  child->test_properties()->transform = transform;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   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_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   child->test_properties()->SetReplicaLayer(
       LayerImpl::Create(root->layer_tree_impl(), 100));
   LayerImpl* replica = child->test_properties()->replica_layer;
   replica->test_properties()->parent = child;
   replica->test_properties()->SetMaskLayer(
       LayerImpl::Create(root->layer_tree_impl(), 200));
   LayerImpl* replica_mask = replica->test_properties()->mask_layer;
 
   gfx::Transform transform;
   transform.Translate(10, 10);
 
   gfx::PointF replica_position(3.f, 3.f);
 
   root->SetBounds(gfx::Size(40, 40));
   root->SetDrawsContent(true);
-  child->SetTransform(transform);
+  child->test_properties()->transform = transform;
   child->SetBounds(gfx::Size(30, 30));
   replica->SetPosition(replica_position);
   replica_mask->SetBounds(gfx::Size(20, 20));
 
   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.
@@ skipping 22 matching lines @@
   LayerImpl* root = root_layer_for_testing();
   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);
 
   gfx::Transform scale;
   scale.Scale(2.f, 2.f);
 
   root->SetBounds(gfx::Size(30, 30));
-  render_surface1->SetTransform(scale);
+  render_surface1->test_properties()->transform = scale;
   render_surface1->SetBounds(gfx::Size(30, 30));
   render_surface1->test_properties()->force_render_surface = true;
   between_targets->SetBounds(gfx::Size(30, 30));
   render_surface2->SetBounds(gfx::Size(30, 30));
   render_surface2->test_properties()->force_render_surface = true;
   test_layer->SetBounds(gfx::Size(30, 30));
   test_layer->SetDrawsContent(true);
 
   // We want layer between the two targets to create a clip node and transform
   // node but it shouldn't create a render surface.
@@ skipping 32 matching lines @@
 
   root->SetBounds(gfx::Size(30, 30));
   render_surface1->SetBounds(gfx::Size(30, 30));
   render_surface1->test_properties()->force_render_surface = true;
 
   // TODO(sunxd): we make child have no render surface, because if the
   // child has one, the large transform applied to child will result in NaNs in
   // the draw_transform of the render_surface, thus make draw property updates
   // skip the child layer. We need further investigation into this to know
   // what exactly happens here.
-  child->SetTransform(large_transform);
+  child->test_properties()->transform = large_transform;
   child->SetBounds(gfx::Size(30, 30));
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::RectF(),
             render_surface1->render_surface()->DrawableContentRect());
 
   bool is_inf_or_nan = std::isinf(child->DrawTransform().matrix().get(0, 0)) ||
                        std::isnan(child->DrawTransform().matrix().get(0, 0));
   EXPECT_TRUE(is_inf_or_nan);
@@ skipping 381 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