CC Animation: Merge LayerAnimationController into ElementAnimations.

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/layer_animation_controller.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::EaseTimingFunction;
 using cc::FloatKeyframe;
 using cc::KeyframedFloatAnimationCurve;
@@ skipping 181 matching lines @@
   return duration_;
 }
 
 float FakeFloatTransition::GetValue(base::TimeDelta time) const {
   double progress = TimeUtil::Divide(time, duration_);
   if (progress >= 1.0)
     progress = 1.0;
   return (1.0 - progress) * from_ + progress * to_;
 }
 
-gfx::ScrollOffset FakeLayerAnimationValueProvider::ScrollOffsetForAnimation()
-    const {
-  return scroll_offset_;
-}
-
-FakeLayerAnimationValueObserver::FakeLayerAnimationValueObserver()
-    : animation_waiting_for_deletion_(false) {
-  opacity_[ToIndex(LayerTreeType::ACTIVE)] = 0.0f;
-  opacity_[ToIndex(LayerTreeType::PENDING)] = 0.0f;
-
-  transform_is_animating_[ToIndex(LayerTreeType::ACTIVE)] = false;
-  transform_is_animating_[ToIndex(LayerTreeType::PENDING)] = false;
-}
-
-FakeLayerAnimationValueObserver::~FakeLayerAnimationValueObserver() {}
-
-int FakeLayerAnimationValueObserver::ToIndex(LayerTreeType tree_type) {
-  int index = static_cast<int>(tree_type);
-  DCHECK_GE(index, 0);
-  DCHECK_LE(index, 1);
-  return index;
-}
-
-void FakeLayerAnimationValueObserver::OnFilterAnimated(
-    LayerTreeType tree_type,
-    const FilterOperations& filters) {
-  filters_[ToIndex(tree_type)] = filters;
-}
-
-void FakeLayerAnimationValueObserver::OnOpacityAnimated(LayerTreeType tree_type,
-                                                        float opacity) {
-  opacity_[ToIndex(tree_type)] = opacity;
-}
-
-void FakeLayerAnimationValueObserver::OnTransformAnimated(
-    LayerTreeType tree_type,
-    const gfx::Transform& transform) {
-  transform_[ToIndex(tree_type)] = transform;
-}
-
-void FakeLayerAnimationValueObserver::OnScrollOffsetAnimated(
-    LayerTreeType tree_type,
-    const gfx::ScrollOffset& scroll_offset) {
-  scroll_offset_[ToIndex(tree_type)] = scroll_offset;
-}
-
-void FakeLayerAnimationValueObserver::OnAnimationWaitingForDeletion() {
-  animation_waiting_for_deletion_ = true;
-}
-
-void FakeLayerAnimationValueObserver::OnTransformIsPotentiallyAnimatingChanged(
-    LayerTreeType tree_type,
-    bool is_animating) {
-  transform_is_animating_[ToIndex(tree_type)] = is_animating;
-}
-
 std::unique_ptr<AnimationCurve> FakeFloatTransition::Clone() const {
   return base::WrapUnique(new FakeFloatTransition(*this));
 }
 
-int AddOpacityTransitionToController(LayerAnimationController* controller,
-                                     double duration,
-                                     float start_opacity,
-                                     float end_opacity,
-                                     bool use_timing_function) {
-  return AddOpacityTransition(controller,
-                              duration,
-                              start_opacity,
-                              end_opacity,
+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 AddAnimatedTransformToController(LayerAnimationController* controller,
-                                     double duration,
-                                     int delta_x,
-                                     int delta_y) {
-  return AddAnimatedTransform(controller,
-                              duration,
-                              delta_x,
-                              delta_y);
+int AddAnimatedTransformToElementAnimations(ElementAnimations* target,
+                                            double duration,
+                                            int delta_x,
+                                            int delta_y) {
+  return AddAnimatedTransform(target, duration, delta_x, delta_y);
 }
 
-int AddAnimatedFilterToController(LayerAnimationController* controller,
-                                  double duration,
-                                  float start_brightness,
-                                  float end_brightness) {
-  return AddAnimatedFilter(
-      controller, duration, start_brightness, end_brightness);
+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,
@@ skipping 12 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 AddOpacityStepsToController(LayerAnimationController* target,
-                                double duration,
-                                float start_opacity,
-                                float end_opacity,
-                                int num_steps) {
+int AddOpacityStepsToElementAnimations(ElementAnimations* target,
+                                       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, 0.5f);
   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));
@@ skipping 17 matching lines @@
   timeline->AttachPlayer(player);
   player->AttachLayer(layer_id);
   DCHECK(player->element_animations());
   player->AddAnimation(std::move(animation));
 }
 
 void AddAnimationToLayerWithExistingPlayer(
     int layer_id,
     scoped_refptr<AnimationTimeline> timeline,
     std::unique_ptr<Animation> animation) {
-  LayerAnimationController* controller =
-      timeline->animation_host()->GetControllerForLayerId(layer_id);
-  DCHECK(controller);
-  controller->AddAnimation(std::move(animation));
+  scoped_refptr<ElementAnimations> element_animations =
+      timeline->animation_host()->GetElementAnimationsForLayerId(layer_id);
+  DCHECK(element_animations);
+  element_animations->AddAnimation(std::move(animation));
 }
 
 void RemoveAnimationFromLayerWithExistingPlayer(
     int layer_id,
     scoped_refptr<AnimationTimeline> timeline,
     int animation_id) {
-  LayerAnimationController* controller =
-      timeline->animation_host()->GetControllerForLayerId(layer_id);
-  DCHECK(controller);
-  controller->RemoveAnimation(animation_id);
+  scoped_refptr<ElementAnimations> element_animations =
+      timeline->animation_host()->GetElementAnimationsForLayerId(layer_id);
+  DCHECK(element_animations);
+  element_animations->RemoveAnimation(animation_id);
 }
 
 Animation* GetAnimationFromLayerWithExistingPlayer(
     int layer_id,
     scoped_refptr<AnimationTimeline> timeline,
     int animation_id) {
-  LayerAnimationController* controller =
-      timeline->animation_host()->GetControllerForLayerId(layer_id);
-  DCHECK(controller);
-  return controller->GetAnimationById(animation_id);
+  scoped_refptr<ElementAnimations> element_animations =
+      timeline->animation_host()->GetElementAnimationsForLayerId(layer_id);
+  DCHECK(element_animations);
+  return element_animations->GetAnimationById(animation_id);
 }
 
 int AddAnimatedFilterToLayerWithPlayer(
     int layer_id,
     scoped_refptr<AnimationTimeline> timeline,
     double duration,
     float start_brightness,
     float end_brightness) {
   scoped_refptr<AnimationPlayer> player =
       AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
@@ skipping 45 matching lines @@
   timeline->AttachPlayer(player);
   player->AttachLayer(layer_id);
   DCHECK(player->element_animations());
   return AddOpacityTransitionToPlayer(player.get(), duration, start_opacity,
                                       end_opacity, use_timing_function);
 }
 
 void AbortAnimationsOnLayerWithPlayer(int layer_id,
                                       scoped_refptr<AnimationTimeline> timeline,
                                       TargetProperty::Type target_property) {
-  LayerAnimationController* controller =
-      timeline->animation_host()->GetControllerForLayerId(layer_id);
-  DCHECK(controller);
-  controller->AbortAnimations(target_property);
+  scoped_refptr<ElementAnimations> element_animations =
+      timeline->animation_host()->GetElementAnimationsForLayerId(layer_id);
+  DCHECK(element_animations);
+  element_animations->AbortAnimations(target_property);
 }
 
 }  // namespace cc