cc: Rename cc classes and members to match filenames

cc/active_animation.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 CCActiveAnimation_h
 #define CCActiveAnimation_h
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 
 namespace cc {
 
-class CCAnimationCurve;
+class AnimationCurve;
 
-// A CCActiveAnimation, contains all the state required to play a CCAnimationCurve.
+// A ActiveAnimation, contains all the state required to play a AnimationCurve.

[enne (OOO), 2012/10/18 01:28:32]

Surprisingly, this seems like the only grammar issue in comments caused by this
search and replace.  I'll fix this.

 // Specifically, the affected property, the run state (paused, finished, etc.),
 // loop count, last pause time, and the total time spent paused.
-class CCActiveAnimation {
+class ActiveAnimation {
 public:
     // Animations begin in one of the 'waiting' states. Animations waiting for the next tick
     // will start the next time the controller animates. Animations waiting for target
     // availibility will run as soon as their target property is free (and all the animations
     // animating with it are also able to run). Animations waiting for their start time to
     // come have be scheduled to run at a particular point in time. When this time arrives,
     // the controller will move the animations into the Running state. Running animations
     // may toggle between Running and Paused, and may be stopped by moving into either the
     // Aborted or Finished states. A Finished animation was allowed to run to completion, but
     // an Aborted animation was not.
@@ skipping 10 matching lines @@
         RunStateEnumSize
     };
 
     enum TargetProperty {
         Transform = 0,
         Opacity,
         // This sentinel must be last.
         TargetPropertyEnumSize
     };
 
-    static scoped_ptr<CCActiveAnimation> create(scoped_ptr<CCAnimationCurve>, int animationId, int groupId, TargetProperty);
+    static scoped_ptr<ActiveAnimation> create(scoped_ptr<AnimationCurve>, int animationId, int groupId, TargetProperty);
 
-    virtual ~CCActiveAnimation();
+    virtual ~ActiveAnimation();
 
     int id() const { return m_id; }
     int group() const { return m_group; }
     TargetProperty targetProperty() const { return m_targetProperty; }
 
     RunState runState() const { return m_runState; }
     void setRunState(RunState, double monotonicTime);
 
     // This is the number of times that the animation will play. If this
     // value is zero the animation will not play. If it is negative, then
@@ skipping 13 matching lines @@
 
     // If alternatesDirection is true, on odd numbered iterations we reverse the curve.
     bool alternatesDirection() const { return m_alternatesDirection; }
     void setAlternatesDirection(bool alternates) { m_alternatesDirection = alternates; }
 
     bool isFinishedAt(double monotonicTime) const;
     bool isFinished() const { return m_runState == Finished
                                   || m_runState == Aborted
                                   || m_runState == WaitingForDeletion; }
 
-    CCAnimationCurve* curve() { return m_curve.get(); }
-    const CCAnimationCurve* curve() const { return m_curve.get(); }
+    AnimationCurve* curve() { return m_curve.get(); }
+    const AnimationCurve* curve() const { return m_curve.get(); }
 
     // If this is true, even if the animation is running, it will not be tickable until
     // it is given a start time. This is true for animations running on the main thread.
     bool needsSynchronizedStartTime() const { return m_needsSynchronizedStartTime; }
     void setNeedsSynchronizedStartTime(bool needsSynchronizedStartTime) { m_needsSynchronizedStartTime = needsSynchronizedStartTime; }
 
     // Takes the given absolute time, and using the start time and the number
     // of iterations, returns the relative time in the current iteration.
     double trimTimeToCurrentIteration(double monotonicTime) const;
 
     enum InstanceType {
         ControllingInstance = 0,
         NonControllingInstance
     };
 
-    scoped_ptr<CCActiveAnimation> clone(InstanceType) const;
-    scoped_ptr<CCActiveAnimation> cloneAndInitialize(InstanceType, RunState initialRunState, double startTime) const;
+    scoped_ptr<ActiveAnimation> clone(InstanceType) const;
+    scoped_ptr<ActiveAnimation> cloneAndInitialize(InstanceType, RunState initialRunState, double startTime) const;
     bool isControllingInstance() const { return m_isControllingInstance; }
 
-    void pushPropertiesTo(CCActiveAnimation*) const;
+    void pushPropertiesTo(ActiveAnimation*) const;
 
 private:
-    CCActiveAnimation(scoped_ptr<CCAnimationCurve>, int animationId, int groupId, TargetProperty);
+    ActiveAnimation(scoped_ptr<AnimationCurve>, int animationId, int groupId, TargetProperty);
 
-    scoped_ptr<CCAnimationCurve> m_curve;
+    scoped_ptr<AnimationCurve> m_curve;
 
     // IDs are not necessarily unique.
     int m_id;
 
     // Animations that must be run together are called 'grouped' and have the same group id
     // Grouped animations are guaranteed to start at the same time and no other animations
     // may animate any of the group's target properties until all animations in the
     // group have finished animating. Note: an active animation's group id and target
     // property uniquely identify that animation.
     int m_group;
@@ skipping 17 matching lines @@
 
     // These are used in trimTimeToCurrentIteration to account for time
     // spent while paused. This is not included in AnimationState since it
     // there is absolutely no need for clients of this controller to know
     // about these values.
     double m_pauseTime;
     double m_totalPausedTime;
 
     // Animations lead dual lives. An active animation will be conceptually owned by
     // two controllers, one on the impl thread and one on the main. In reality, there
-    // will be two separate CCActiveAnimation instances for the same animation. They
+    // will be two separate ActiveAnimation instances for the same animation. They
     // will have the same group id and the same target property (these two values
     // uniquely identify an animation). The instance on the impl thread is the instance
     // that ultimately controls the values of the animating layer and so we will refer
     // to it as the 'controlling instance'.
     bool m_isControllingInstance;
 
-    DISALLOW_COPY_AND_ASSIGN(CCActiveAnimation);
+    DISALLOW_COPY_AND_ASSIGN(ActiveAnimation);
 };
 
 } // namespace cc
 
 #endif // CCActiveAnimation_h