cc : Delete LayerImpl::transform

cc/trees/layer_tree_impl_unittest.cc

 // Copyright 2014 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_impl.h"
 
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_test_common.h"
@@ skipping 54 matching lines @@
         LayerImpl::Create(host_impl().active_tree(), root_id);
     std::unique_ptr<LayerImpl> left_child =
         LayerImpl::Create(host_impl().active_tree(), left_child_id);
     std::unique_ptr<LayerImpl> right_child =
         LayerImpl::Create(host_impl().active_tree(), right_child_id);
 
     gfx::Size bounds(100, 100);
     {
       gfx::Transform translate_z;
       translate_z.Translate3d(0, 0, root_depth);
-      root->SetTransform(translate_z);
+      root->test_properties()->transform = translate_z;
       root->SetBounds(bounds);
       root->SetDrawsContent(true);
       root->Set3dSortingContextId(root_sorting_context);
     }
     {
       gfx::Transform translate_z;
       translate_z.Translate3d(0, 0, left_child_depth);
-      left_child->SetTransform(translate_z);
+      left_child->test_properties()->transform = translate_z;
       left_child->SetBounds(bounds);
       left_child->SetDrawsContent(true);
       left_child->Set3dSortingContextId(left_child_sorting_context);
       left_child->test_properties()->should_flatten_transform = false;
     }
     {
       gfx::Transform translate_z;
       translate_z.Translate3d(0, 0, right_child_depth);
-      right_child->SetTransform(translate_z);
+      right_child->test_properties()->transform = translate_z;
       right_child->SetBounds(bounds);
       right_child->SetDrawsContent(true);
       right_child->Set3dSortingContextId(right_child_sorting_context);
     }
 
     root->test_properties()->AddChild(std::move(left_child));
     root->test_properties()->AddChild(std::move(right_child));
 
     host_impl().SetViewportSize(root->bounds());
     host_impl().active_tree()->SetRootLayerForTesting(std::move(root));
@@ skipping 123 matching lines @@
 
 TEST_F(LayerTreeImplTest, HitTestingForUninvertibleTransform) {
   gfx::Transform uninvertible_transform;
   uninvertible_transform.matrix().set(0, 0, 0.0);
   uninvertible_transform.matrix().set(1, 1, 0.0);
   uninvertible_transform.matrix().set(2, 2, 0.0);
   uninvertible_transform.matrix().set(3, 3, 0.0);
   ASSERT_FALSE(uninvertible_transform.IsInvertible());
 
   LayerImpl* root = root_layer();
-  root->SetTransform(uninvertible_transform);
+  root->test_properties()->transform = uninvertible_transform;
   root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
   ASSERT_FALSE(root_layer()->ScreenSpaceTransform().IsInvertible());
 
@@ skipping 78 matching lines @@
   EXPECT_EQ(root->id(), result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitTestingForSingleRotatedLayer) {
   gfx::Transform rotation45_degrees_about_center;
   rotation45_degrees_about_center.Translate(50.0, 50.0);
   rotation45_degrees_about_center.RotateAboutZAxis(45.0);
   rotation45_degrees_about_center.Translate(-50.0, -50.0);
 
   LayerImpl* root = root_layer();
-  root->SetTransform(rotation45_degrees_about_center);
+  root->test_properties()->transform = rotation45_degrees_about_center;
   root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
@@ skipping 33 matching lines @@
 TEST_F(LayerTreeImplTest, HitTestingClipNodeDifferentTransformAndTargetIds) {
   // Tests hit testing on a layer whose clip node has different transform and
   // target id.
   LayerImpl* root = root_layer();
   root->SetBounds(gfx::Size(500, 500));
 
   gfx::Transform translation;
   translation.Translate(100, 100);
   std::unique_ptr<LayerImpl> render_surface =
       LayerImpl::Create(host_impl().active_tree(), 2);
-  render_surface->SetTransform(translation);
+  render_surface->test_properties()->transform = translation;
   render_surface->SetBounds(gfx::Size(100, 100));
   render_surface->test_properties()->force_render_surface = true;
 
   gfx::Transform scale_matrix;
   scale_matrix.Scale(2, 2);
   std::unique_ptr<LayerImpl> scale =
       LayerImpl::Create(host_impl().active_tree(), 3);
-  scale->SetTransform(scale_matrix);
+  scale->test_properties()->transform = scale_matrix;
   scale->SetBounds(gfx::Size(50, 50));
 
   std::unique_ptr<LayerImpl> clip =
       LayerImpl::Create(host_impl().active_tree(), 4);
   clip->SetBounds(gfx::Size(25, 25));
   clip->SetMasksToBounds(true);
 
   std::unique_ptr<LayerImpl> test =
       LayerImpl::Create(host_impl().active_tree(), 5);
   test->SetBounds(gfx::Size(100, 100));
@@ skipping 88 matching lines @@
   // perspective_projection_about_center * translation_by_z is designed so that
   // the 100 x 100 layer becomes 50 x 50, and remains centered at (50, 50).
   gfx::Transform perspective_projection_about_center;
   perspective_projection_about_center.Translate(50.0, 50.0);
   perspective_projection_about_center.ApplyPerspectiveDepth(1.0);
   perspective_projection_about_center.Translate(-50.0, -50.0);
   gfx::Transform translation_by_z;
   translation_by_z.Translate3d(0.0, 0.0, -1.0);
 
   LayerImpl* root = root_layer();
-  root->SetTransform(perspective_projection_about_center * translation_by_z);
+  root->test_properties()->transform =
+      (perspective_projection_about_center * translation_by_z);
   root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
@@ skipping 112 matching lines @@
     child->SetBounds(gfx::Size(80, 80));
     child->SetMasksToBounds(true);
 
     gfx::Transform rotation45_degrees_about_corner;
     rotation45_degrees_about_corner.RotateAboutZAxis(45.0);
 
     // This is positioned with respect to its parent which is already at
     // position (10, 10).
     // The size is to ensure it covers at least sqrt(2) * 100.
     grand_child->SetBounds(gfx::Size(200, 200));
-    grand_child->SetTransform(rotation45_degrees_about_corner);
+    grand_child->test_properties()->transform = rotation45_degrees_about_corner;
     grand_child->SetMasksToBounds(true);
 
     // Rotates about the center of the layer
     gfx::Transform rotated_leaf_transform;
     rotated_leaf_transform.Translate(
         -10.0, -10.0);  // cancel out the grand_parent's position
     rotated_leaf_transform.RotateAboutZAxis(
         -45.0);  // cancel out the corner 45-degree rotation of the parent.
     rotated_leaf_transform.Translate(50.0, 50.0);
     rotated_leaf_transform.RotateAboutZAxis(45.0);
     rotated_leaf_transform.Translate(-50.0, -50.0);
     rotated_leaf->SetBounds(gfx::Size(100, 100));
-    rotated_leaf->SetTransform(rotated_leaf_transform);
+    rotated_leaf->test_properties()->transform = rotated_leaf_transform;
     rotated_leaf->SetDrawsContent(true);
 
     grand_child->test_properties()->AddChild(std::move(rotated_leaf));
     child->test_properties()->AddChild(std::move(grand_child));
     root->test_properties()->AddChild(std::move(child));
 
     ExecuteCalculateDrawProperties(root);
   }
 
   host_impl().SetViewportSize(root->bounds());
@@ skipping 276 matching lines @@
     child1->SetPosition(gfx::PointF(10.f, 10.f));
     child1->SetBounds(gfx::Size(50, 50));
     child1->SetDrawsContent(true);
     child1->test_properties()->should_flatten_transform = false;
     child1->Set3dSortingContextId(1);
 
     child2->SetPosition(gfx::PointF(50.f, 10.f));
     child2->SetBounds(gfx::Size(50, 50));
     gfx::Transform translate_z;
     translate_z.Translate3d(0, 0, 10.f);
-    child2->SetTransform(translate_z);
+    child2->test_properties()->transform = translate_z;
     child2->SetDrawsContent(true);
     child2->test_properties()->should_flatten_transform = false;
     child2->Set3dSortingContextId(1);
 
     // Remember that grand_child is positioned with respect to its parent (i.e.
     // child1).  In screen space, the intended position is (10, 50), with size
     // 100 x 50.
     grand_child1->SetPosition(gfx::PointF(0.f, 40.f));
     grand_child1->SetBounds(gfx::Size(100, 50));
     grand_child1->SetDrawsContent(true);
@@ skipping 348 matching lines @@
   gfx::Transform uninvertible_transform;
   uninvertible_transform.matrix().set(0, 0, 0.0);
   uninvertible_transform.matrix().set(1, 1, 0.0);
   uninvertible_transform.matrix().set(2, 2, 0.0);
   uninvertible_transform.matrix().set(3, 3, 0.0);
   ASSERT_FALSE(uninvertible_transform.IsInvertible());
 
   Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
 
   LayerImpl* root = root_layer();
-  root->SetTransform(uninvertible_transform);
+  root->test_properties()->transform = uninvertible_transform;
   root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
   root->SetTouchEventHandlerRegion(touch_handler_region);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
@@ skipping 770 matching lines @@
   int child_id = 2;
   int grand_child_id = 3;
 
   gfx::Transform large_transform;
   large_transform.Scale(SkDoubleToMScalar(1e37), SkDoubleToMScalar(1e37));
   large_transform.RotateAboutYAxis(30);
 
   {
     std::unique_ptr<LayerImpl> child =
         LayerImpl::Create(host_impl().active_tree(), child_id);
-    child->SetTransform(large_transform);
+    child->test_properties()->transform = large_transform;
     child->SetBounds(gfx::Size(100, 100));
 
     std::unique_ptr<LayerImpl> grand_child =
         LayerImpl::Create(host_impl().active_tree(), grand_child_id);
-    grand_child->SetTransform(large_transform);
+    grand_child->test_properties()->transform = large_transform;
     grand_child->SetBounds(gfx::Size(100, 100));
     grand_child->SetDrawsContent(true);
 
     child->test_properties()->AddChild(std::move(grand_child));
     root->test_properties()->AddChild(std::move(child));
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
@@ skipping 56 matching lines @@
 
   LayerImpl* root = root_layer();
   std::unique_ptr<LayerImpl> left_child =
       LayerImpl::Create(host_impl().active_tree(), 2);
   std::unique_ptr<LayerImpl> right_child =
       LayerImpl::Create(host_impl().active_tree(), 3);
 
   {
     gfx::Transform translate_z;
     translate_z.Translate3d(0, 0, 10);
-    root->SetTransform(translate_z);
+    root->test_properties()->transform = translate_z;
     root->SetBounds(gfx::Size(100, 100));
     root->SetDrawsContent(true);
   }
   {
     gfx::Transform translate_z;
     translate_z.Translate3d(0, 0, 10);
-    left_child->SetTransform(translate_z);
+    left_child->test_properties()->transform = translate_z;
     left_child->SetBounds(gfx::Size(100, 100));
     left_child->SetDrawsContent(true);
   }
   {
     gfx::Transform translate_z;
     translate_z.Translate3d(0, 0, 10);
-    right_child->SetTransform(translate_z);
+    right_child->test_properties()->transform = translate_z;
     right_child->SetBounds(gfx::Size(100, 100));
   }
 
   root->test_properties()->AddChild(std::move(left_child));
   root->test_properties()->AddChild(std::move(right_child));
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
   CHECK_EQ(1u, RenderSurfaceLayerList().size());
 
@@ skipping 106 matching lines @@
     auto weak_promise = promise->AsWeakPtr();
     host_impl().active_tree()->QueueSwapPromise(std::move(promise));
     host_impl().active_tree()->BreakSwapPromises(
         SwapPromise::DidNotSwapReason::SWAP_FAILS);
     EXPECT_FALSE(weak_promise);
   }
 }
 
 }  // namespace
 }  // namespace cc