CC Animation: Replace AnimiationEventsVector with AnimiationEvents class.

cc/animation/layer_animation_controller.h

 // 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.
 
 #ifndef CC_ANIMATION_LAYER_ANIMATION_CONTROLLER_H_
 #define CC_ANIMATION_LAYER_ANIMATION_CONTROLLER_H_
 
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
-#include "cc/animation/animation_events.h"
+#include "cc/animation/animation.h"
 #include "cc/animation/layer_animation_event_observer.h"
 #include "cc/base/cc_export.h"
 #include "ui/gfx/geometry/scroll_offset.h"
 #include "ui/gfx/transform.h"
 
 namespace gfx {
 class BoxF;
 class Transform;
 }
 
 namespace cc {
 
-class Animation;
 class AnimationDelegate;
+class AnimationEvents;
 class AnimationRegistrar;
 class FilterOperations;
 class KeyframeValueList;
 class LayerAnimationValueObserver;
 class LayerAnimationValueProvider;
 
 class CC_EXPORT LayerAnimationController
     : public base::RefCounted<LayerAnimationController> {
  public:
   enum class ObserverType { ACTIVE, PENDING };
@@ skipping 11 matching lines @@
   void AbortAnimations(Animation::TargetProperty target_property);
 
   // Ensures that the list of active animations on the main thread and the impl
   // thread are kept in sync. This function does not take ownership of the impl
   // thread controller. This method is virtual for testing.
   virtual void PushAnimationUpdatesTo(
       LayerAnimationController* controller_impl);
 
   void Animate(base::TimeTicks monotonic_time);
   void AccumulatePropertyUpdates(base::TimeTicks monotonic_time,
-                                 AnimationEventsVector* events);
+                                 AnimationEvents* events);
 
-  void UpdateState(bool start_ready_animations,
-                   AnimationEventsVector* events);
+  void UpdateState(bool start_ready_animations, AnimationEvents* events);
 
   // Make animations affect active observers if and only if they affect
   // pending observers. Any animations that no longer affect any observers
   // are deleted.
   void ActivateAnimations();
 
   // Returns the active animation animating the given property that is either
   // running, or is next to run, if such an animation exists.
   Animation* GetAnimation(Animation::TargetProperty target_property) const;
 
@@ skipping 107 matching lines @@
   void PushNewAnimationsToImplThread(
       LayerAnimationController* controller_impl) const;
   void MarkAbortedAnimationsForDeletion(
       LayerAnimationController* controller_impl) const;
   void RemoveAnimationsCompletedOnMainThread(
       LayerAnimationController* controller_impl) const;
   void PushPropertiesToImplThread(LayerAnimationController* controller_impl);
 
   void StartAnimations(base::TimeTicks monotonic_time);
   void PromoteStartedAnimations(base::TimeTicks monotonic_time,
-                                AnimationEventsVector* events);
+                                AnimationEvents* events);
   void MarkFinishedAnimations(base::TimeTicks monotonic_time);
   void MarkAnimationsForDeletion(base::TimeTicks monotonic_time,
-                                 AnimationEventsVector* events);
+                                 AnimationEvents* events);
   void PurgeAnimationsMarkedForDeletion();
 
   void TickAnimations(base::TimeTicks monotonic_time);
 
   enum UpdateActivationType { NORMAL_ACTIVATION, FORCE_ACTIVATION };
   void UpdateActivation(UpdateActivationType type);
 
   void NotifyObserversOpacityAnimated(float opacity,
                                       bool notify_active_observers,
                                       bool notify_pending_observers);
@@ skipping 43 matching lines @@
 
   bool potentially_animating_transform_for_active_observers_;
   bool potentially_animating_transform_for_pending_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerAnimationController);
 };
 
 }  // namespace cc
 
 #endif  // CC_ANIMATION_LAYER_ANIMATION_CONTROLLER_H_