CC Animations: Rewrite unit tests to work with AnimationPlayer.

cc/test/animation_test_common.cc

 // Copyright 2012 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/test/animation_test_common.h"
 
 #include "base/memory/ptr_util.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
 #include "cc/animation/element_animations.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/scroll_offset_animation_curve.h"
 #include "cc/animation/timing_function.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/base/time_util.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 
 using cc::Animation;
 using cc::AnimationCurve;
 using cc::FloatKeyframe;
 using cc::KeyframedFloatAnimationCurve;
 using cc::KeyframedTransformAnimationCurve;
 using cc::TimingFunction;
 using cc::TransformKeyframe;
 
 namespace cc {
 
-template <class Target>
-int AddOpacityTransition(Target* target,
+int AddOpacityTransition(AnimationPlayer* target,
                          double duration,
                          float start_opacity,
                          float end_opacity,
                          bool use_timing_function) {
   std::unique_ptr<KeyframedFloatAnimationCurve> curve(
       KeyframedFloatAnimationCurve::Create());
 
   std::unique_ptr<TimingFunction> func;
   if (!use_timing_function)
     func = CubicBezierTimingFunction::CreatePreset(
         CubicBezierTimingFunction::EaseType::EASE);
   if (duration > 0.0)
     curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), start_opacity,
                                              std::move(func)));
   curve->AddKeyframe(FloatKeyframe::Create(
       base::TimeDelta::FromSecondsD(duration), end_opacity, nullptr));
 
   int id = AnimationIdProvider::NextAnimationId();
 
   std::unique_ptr<Animation> animation(Animation::Create(
       std::move(curve), id, AnimationIdProvider::NextGroupId(),
       TargetProperty::OPACITY));
   animation->set_needs_synchronized_start_time(true);
 
   target->AddAnimation(std::move(animation));
   return id;
 }
 
-template <class Target>
-int AddAnimatedTransform(Target* target,
+int AddAnimatedTransform(AnimationPlayer* target,
                          double duration,
                          TransformOperations start_operations,
                          TransformOperations operations) {
   std::unique_ptr<KeyframedTransformAnimationCurve> curve(
       KeyframedTransformAnimationCurve::Create());
 
   if (duration > 0.0) {
     curve->AddKeyframe(TransformKeyframe::Create(base::TimeDelta(),
                                                  start_operations, nullptr));
   }
 
   curve->AddKeyframe(TransformKeyframe::Create(
       base::TimeDelta::FromSecondsD(duration), operations, nullptr));
 
   int id = AnimationIdProvider::NextAnimationId();
 
   std::unique_ptr<Animation> animation(Animation::Create(
       std::move(curve), id, AnimationIdProvider::NextGroupId(),
       TargetProperty::TRANSFORM));
   animation->set_needs_synchronized_start_time(true);
 
   target->AddAnimation(std::move(animation));
   return id;
 }
 
-template <class Target>
-int AddAnimatedTransform(Target* target,
+int AddAnimatedTransform(AnimationPlayer* target,
                          double duration,
                          int delta_x,
                          int delta_y) {
   TransformOperations start_operations;
   if (duration > 0.0) {
     start_operations.AppendTranslate(0, 0, 0.0);
   }
 
   TransformOperations operations;
   operations.AppendTranslate(delta_x, delta_y, 0.0);
   return AddAnimatedTransform(target, duration, start_operations, operations);
 }
 
-template <class Target>
-int AddAnimatedFilter(Target* target,
+int AddAnimatedFilter(AnimationPlayer* target,
                       double duration,
                       float start_brightness,
                       float end_brightness) {
   std::unique_ptr<KeyframedFilterAnimationCurve> curve(
       KeyframedFilterAnimationCurve::Create());
 
   if (duration > 0.0) {
     FilterOperations start_filters;
     start_filters.Append(
         FilterOperation::CreateBrightnessFilter(start_brightness));
@@ skipping 94 matching lines @@
   double progress = TimeUtil::Divide(time, duration_);
   if (progress >= 1.0)
     progress = 1.0;
   return (1.0 - progress) * from_ + progress * to_;
 }
 
 std::unique_ptr<AnimationCurve> FakeFloatTransition::Clone() const {
   return base::WrapUnique(new FakeFloatTransition(*this));
 }
 
-int AddScrollOffsetAnimationToElementAnimations(ElementAnimations* target,
-                                                gfx::ScrollOffset initial_value,
-                                                gfx::ScrollOffset target_value,
-                                                bool impl_only) {
+int AddScrollOffsetAnimationToPlayer(AnimationPlayer* player,
+                                     gfx::ScrollOffset initial_value,
+                                     gfx::ScrollOffset target_value,
+                                     bool impl_only) {
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurve::Create(
           target_value, CubicBezierTimingFunction::CreatePreset(
                             CubicBezierTimingFunction::EaseType::EASE_IN_OUT)));
   curve->SetInitialValue(initial_value);
 
   int id = AnimationIdProvider::NextAnimationId();
 
   std::unique_ptr<Animation> animation(Animation::Create(
       std::move(curve), id, AnimationIdProvider::NextGroupId(),
       TargetProperty::SCROLL_OFFSET));
   animation->set_is_impl_only(impl_only);
 
-  target->AddAnimation(std::move(animation));
+  player->AddAnimation(std::move(animation));
 
   return id;
 }
 
-int AddOpacityTransitionToElementAnimations(ElementAnimations* target,
-                                            double duration,
-                                            float start_opacity,
-                                            float end_opacity,
-                                            bool use_timing_function) {
-  return AddOpacityTransition(target, duration, start_opacity, end_opacity,
-                              use_timing_function);
-}
-
-int AddAnimatedTransformToElementAnimations(ElementAnimations* target,
-                                            double duration,
-                                            int delta_x,
-                                            int delta_y) {
-  return AddAnimatedTransform(target, duration, delta_x, delta_y);
-}
-
-int AddAnimatedFilterToElementAnimations(ElementAnimations* target,
-                                         double duration,
-                                         float start_brightness,
-                                         float end_brightness) {
-  return AddAnimatedFilter(target, duration, start_brightness, end_brightness);
-}
-
 int AddAnimatedTransformToPlayer(AnimationPlayer* player,
                                  double duration,
                                  int delta_x,
                                  int delta_y) {
   return AddAnimatedTransform(player, duration, delta_x, delta_y);
 }
 
 int AddAnimatedTransformToPlayer(AnimationPlayer* player,
                                  double duration,
                                  TransformOperations start_operations,
@@ skipping 10 matching lines @@
                               use_timing_function);
 }
 
 int AddAnimatedFilterToPlayer(AnimationPlayer* player,
                               double duration,
                               float start_brightness,
                               float end_brightness) {
   return AddAnimatedFilter(player, duration, start_brightness, end_brightness);
 }
 
-int AddOpacityStepsToElementAnimations(ElementAnimations* target,
-                                       double duration,
-                                       float start_opacity,
-                                       float end_opacity,
-                                       int num_steps) {
+int AddOpacityStepsToPlayer(AnimationPlayer* player,
+                            double duration,
+                            float start_opacity,
+                            float end_opacity,
+                            int num_steps) {
   std::unique_ptr<KeyframedFloatAnimationCurve> curve(
       KeyframedFloatAnimationCurve::Create());
 
   std::unique_ptr<TimingFunction> func = StepsTimingFunction::Create(
       num_steps, StepsTimingFunction::StepPosition::MIDDLE);
   if (duration > 0.0)
     curve->AddKeyframe(FloatKeyframe::Create(base::TimeDelta(), start_opacity,
                                              std::move(func)));
   curve->AddKeyframe(FloatKeyframe::Create(
       base::TimeDelta::FromSecondsD(duration), end_opacity, nullptr));
 
   int id = AnimationIdProvider::NextAnimationId();
 
   std::unique_ptr<Animation> animation(Animation::Create(
       std::move(curve), id, AnimationIdProvider::NextGroupId(),
       TargetProperty::OPACITY));
   animation->set_needs_synchronized_start_time(true);
 
-  target->AddAnimation(std::move(animation));
+  player->AddAnimation(std::move(animation));
   return id;
 }
 
 void AddAnimationToElementWithPlayer(ElementId element_id,
                                      scoped_refptr<AnimationTimeline> timeline,
                                      std::unique_ptr<Animation> animation) {
   scoped_refptr<AnimationPlayer> player =
       AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
   timeline->AttachPlayer(player);
   player->AttachElement(element_id);
   DCHECK(player->element_animations());
   player->AddAnimation(std::move(animation));
 }
 
 void AddAnimationToElementWithExistingPlayer(
     ElementId element_id,
     scoped_refptr<AnimationTimeline> timeline,
     std::unique_ptr<Animation> animation) {
   scoped_refptr<ElementAnimations> element_animations =
       timeline->animation_host()->GetElementAnimationsForElementId(element_id);
   DCHECK(element_animations);
-  element_animations->AddAnimation(std::move(animation));
+  DCHECK(element_animations->players_list().might_have_observers());
+  ElementAnimations::PlayersList::Iterator it(
+      &element_animations->players_list());
+  AnimationPlayer* player = it.GetNext();
+  DCHECK(player);
+  player->AddAnimation(std::move(animation));
 }
 
 void RemoveAnimationFromElementWithExistingPlayer(
     ElementId element_id,
     scoped_refptr<AnimationTimeline> timeline,
     int animation_id) {
   scoped_refptr<ElementAnimations> element_animations =
       timeline->animation_host()->GetElementAnimationsForElementId(element_id);
   DCHECK(element_animations);
-  element_animations->RemoveAnimation(animation_id);
+  DCHECK(element_animations->players_list().might_have_observers());
+  ElementAnimations::PlayersList::Iterator it(
+      &element_animations->players_list());
+  AnimationPlayer* player = it.GetNext();
+  DCHECK(player);
+  player->RemoveAnimation(animation_id);
 }
 
 Animation* GetAnimationFromElementWithExistingPlayer(
     ElementId element_id,
     scoped_refptr<AnimationTimeline> timeline,
     int animation_id) {
   scoped_refptr<ElementAnimations> element_animations =
       timeline->animation_host()->GetElementAnimationsForElementId(element_id);
   DCHECK(element_animations);
-  return element_animations->GetAnimationById(animation_id);
+  DCHECK(element_animations->players_list().might_have_observers());
+  ElementAnimations::PlayersList::Iterator it(
+      &element_animations->players_list());
+  AnimationPlayer* player = it.GetNext();
+  DCHECK(player);
+  return player->GetAnimationById(animation_id);
 }
 
 int AddAnimatedFilterToElementWithPlayer(
     ElementId element_id,
     scoped_refptr<AnimationTimeline> timeline,
     double duration,
     float start_brightness,
     float end_brightness) {
   scoped_refptr<AnimationPlayer> player =
       AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
@@ skipping 42 matching lines @@
     bool use_timing_function) {
   scoped_refptr<AnimationPlayer> player =
       AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
   timeline->AttachPlayer(player);
   player->AttachElement(element_id);
   DCHECK(player->element_animations());
   return AddOpacityTransitionToPlayer(player.get(), duration, start_opacity,
                                       end_opacity, use_timing_function);
 }
 
-void AbortAnimationsOnElementWithPlayer(
-    ElementId element_id,
-    scoped_refptr<AnimationTimeline> timeline,
-    TargetProperty::Type target_property) {
-  scoped_refptr<ElementAnimations> element_animations =
-      timeline->animation_host()->GetElementAnimationsForElementId(element_id);
-  DCHECK(element_animations);
-  element_animations->AbortAnimations(target_property);
-}
-
 }  // namespace cc