CC Animation: Merge LayerAnimationController into ElementAnimations.

cc/test/animation_test_common.h

Index: cc/test/animation_test_common.h
diff --git a/cc/test/animation_test_common.h b/cc/test/animation_test_common.h
index 4d0b7791ee4209d96f563857de6cd4daed146947..255bdace499cecbb50cb4e5774e1261c6cdfdf2f 100644
--- a/cc/test/animation_test_common.h
+++ b/cc/test/animation_test_common.h
@@ -8,15 +8,13 @@
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/animation_timeline.h"
-#include "cc/animation/layer_animation_controller.h"
-#include "cc/animation/layer_animation_value_observer.h"
-#include "cc/animation/layer_animation_value_provider.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/output/filter_operations.h"
 #include "cc/test/geometry_test_utils.h"
 
 namespace cc {
 class AnimationPlayer;
+class ElementAnimations;
 class LayerImpl;
 class Layer;
 }
@@ -76,82 +74,21 @@ class FakeFloatTransition : public FloatAnimationCurve {
   float to_;
 };
 
-class FakeLayerAnimationValueObserver : public LayerAnimationValueObserver {
- public:
-  FakeLayerAnimationValueObserver();
-  ~FakeLayerAnimationValueObserver() override;
-
-  // LayerAnimationValueObserver implementation.
-  void OnFilterAnimated(LayerTreeType tree_type,
-                        const FilterOperations& filters) override;
-  void OnOpacityAnimated(LayerTreeType tree_type, float opacity) override;
-  void OnTransformAnimated(LayerTreeType tree_type,
-                           const gfx::Transform& transform) override;
-  void OnScrollOffsetAnimated(LayerTreeType tree_type,
-                              const gfx::ScrollOffset& scroll_offset) override;
-  void OnAnimationWaitingForDeletion() override;
-  void OnTransformIsPotentiallyAnimatingChanged(LayerTreeType tree_type,
-                                                bool is_animating) override;
-
-  const FilterOperations& filters(LayerTreeType tree_type) const {
-    return filters_[ToIndex(tree_type)];
-  }
-  float opacity(LayerTreeType tree_type) const {
-    return opacity_[ToIndex(tree_type)];
-  }
-  const gfx::Transform& transform(LayerTreeType tree_type) const {
-    return transform_[ToIndex(tree_type)];
-  }
-  gfx::ScrollOffset scroll_offset(LayerTreeType tree_type) {
-    return scroll_offset_[ToIndex(tree_type)];
-  }
-
-  bool animation_waiting_for_deletion() {
-    return animation_waiting_for_deletion_;
-  }
-
-  bool transform_is_animating(LayerTreeType tree_type) {
-    return transform_is_animating_[ToIndex(tree_type)];
-  }
-
- private:
-  static int ToIndex(LayerTreeType tree_type);
-
-  FilterOperations filters_[2];
-  float opacity_[2];
-  gfx::Transform transform_[2];
-  gfx::ScrollOffset scroll_offset_[2];
-  bool animation_waiting_for_deletion_;
-  bool transform_is_animating_[2];
-};
-
-class FakeLayerAnimationValueProvider : public LayerAnimationValueProvider {
- public:
-  gfx::ScrollOffset ScrollOffsetForAnimation() const override;
-
-  void set_scroll_offset(const gfx::ScrollOffset& scroll_offset) {
-    scroll_offset_ = scroll_offset;
-  }
-
- private:
-  gfx::ScrollOffset scroll_offset_;
-};
-
-int AddOpacityTransitionToController(LayerAnimationController* controller,
-                                     double duration,
-                                     float start_opacity,
-                                     float end_opacity,
-                                     bool use_timing_function);
+int AddOpacityTransitionToElementAnimations(ElementAnimations* target,
+                                            double duration,
+                                            float start_opacity,
+                                            float end_opacity,
+                                            bool use_timing_function);
 
-int AddAnimatedTransformToController(LayerAnimationController* controller,
-                                     double duration,
-                                     int delta_x,
-                                     int delta_y);
+int AddAnimatedTransformToElementAnimations(ElementAnimations* target,
+                                            double duration,
+                                            int delta_x,
+                                            int delta_y);
 
-int AddAnimatedFilterToController(LayerAnimationController* controller,
-                                  double duration,
-                                  float start_brightness,
-                                  float end_brightness);
+int AddAnimatedFilterToElementAnimations(ElementAnimations* target,
+                                         double duration,
+                                         float start_brightness,
+                                         float end_brightness);
 
 int AddAnimatedTransformToPlayer(AnimationPlayer* player,
                                  double duration,
@@ -174,11 +111,11 @@ int AddAnimatedFilterToPlayer(AnimationPlayer* player,
                               float start_brightness,
                               float 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);
 
 void AddAnimationToLayerWithPlayer(int layer_id,
                                    scoped_refptr<AnimationTimeline> timeline,