cc: Fix property tree position updates when rebuilding is skipped

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/test/geometry_test_utils.h"
 #include "cc/trees/draw_property_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 29 matching lines @@
 TEST(PropertyTreeTest, ComputeTransformChild) {
   TransformTree tree;
   TransformNode& root = *tree.Node(0);
   root.data.local.Translate(2, 2);
   root.data.target_id = 0;
   tree.UpdateTransforms(0);
 
   TransformNode child;
   child.data.local.Translate(3, 3);
   child.data.target_id = 0;
+  child.data.source_node_id = 0;
 
   tree.Insert(child, 0);
   tree.UpdateTransforms(1);
 
   gfx::Transform expected;
   gfx::Transform transform;
 
   expected.Translate(3, 3);
   bool success = tree.ComputeTransform(1, 0, &transform);
   EXPECT_TRUE(success);
@@ skipping 20 matching lines @@
   EXPECT_TRUE(success);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 }
 
 TEST(PropertyTreeTest, TransformsWithFlattening) {
   TransformTree 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.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.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.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.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);
   ComputeTransforms(&tree);
 
   gfx::Transform flattened_rotation_about_x = rotation_about_x;
   flattened_rotation_about_x.FlattenTo2d();
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(rotation_about_x,
@@ skipping 36 matching lines @@
 TEST(PropertyTreeTest, MultiplicationOrder) {
   TransformTree tree;
   TransformNode& root = *tree.Node(0);
   root.data.local.Translate(2, 2);
   root.data.target_id = 0;
   tree.UpdateTransforms(0);
 
   TransformNode child;
   child.data.local.Scale(2, 2);
   child.data.target_id = 0;
+  child.data.source_node_id = 0;
 
   tree.Insert(child, 0);
   tree.UpdateTransforms(1);
 
   gfx::Transform expected;
   expected.Translate(2, 2);
   expected.Scale(2, 2);
 
   gfx::Transform transform;
   gfx::Transform inverse;
@@ skipping 12 matching lines @@
 
 TEST(PropertyTreeTest, ComputeTransformWithUninvertibleTransform) {
   TransformTree tree;
   TransformNode& root = *tree.Node(0);
   root.data.target_id = 0;
   tree.UpdateTransforms(0);
 
   TransformNode child;
   child.data.local.Scale(0, 0);
   child.data.target_id = 0;
+  child.data.source_node_id = 0;
 
   tree.Insert(child, 0);
   tree.UpdateTransforms(1);
 
   gfx::Transform expected;
   expected.Scale(0, 0);
 
   gfx::Transform transform;
   gfx::Transform inverse;
 
   bool success = tree.ComputeTransform(1, 0, &transform);
   EXPECT_TRUE(success);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 
   // To compute this would require inverting the 0 matrix, so we cannot
   // succeed.
   success = tree.ComputeTransform(0, 1, &inverse);
   EXPECT_FALSE(success);
 }
 
 TEST(PropertyTreeTest, ComputeTransformWithSublayerScale) {
   TransformTree tree;
   TransformNode& root = *tree.Node(0);
   root.data.target_id = 0;
   tree.UpdateTransforms(0);
 
   TransformNode grand_parent;
   grand_parent.data.local.Scale(2.f, 2.f);
   grand_parent.data.target_id = 0;
+  grand_parent.data.source_node_id = 0;
   grand_parent.data.needs_sublayer_scale = true;
   int grand_parent_id = tree.Insert(grand_parent, 0);
   tree.UpdateTransforms(grand_parent_id);
 
   TransformNode parent;
   parent.data.local.Translate(15.f, 15.f);
   parent.data.target_id = grand_parent_id;
+  parent.data.source_node_id = grand_parent_id;
   int parent_id = tree.Insert(parent, grand_parent_id);
   tree.UpdateTransforms(parent_id);
 
   TransformNode child;
   child.data.local.Scale(3.f, 3.f);
   child.data.target_id = grand_parent_id;
+  child.data.source_node_id = parent_id;
   int child_id = tree.Insert(child, parent_id);
   tree.UpdateTransforms(child_id);
 
   TransformNode grand_child;
   grand_child.data.local.Scale(5.f, 5.f);
   grand_child.data.target_id = grand_parent_id;
+  grand_child.data.source_node_id = child_id;
   grand_child.data.needs_sublayer_scale = true;
   int grand_child_id = tree.Insert(grand_child, child_id);
   tree.UpdateTransforms(grand_child_id);
 
   EXPECT_EQ(gfx::Vector2dF(2.f, 2.f),
             tree.Node(grand_parent_id)->data.sublayer_scale);
   EXPECT_EQ(gfx::Vector2dF(30.f, 30.f),
             tree.Node(grand_child_id)->data.sublayer_scale);
 
   // Compute transform from grand_parent to grand_child.
@@ skipping 65 matching lines @@
 
 TEST(PropertyTreeTest, FlatteningWhenDestinationHasOnlyFlatAncestors) {
   // 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.
   TransformTree tree;
 
   int parent = tree.Insert(TransformNode(), 0);
   tree.Node(parent)->data.content_target_id = parent;
   tree.Node(parent)->data.target_id = 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.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.Node(grand_child)->data.source_node_id = child;
   tree.Node(grand_child)->data.flattens_inherited_transform = true;
 
   tree.set_needs_update(true);
   ComputeTransforms(&tree);
 
   gfx::Transform flattened_rotation_about_x = rotation_about_x;
   flattened_rotation_about_x.FlattenTo2d();
 
   gfx::Transform grand_child_to_parent;
   bool success =
       tree.ComputeTransform(grand_child, parent, &grand_child_to_parent);
   EXPECT_TRUE(success);
   EXPECT_TRANSFORMATION_MATRIX_EQ(flattened_rotation_about_x,
                                   grand_child_to_parent);
 }
 
 }  // namespace cc