cc: Use sublayer scale from effect tree (2)

cc/trees/property_tree_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/property_tree.h"
 
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/proto/property_tree.pb.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/trees/clip_node.h"
@@ skipping 19 matching lines @@
   original.needs_local_transform_update = false;
   original.is_invertible = false;
   original.ancestors_are_invertible = false;
   original.has_potential_animation = false;
   original.to_screen_is_potentially_animated = false;
   original.has_only_translation_animations = false;
   original.flattens_inherited_transform = false;
   original.node_and_ancestors_are_flat = false;
   original.node_and_ancestors_have_only_integer_translation = false;
   original.scrolls = false;
-  original.needs_sublayer_scale = false;
+  original.needs_surface_contents_scale = false;
   original.affected_by_inner_viewport_bounds_delta_x = false;
   original.affected_by_inner_viewport_bounds_delta_y = false;
   original.affected_by_outer_viewport_bounds_delta_x = false;
   original.affected_by_outer_viewport_bounds_delta_y = false;
   original.in_subtree_of_page_scale_layer = false;
   original.post_local_scale_factor = 0.5f;
-  original.sublayer_scale = gfx::Vector2dF(0.5f, 0.5f);
+  original.surface_contents_scale = gfx::Vector2dF(0.5f, 0.5f);
   original.scroll_offset = gfx::ScrollOffset(1.5f, 1.5f);
   original.scroll_snap = gfx::Vector2dF(0.4f, 0.4f);
   original.source_offset = gfx::Vector2dF(2.5f, 2.4f);
   original.source_to_parent = gfx::Vector2dF(3.2f, 3.2f);
 
   proto::TreeNode proto;
   original.ToProtobuf(&proto);
   TransformNode result;
   result.FromProtobuf(proto);
 
@@ skipping 109 matching lines @@
   original.parent_id = 2;
   original.owner_id = 4;
   original.opacity = 0.5f;
   original.screen_space_opacity = 0.6f;
   original.has_render_surface = false;
   original.transform_id = 2;
   original.clip_id = 3;
   original.mask_layer_id = 6;
   original.replica_layer_id = 10;
   original.replica_mask_layer_id = 9;
-  original.sublayer_scale = gfx::Vector2dF(0.5f, 0.5f);
+  original.surface_contents_scale = gfx::Vector2dF(0.5f, 0.5f);
 
   proto::TreeNode proto;
   original.ToProtobuf(&proto);
   EffectNode result;
   result.FromProtobuf(proto);
 
   EXPECT_EQ(original, result);
 }
 
 TEST(PropertyTreeSerializationTest, EffectTreeSerialization) {
@@ skipping 411 matching lines @@
 
     int grand_parent = tree.Insert(TransformNode(), 0);
     tree.SetContentTargetId(grand_parent, grand_parent);
     tree.SetTargetId(grand_parent, grand_parent);
     tree.Node(grand_parent)->source_node_id = 0;
 
     gfx::Transform rotation_about_x;
     rotation_about_x.RotateAboutXAxis(15);
 
     int parent = tree.Insert(TransformNode(), grand_parent);
-    tree.Node(parent)->needs_sublayer_scale = true;
+    tree.Node(parent)->needs_surface_contents_scale = true;
     tree.SetTargetId(parent, grand_parent);
     tree.SetContentTargetId(parent, parent);
     tree.Node(parent)->source_node_id = grand_parent;
     tree.Node(parent)->local = rotation_about_x;
 
     int child = tree.Insert(TransformNode(), parent);
     tree.SetTargetId(child, parent);
     tree.SetContentTargetId(child, parent);
     tree.Node(child)->source_node_id = parent;
     tree.Node(child)->flattens_inherited_transform = true;
@@ skipping 128 matching lines @@
     // To compute this would require inverting the 0 matrix, so we cannot
     // succeed.
     success = tree.ComputeTransform(0, 1, &inverse);
     EXPECT_FALSE(success);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestComputeTransformWithUninvertibleTransform);
 
-class PropertyTreeTestComputeTransformWithSublayerScale
+class PropertyTreeTestComputeTransformWithSurfaceContentsScale
     : public PropertyTreeTest {
  protected:
   void StartTest() override {
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
     TransformNode& root = *tree.Node(0);
     root.id = 0;
     tree.SetTargetId(root.id, 0);
     tree.UpdateTransforms(0);
 
     TransformNode grand_parent;
     grand_parent.local.Scale(2.f, 2.f);
     grand_parent.source_node_id = 0;
-    grand_parent.needs_sublayer_scale = true;
+    grand_parent.needs_surface_contents_scale = true;
     int grand_parent_id = tree.Insert(grand_parent, 0);
     tree.SetTargetId(grand_parent_id, 0);
     tree.UpdateTransforms(grand_parent_id);
 
     TransformNode parent;
     parent.local.Translate(15.f, 15.f);
     parent.source_node_id = grand_parent_id;
     int parent_id = tree.Insert(parent, grand_parent_id);
     tree.SetTargetId(parent_id, grand_parent_id);
     tree.UpdateTransforms(parent_id);
 
     TransformNode child;
     child.local.Scale(3.f, 3.f);
     child.source_node_id = parent_id;
     int child_id = tree.Insert(child, parent_id);
     tree.SetTargetId(child_id, grand_parent_id);
     tree.UpdateTransforms(child_id);
 
     TransformNode grand_child;
     grand_child.local.Scale(5.f, 5.f);
     grand_child.source_node_id = child_id;
-    grand_child.needs_sublayer_scale = true;
+    grand_child.needs_surface_contents_scale = true;
     int grand_child_id = tree.Insert(grand_child, child_id);
     tree.SetTargetId(grand_child_id, grand_parent_id);
     SetupTransformTreeForTest(&tree);
     tree.UpdateTransforms(grand_child_id);
 
     EXPECT_EQ(gfx::Vector2dF(2.f, 2.f),
-              tree.Node(grand_parent_id)->sublayer_scale);
+              tree.Node(grand_parent_id)->surface_contents_scale);
     EXPECT_EQ(gfx::Vector2dF(30.f, 30.f),
-              tree.Node(grand_child_id)->sublayer_scale);
+              tree.Node(grand_child_id)->surface_contents_scale);
 
     // Compute transform from grand_parent to grand_child.
-    gfx::Transform expected_transform_without_sublayer_scale;
-    expected_transform_without_sublayer_scale.Scale(1.f / 15.f, 1.f / 15.f);
-    expected_transform_without_sublayer_scale.Translate(-15.f, -15.f);
+    gfx::Transform expected_transform_without_surface_contents_scale;
+    expected_transform_without_surface_contents_scale.Scale(1.f / 15.f,
+                                                            1.f / 15.f);
+    expected_transform_without_surface_contents_scale.Translate(-15.f, -15.f);
 
-    gfx::Transform expected_transform_with_dest_sublayer_scale;
-    expected_transform_with_dest_sublayer_scale.Scale(30.f, 30.f);
-    expected_transform_with_dest_sublayer_scale.Scale(1.f / 15.f, 1.f / 15.f);
-    expected_transform_with_dest_sublayer_scale.Translate(-15.f, -15.f);
+    gfx::Transform expected_transform_with_dest_surface_contents_scale;
+    expected_transform_with_dest_surface_contents_scale.Scale(30.f, 30.f);
+    expected_transform_with_dest_surface_contents_scale.Scale(1.f / 15.f,
+                                                              1.f / 15.f);
+    expected_transform_with_dest_surface_contents_scale.Translate(-15.f, -15.f);
 
-    gfx::Transform expected_transform_with_source_sublayer_scale;
-    expected_transform_with_source_sublayer_scale.Scale(1.f / 15.f, 1.f / 15.f);
-    expected_transform_with_source_sublayer_scale.Translate(-15.f, -15.f);
-    expected_transform_with_source_sublayer_scale.Scale(0.5f, 0.5f);
+    gfx::Transform expected_transform_with_source_surface_contents_scale;
+    expected_transform_with_source_surface_contents_scale.Scale(1.f / 15.f,
+                                                                1.f / 15.f);
+    expected_transform_with_source_surface_contents_scale.Translate(-15.f,
+                                                                    -15.f);
+    expected_transform_with_source_surface_contents_scale.Scale(0.5f, 0.5f);
 
     gfx::Transform transform;
     bool success =
         tree.ComputeTransform(grand_parent_id, grand_child_id, &transform);
     EXPECT_TRUE(success);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform_without_sublayer_scale,
-                                    transform);
+    EXPECT_TRANSFORMATION_MATRIX_EQ(
+        expected_transform_without_surface_contents_scale, transform);
 
-    success = tree.ComputeTransformWithDestinationSublayerScale(
-        grand_parent_id, grand_child_id, &transform);
-    EXPECT_TRUE(success);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform_with_dest_sublayer_scale,
-                                    transform);
-
-    success = tree.ComputeTransformWithSourceSublayerScale(
+    success = tree.ComputeTransformWithDestinationSurfaceContentsScale(
         grand_parent_id, grand_child_id, &transform);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected_transform_with_source_sublayer_scale, transform);
+        expected_transform_with_dest_surface_contents_scale, transform);
+
+    success =
+        tree.ComputeTransform(grand_parent_id, grand_child_id, &transform);
+    const TransformNode* grand_parent_node = tree.Node(grand_parent_id);
+    EXPECT_NE(grand_parent_node->surface_contents_scale.x(), 0.f);
+    EXPECT_NE(grand_parent_node->surface_contents_scale.y(), 0.f);
+    transform.Scale(1.0 / grand_parent_node->surface_contents_scale.x(),
+                    1.0 / grand_parent_node->surface_contents_scale.y());
+    EXPECT_TRUE(success);
+    EXPECT_TRANSFORMATION_MATRIX_EQ(
+        expected_transform_with_source_surface_contents_scale, transform);
 
     // Now compute transform from grand_child to grand_parent.
-    expected_transform_without_sublayer_scale.MakeIdentity();
-    expected_transform_without_sublayer_scale.Translate(15.f, 15.f);
-    expected_transform_without_sublayer_scale.Scale(15.f, 15.f);
+    expected_transform_without_surface_contents_scale.MakeIdentity();
+    expected_transform_without_surface_contents_scale.Translate(15.f, 15.f);
+    expected_transform_without_surface_contents_scale.Scale(15.f, 15.f);
 
-    expected_transform_with_dest_sublayer_scale.MakeIdentity();
-    expected_transform_with_dest_sublayer_scale.Scale(2.f, 2.f);
-    expected_transform_with_dest_sublayer_scale.Translate(15.f, 15.f);
-    expected_transform_with_dest_sublayer_scale.Scale(15.f, 15.f);
+    expected_transform_with_dest_surface_contents_scale.MakeIdentity();
+    expected_transform_with_dest_surface_contents_scale.Scale(2.f, 2.f);
+    expected_transform_with_dest_surface_contents_scale.Translate(15.f, 15.f);
+    expected_transform_with_dest_surface_contents_scale.Scale(15.f, 15.f);
 
-    expected_transform_with_source_sublayer_scale.MakeIdentity();
-    expected_transform_with_source_sublayer_scale.Translate(15.f, 15.f);
-    expected_transform_with_source_sublayer_scale.Scale(15.f, 15.f);
-    expected_transform_with_source_sublayer_scale.Scale(1.f / 30.f, 1.f / 30.f);
+    expected_transform_with_source_surface_contents_scale.MakeIdentity();
+    expected_transform_with_source_surface_contents_scale.Translate(15.f, 15.f);
+    expected_transform_with_source_surface_contents_scale.Scale(15.f, 15.f);
+    expected_transform_with_source_surface_contents_scale.Scale(1.f / 30.f,
+                                                                1.f / 30.f);
 
     success =
         tree.ComputeTransform(grand_child_id, grand_parent_id, &transform);
     EXPECT_TRUE(success);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform_without_sublayer_scale,
-                                    transform);
+    EXPECT_TRANSFORMATION_MATRIX_EQ(
+        expected_transform_without_surface_contents_scale, transform);
 
-    success = tree.ComputeTransformWithDestinationSublayerScale(
-        grand_child_id, grand_parent_id, &transform);
-    EXPECT_TRUE(success);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform_with_dest_sublayer_scale,
-                                    transform);
-
-    success = tree.ComputeTransformWithSourceSublayerScale(
+    success = tree.ComputeTransformWithDestinationSurfaceContentsScale(
         grand_child_id, grand_parent_id, &transform);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
-        expected_transform_with_source_sublayer_scale, transform);
+        expected_transform_with_dest_surface_contents_scale, transform);
+
+    success =
+        tree.ComputeTransform(grand_child_id, grand_parent_id, &transform);
+    const TransformNode* grand_child_node = tree.Node(grand_child_id);
+    EXPECT_NE(grand_child_node->surface_contents_scale.x(), 0.f);
+    EXPECT_NE(grand_child_node->surface_contents_scale.y(), 0.f);
+    transform.Scale(1.0 / grand_child_node->surface_contents_scale.x(),
+                    1.0 / grand_child_node->surface_contents_scale.y());
+    EXPECT_TRUE(success);
+    EXPECT_TRANSFORMATION_MATRIX_EQ(
+        expected_transform_with_source_surface_contents_scale, transform);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
-    PropertyTreeTestComputeTransformWithSublayerScale);
+    PropertyTreeTestComputeTransformWithSurfaceContentsScale);
 
-class PropertyTreeTestComputeTransformToTargetWithZeroSublayerScale
+class PropertyTreeTestComputeTransformToTargetWithZeroSurfaceContentsScale
     : public PropertyTreeTest {
  protected:
   void StartTest() override {
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
     TransformNode& root = *tree.Node(0);
     tree.SetTargetId(root.id, 0);
     tree.UpdateTransforms(0);
 
     TransformNode grand_parent;
     grand_parent.local.Scale(2.f, 0.f);
     grand_parent.source_node_id = 0;
-    grand_parent.needs_sublayer_scale = true;
+    grand_parent.needs_surface_contents_scale = true;
     int grand_parent_id = tree.Insert(grand_parent, 0);
     tree.SetTargetId(grand_parent_id, 0);
     tree.SetContentTargetId(grand_parent_id, grand_parent_id);
     tree.UpdateTransforms(grand_parent_id);
 
     TransformNode parent;
     parent.local.Translate(1.f, 1.f);
     parent.source_node_id = grand_parent_id;
     int parent_id = tree.Insert(parent, grand_parent_id);
     tree.SetTargetId(parent_id, grand_parent_id);
@@ skipping 37 matching lines @@
 
     draw_property_utils::ComputeTransforms(&tree);
 
     success = tree.ComputeTransform(child_id, grand_parent_id, &transform);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform, transform);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
-    PropertyTreeTestComputeTransformToTargetWithZeroSublayerScale);
+    PropertyTreeTestComputeTransformToTargetWithZeroSurfaceContentsScale);
 
 class PropertyTreeTestFlatteningWhenDestinationHasOnlyFlatAncestors
     : public PropertyTreeTest {
  protected:
   void StartTest() override {
     // This tests that flattening is performed correctly when
     // destination and its ancestors are flat, but there are 3d transforms
     // and flattening between the source and destination.
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
@@ skipping 156 matching lines @@
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestSingularTransformSnapTest);
 
 #undef DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F
 #undef SERIALIZED_PROPERTY_TREE_TEST_F
 #undef DIRECT_PROPERTY_TREE_TEST_F
 
 }  // namespace
 }  // namespace cc