Rename ActiveAnimation -> Animation

cc/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_LAYER_ANIMATION_CONTROLLER_H_
 #define CC_LAYER_ANIMATION_CONTROLLER_H_
 
 #include "base/basictypes.h"
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
@@ skipping 19 matching lines @@
 
 class CC_EXPORT LayerAnimationController
     : public base::RefCounted<LayerAnimationController>,
       public LayerAnimationEventObserver {
 public:
     static scoped_refptr<LayerAnimationController> create(int id);
 
     int id() const { return m_id; }
 
     // These methods are virtual for testing.
-    virtual void addAnimation(scoped_ptr<ActiveAnimation>);
+    virtual void addAnimation(scoped_ptr<Animation>);
     virtual void pauseAnimation(int animationId, double timeOffset);
     virtual void removeAnimation(int animationId);
-    virtual void removeAnimation(int animationId, ActiveAnimation::TargetProperty);
+    virtual void removeAnimation(int animationId, Animation::TargetProperty);
     virtual void suspendAnimations(double monotonicTime);
     virtual void resumeAnimations(double monotonicTime);
 
     // 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.
     virtual void pushAnimationUpdatesTo(LayerAnimationController*);
 
     void animate(double monotonicTime, AnimationEventsVector*);
 
     // Returns the active animation in the given group, animating the given property, if such an
     // animation exists.
-    ActiveAnimation* getActiveAnimation(int groupId, ActiveAnimation::TargetProperty) const;
+    Animation* getAnimation(int groupId, Animation::TargetProperty) const;
 
     // Returns the active animation animating the given property that is either running, or is
     // next to run, if such an animation exists.
-    ActiveAnimation* getActiveAnimation(ActiveAnimation::TargetProperty) const;
+    Animation* getAnimation(Animation::TargetProperty) const;
 
     // Returns true if there are any animations that have neither finished nor aborted.
     bool hasActiveAnimation() const;
 
     // Returns true if there are any animations at all to process.
     bool hasAnyAnimation() const { return !m_activeAnimations.isEmpty(); }
 
     // Returns true if there is an animation currently animating the given property, or
     // if there is an animation scheduled to animate this property in the future.
-    bool isAnimatingProperty(ActiveAnimation::TargetProperty) const;
+    bool isAnimatingProperty(Animation::TargetProperty) const;
 
     // This is called in response to an animation being started on the impl thread. This
     // function updates the corresponding main thread animation's start time.
     virtual void OnAnimationStarted(const AnimationEvent&) OVERRIDE;
 
     // If a sync is forced, then the next time animation updates are pushed to the impl
     // thread, all animations will be transferred.
     void setForceSync() { m_forceSync = true; }
 
     void setAnimationRegistrar(AnimationRegistrar*);
@@ skipping 27 matching lines @@
     void updateActivation(bool force = false);
 
     void notifyObserversOpacityAnimated(float opacity);
     void notifyObserversTransformAnimated(const gfx::Transform& transform);
 
     // If this is true, we force a sync to the impl thread.
     bool m_forceSync;
 
     AnimationRegistrar* m_registrar;
     int m_id;
-    ScopedPtrVector<ActiveAnimation> m_activeAnimations;
+    ScopedPtrVector<Animation> m_activeAnimations;
 
     // This is used to ensure that we don't spam the registrar.
     bool m_isActive;
 
     ObserverList<LayerAnimationValueObserver> m_observers;
 
     DISALLOW_COPY_AND_ASSIGN(LayerAnimationController);
 };
 
 } // namespace cc
 
 #endif  // CC_LAYER_ANIMATION_CONTROLLER_H_