CC Animation: Move animations_ from ElementAnimations to AnimationPlayer.

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 7060 matching lines @@
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 
   TransformOperations translation;
   translation.AppendTranslate(1.f, 2.f, 3.f);
 
   scoped_refptr<AnimationTimeline> timeline;
   timeline = AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
 
   host_impl.active_tree()->SetElementIdsForTesting();
-  AddAnimatedTransformToElementWithPlayer(parent_raw->element_id(), timeline,
-                                          1.0, TransformOperations(),
-                                          translation);
+
+  scoped_refptr<AnimationPlayer> grand_parent_player =
+      AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
+  timeline->AttachPlayer(grand_parent_player);
+  grand_parent_player->AttachElement(grand_parent_raw->element_id());
+
+  scoped_refptr<AnimationPlayer> parent_player =
+      AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
+  timeline->AttachPlayer(parent_player);
+  parent_player->AttachElement(parent_raw->element_id());
+
+  scoped_refptr<AnimationPlayer> child_player =
+      AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
+  timeline->AttachPlayer(child_player);
+  child_player->AttachElement(child_raw->element_id());
+
+  scoped_refptr<AnimationPlayer> grand_child_player =
+      AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
+  timeline->AttachPlayer(grand_child_player);
+  grand_child_player->AttachElement(grand_child_raw->element_id());
+
+  AddAnimatedTransformToPlayer(parent_player.get(), 1.0, TransformOperations(),
+                               translation);
 
   // No layers have scale-affecting animations.
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 
   TransformOperations scale;
   scale.AppendScale(5.f, 4.f, 3.f);
 
-  AddAnimatedTransformToElementWithPlayer(child_raw->element_id(), timeline,
-                                          1.0, TransformOperations(), scale);
+  AddAnimatedTransformToPlayer(child_player.get(), 1.0, TransformOperations(),
+                               scale);
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // Only |child| has a scale-affecting animation.
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
   EXPECT_EQ(5.f, GetMaximumAnimationScale(child_raw));
   EXPECT_EQ(5.f, GetMaximumAnimationScale(grand_child_raw));
 
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(parent_raw));
   EXPECT_EQ(1.f, GetStartingAnimationScale(child_raw));
   EXPECT_EQ(1.f, GetStartingAnimationScale(grand_child_raw));
 
-  AddAnimatedTransformToElementWithPlayer(grand_parent_raw->element_id(),
-                                          timeline, 1.0, TransformOperations(),
-                                          scale);
+  AddAnimatedTransformToPlayer(grand_parent_player.get(), 1.0,
+                               TransformOperations(), scale);
   grand_parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |grand_parent| and |child| have scale-affecting animations.
   EXPECT_EQ(5.f, GetMaximumAnimationScale(grand_parent_raw));
   EXPECT_EQ(5.f, GetMaximumAnimationScale(parent_raw));
   // We don't support combining animated scales from two nodes; 0.f means
   // that the maximum scale could not be computed.
   EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
   EXPECT_EQ(1.f, GetStartingAnimationScale(grand_parent_raw));
   EXPECT_EQ(1.f, GetStartingAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 
-  AddAnimatedTransformToElementWithPlayer(parent_raw->element_id(), timeline,
-                                          1.0, TransformOperations(), scale);
+  AddAnimatedTransformToPlayer(parent_player.get(), 1.0, TransformOperations(),
+                               scale);
   parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |grand_parent|, |parent|, and |child| have scale-affecting animations.
   EXPECT_EQ(5.f, GetMaximumAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
   EXPECT_EQ(1.f, GetStartingAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 
-  AbortAnimationsOnElementWithPlayer(grand_parent_raw->element_id(), timeline,
-                                     TargetProperty::TRANSFORM);
-  AbortAnimationsOnElementWithPlayer(parent_raw->element_id(), timeline,
-                                     TargetProperty::TRANSFORM);
-  AbortAnimationsOnElementWithPlayer(child_raw->element_id(), timeline,
-                                     TargetProperty::TRANSFORM);
+  grand_parent_player->AbortAnimations(TargetProperty::TRANSFORM, false);
+  parent_player->AbortAnimations(TargetProperty::TRANSFORM, false);
+  child_player->AbortAnimations(TargetProperty::TRANSFORM, false);
 
   TransformOperations perspective;
   perspective.AppendPerspective(10.f);
 
-  AddAnimatedTransformToElementWithPlayer(child_raw->element_id(), timeline,
-                                          1.0, TransformOperations(),
-                                          perspective);
+  AddAnimatedTransformToPlayer(child_player.get(), 1.0, TransformOperations(),
+                               perspective);
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |child| has a scale-affecting animation but computing the maximum of this
   // animation is not supported.
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 
   AbortAnimationsOnElementWithPlayer(child_raw->element_id(), timeline,
                                      TargetProperty::TRANSFORM);
   gfx::Transform scale_matrix;
   scale_matrix.Scale(1.f, 2.f);
   grand_parent_raw->test_properties()->transform = scale_matrix;
   parent_raw->test_properties()->transform = scale_matrix;
   grand_parent_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
-  AddAnimatedTransformToElementWithPlayer(parent_raw->element_id(), timeline,
-                                          1.0, TransformOperations(), scale);
+  AddAnimatedTransformToPlayer(parent_player.get(), 1.0, TransformOperations(),
+                               scale);
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   // |grand_parent| and |parent| each have scale 2.f. |parent| has a  scale
   // animation with maximum scale 5.f.
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_parent_raw));
   EXPECT_EQ(10.f, GetMaximumAnimationScale(parent_raw));
   EXPECT_EQ(10.f, GetMaximumAnimationScale(child_raw));
   EXPECT_EQ(10.f, GetMaximumAnimationScale(grand_child_raw));
 
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
@@ skipping 2621 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