cc: Put to_target and to_screen behind an accessor.

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/draw_property_utils.h"
@@ skipping 617 matching lines @@
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestComputeTransformSiblingSingularAncestor);
 
 class PropertyTreeTestTransformsWithFlattening : public PropertyTreeTest {
  protected:
   void StartTest() override {
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
 
     int grand_parent = tree.Insert(TransformNode(), 0);
-    tree.Node(grand_parent)->data.content_target_id = grand_parent;
-    tree.Node(grand_parent)->data.target_id = grand_parent;
+    tree.SetContentTargetId(grand_parent, grand_parent);
+    tree.SetTargetId(grand_parent, grand_parent);
     tree.Node(grand_parent)->data.source_node_id = 0;
 
     gfx::Transform rotation_about_x;
     rotation_about_x.RotateAboutXAxis(15);
 
     int parent = tree.Insert(TransformNode(), grand_parent);
     tree.Node(parent)->data.needs_sublayer_scale = true;
-    tree.Node(parent)->data.target_id = grand_parent;
-    tree.Node(parent)->data.content_target_id = parent;
+    tree.SetTargetId(parent, grand_parent);
+    tree.SetContentTargetId(parent, parent);
     tree.Node(parent)->data.source_node_id = grand_parent;
     tree.Node(parent)->data.local = rotation_about_x;
 
     int child = tree.Insert(TransformNode(), parent);
-    tree.Node(child)->data.target_id = parent;
-    tree.Node(child)->data.content_target_id = parent;
+    tree.SetTargetId(child, parent);
+    tree.SetContentTargetId(child, parent);
     tree.Node(child)->data.source_node_id = parent;
     tree.Node(child)->data.flattens_inherited_transform = true;
     tree.Node(child)->data.local = rotation_about_x;
 
     int grand_child = tree.Insert(TransformNode(), child);
-    tree.Node(grand_child)->data.target_id = parent;
-    tree.Node(grand_child)->data.content_target_id = parent;
+    tree.SetTargetId(grand_child, parent);
+    tree.SetContentTargetId(grand_child, parent);
     tree.Node(grand_child)->data.source_node_id = child;
     tree.Node(grand_child)->data.flattens_inherited_transform = true;
     tree.Node(grand_child)->data.local = rotation_about_x;
 
     tree.set_needs_update(true);
     SetupTransformTreeForTest(&tree);
     draw_property_utils::ComputeTransforms(&tree);
 
     gfx::Transform flattened_rotation_about_x = rotation_about_x;
     flattened_rotation_about_x.FlattenTo2d();
 
-    EXPECT_TRANSFORMATION_MATRIX_EQ(rotation_about_x,
-                                    tree.Node(child)->data.to_target);
+    EXPECT_TRANSFORMATION_MATRIX_EQ(rotation_about_x, tree.ToTarget(child));
+
+    EXPECT_TRANSFORMATION_MATRIX_EQ(
+        flattened_rotation_about_x * rotation_about_x, tree.ToScreen(child));
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         flattened_rotation_about_x * rotation_about_x,
-        tree.Node(child)->data.to_screen);
-
-    EXPECT_TRANSFORMATION_MATRIX_EQ(
-        flattened_rotation_about_x * rotation_about_x,
-        tree.Node(grand_child)->data.to_target);
+        tree.ToTarget(grand_child));
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(flattened_rotation_about_x *
                                         flattened_rotation_about_x *
                                         rotation_about_x,
-                                    tree.Node(grand_child)->data.to_screen);
+                                    tree.ToScreen(grand_child));
 
     gfx::Transform grand_child_to_child;
     bool success =
         tree.ComputeTransform(grand_child, child, &grand_child_to_child);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(rotation_about_x, grand_child_to_child);
 
     // Remove flattening at grand_child, and recompute transforms.
     tree.Node(grand_child)->data.flattens_inherited_transform = false;
     tree.set_needs_update(true);
     SetupTransformTreeForTest(&tree);
     draw_property_utils::ComputeTransforms(&tree);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(rotation_about_x * rotation_about_x,
-                                    tree.Node(grand_child)->data.to_target);
+                                    tree.ToTarget(grand_child));
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         flattened_rotation_about_x * rotation_about_x * rotation_about_x,
-        tree.Node(grand_child)->data.to_screen);
+        tree.ToScreen(grand_child));
 
     success = tree.ComputeTransform(grand_child, child, &grand_child_to_child);
     EXPECT_TRUE(success);
     EXPECT_TRANSFORMATION_MATRIX_EQ(rotation_about_x, grand_child_to_child);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestTransformsWithFlattening);
 
@@ skipping 272 matching lines @@
     : 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;
 
     int parent = tree.Insert(TransformNode(), 0);
-    tree.Node(parent)->data.content_target_id = parent;
-    tree.Node(parent)->data.target_id = parent;
+    tree.SetContentTargetId(parent, parent);
+    tree.SetTargetId(parent, parent);
     tree.Node(parent)->data.source_node_id = 0;
     tree.Node(parent)->data.local.Translate(2, 2);
 
     gfx::Transform rotation_about_x;
     rotation_about_x.RotateAboutXAxis(15);
 
     int child = tree.Insert(TransformNode(), parent);
-    tree.Node(child)->data.content_target_id = child;
-    tree.Node(child)->data.target_id = child;
+    tree.SetContentTargetId(child, child);
+    tree.SetTargetId(child, child);
     tree.Node(child)->data.source_node_id = parent;
     tree.Node(child)->data.local = rotation_about_x;
 
     int grand_child = tree.Insert(TransformNode(), child);
-    tree.Node(grand_child)->data.content_target_id = grand_child;
-    tree.Node(grand_child)->data.target_id = grand_child;
+    tree.SetContentTargetId(grand_child, grand_child);
+    tree.SetTargetId(grand_child, grand_child);
     tree.Node(grand_child)->data.source_node_id = child;
     tree.Node(grand_child)->data.flattens_inherited_transform = true;
 
     tree.set_needs_update(true);
     SetupTransformTreeForTest(&tree);
     draw_property_utils::ComputeTransforms(&tree);
 
     gfx::Transform flattened_rotation_about_x = rotation_about_x;
     flattened_rotation_about_x.FlattenTo2d();
 
@@ skipping 40 matching lines @@
 
 class PropertyTreeTestNonIntegerTranslationTest : public PropertyTreeTest {
  protected:
   void StartTest() override {
     // This tests that when a node has non-integer translation, the information
     // is propagated to the subtree.
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
 
     int parent = tree.Insert(TransformNode(), 0);
-    tree.Node(parent)->data.target_id = parent;
+    tree.SetTargetId(parent, parent);
     tree.Node(parent)->data.local.Translate(1.5f, 1.5f);
 
     int child = tree.Insert(TransformNode(), parent);
-    tree.Node(child)->data.target_id = parent;
+    tree.SetTargetId(child, parent);
     tree.Node(child)->data.local.Translate(1, 1);
     tree.set_needs_update(true);
     SetupTransformTreeForTest(&tree);
     draw_property_utils::ComputeTransforms(&tree);
     EXPECT_FALSE(tree.Node(parent)
                      ->data.node_and_ancestors_have_only_integer_translation);
     EXPECT_FALSE(tree.Node(child)
                      ->data.node_and_ancestors_have_only_integer_translation);
 
     tree.Node(parent)->data.local.Translate(0.5f, 0.5f);
     tree.Node(child)->data.local.Translate(0.5f, 0.5f);
     tree.set_needs_update(true);
     SetupTransformTreeForTest(&tree);
     draw_property_utils::ComputeTransforms(&tree);
     EXPECT_TRUE(tree.Node(parent)
                     ->data.node_and_ancestors_have_only_integer_translation);
     EXPECT_FALSE(tree.Node(child)
                      ->data.node_and_ancestors_have_only_integer_translation);
 
     tree.Node(child)->data.local.Translate(0.5f, 0.5f);
-    tree.Node(child)->data.target_id = child;
+    tree.SetTargetId(child, child);
     tree.set_needs_update(true);
     SetupTransformTreeForTest(&tree);
     draw_property_utils::ComputeTransforms(&tree);
     EXPECT_TRUE(tree.Node(parent)
                     ->data.node_and_ancestors_have_only_integer_translation);
     EXPECT_TRUE(tree.Node(child)
                     ->data.node_and_ancestors_have_only_integer_translation);
   }
 };
 
 DIRECT_AND_SERIALIZED_PROPERTY_TREE_TEST_F(
     PropertyTreeTestNonIntegerTranslationTest);
 
 class PropertyTreeTestSingularTransformSnapTest : public PropertyTreeTest {
  protected:
   void StartTest() override {
     // This tests that to_target transform is not snapped when it has a singular
     // transform.
     PropertyTrees property_trees;
     TransformTree& tree = property_trees.transform_tree;
 
     int parent = tree.Insert(TransformNode(), 0);
-    tree.Node(parent)->data.target_id = parent;
+    tree.SetTargetId(parent, parent);
     tree.Node(parent)->data.scrolls = true;
 
     int child = tree.Insert(TransformNode(), parent);
     TransformNode* child_node = tree.Node(child);
-    child_node->data.target_id = parent;
+    tree.SetTargetId(child, parent);
     child_node->data.scrolls = true;
     child_node->data.local.Scale3d(6.0f, 6.0f, 0.0f);
     child_node->data.local.Translate(1.3f, 1.3f);
     tree.set_needs_update(true);
 
     SetupTransformTreeForTest(&tree);
     draw_property_utils::ComputeTransforms(&tree);
 
     gfx::Transform from_target;
-    EXPECT_FALSE(child_node->data.to_target.GetInverse(&from_target));
+    EXPECT_FALSE(tree.ToTarget(child).GetInverse(&from_target));
     // The following checks are to ensure that snapping is skipped because of
     // singular transform (and not because of other reasons which also cause
     // snapping to be skipped).
     EXPECT_TRUE(child_node->data.scrolls);
-    EXPECT_TRUE(child_node->data.to_target.IsScaleOrTranslation());
+    EXPECT_TRUE(tree.ToTarget(child).IsScaleOrTranslation());
     EXPECT_FALSE(child_node->data.to_screen_is_potentially_animated);
     EXPECT_FALSE(child_node->data.ancestors_are_invertible);
 
-    gfx::Transform rounded = child_node->data.to_target;
+    gfx::Transform rounded = tree.ToTarget(child);
     rounded.RoundTranslationComponents();
-    EXPECT_NE(child_node->data.to_target, rounded);
+    EXPECT_NE(tree.ToTarget(child), rounded);
   }
 };
 
 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