cc : Add OnTransformAnimated to transform tree

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 6267 matching lines @@
   render_surface2->test_properties()->force_render_surface = true;
   ExecuteCalculateDrawProperties(root);
 
   const EffectTree& tree =
       root->layer_tree_impl()->property_trees()->effect_tree;
   EXPECT_TRUE(tree.Node(render_surface1->effect_tree_index())
                   ->hidden_by_backface_visibility);
   EXPECT_TRUE(tree.Node(render_surface2->effect_tree_index())
                   ->hidden_by_backface_visibility);
 
-  back_facing->OnTransformAnimated(gfx::Transform());
-  render_surface2->OnTransformAnimated(rotate_about_y);
+  root->layer_tree_impl()->property_trees()->transform_tree.OnTransformAnimated(
+      gfx::Transform(), back_facing->transform_tree_index(),
+      root->layer_tree_impl());
+  root->layer_tree_impl()->property_trees()->transform_tree.OnTransformAnimated(
+      rotate_about_y, render_surface2->transform_tree_index(),
+      root->layer_tree_impl());
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(tree.Node(render_surface1->effect_tree_index())
                    ->hidden_by_backface_visibility);
   EXPECT_TRUE(tree.Node(render_surface2->effect_tree_index())
                   ->hidden_by_backface_visibility);
 
-  render_surface1->OnTransformAnimated(rotate_about_y);
+  root->layer_tree_impl()->property_trees()->transform_tree.OnTransformAnimated(
+      rotate_about_y, render_surface1->transform_tree_index(),
+      root->layer_tree_impl());
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRUE(tree.Node(render_surface1->effect_tree_index())
                   ->hidden_by_backface_visibility);
   EXPECT_TRUE(tree.Node(render_surface2->effect_tree_index())
                   ->hidden_by_backface_visibility);
 }
 
 TEST_F(LayerTreeHostCommonTest, ClippedByScrollParent) {
   // Checks that the simple case (being clipped by a scroll parent that would
   // have been processed before you anyhow) results in the right clips.
@@ skipping 1378 matching lines @@
   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->test_properties()->transform = gfx::Transform();
-  child1_layer->UpdatePropertyTreeTransform(gfx::Transform());
+  root_layer->layer_tree_impl()
+      ->property_trees()
+      ->transform_tree.OnTransformAnimated(gfx::Transform(),
+                                           child1_layer->transform_tree_index(),
+                                           root_layer->layer_tree_impl());
   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 258 matching lines @@
   // clipped target space, so is treated as fully visible.
   EXPECT_EQ(gfx::Rect(120, 120), animated->visible_layer_rect());
 
   // The singular transform on |animated| is flattened when inherited by
   // |surface|, and this happens to make it invertible.
   EXPECT_EQ(gfx::Rect(2, 2), surface->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(2, 2), descendant_of_animation->visible_layer_rect());
 
   gfx::Transform zero_matrix;
   zero_matrix.Scale3d(0.f, 0.f, 0.f);
-  animated->OnTransformAnimated(zero_matrix);
+  root->layer_tree_impl()->property_trees()->transform_tree.OnTransformAnimated(
+      zero_matrix, animated->transform_tree_index(), root->layer_tree_impl());
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
 
   // The animated layer maps to the empty rect in clipped target space, so is
   // treated as having an empty visible rect.
   EXPECT_EQ(gfx::Rect(), animated->visible_layer_rect());
 
   // This time, flattening does not make |animated|'s transform invertible. This
   // means the clip cannot be projected into |surface|'s space, so we treat
   // |surface| and layers that draw into it as having empty visible rect.
   EXPECT_EQ(gfx::Rect(), surface->visible_layer_rect());
@@ skipping 1783 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