Revert "Pull chromium at 2c3ffb2355a27c32f45e508ef861416b820c823b"

cc/animation/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 CC_ANIMATION_ANIMATION_H_
 #define CC_ANIMATION_ANIMATION_H_
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "cc/base/cc_export.h"
 
 namespace cc {
 
 class AnimationCurve;
 
 // An Animation contains all the state required to play an AnimationCurve.
 // Specifically, the affected property, the run state (paused, finished, etc.),
 // loop count, last pause time, and the total time spent paused.
 class CC_EXPORT Animation {
  public:
-  // Animations begin in the 'WAITING_FOR_TARGET_AVAILABILITY' state. An
-  // Animation waiting for target availibility will run as soon as its target
-  // property is free (and all the animations animating with it are also able to
-  // run). When this time arrives, the controller will move the animation into
-  // the STARTING state, and then 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.
+  // Animations begin in the 'WaitingForTargetAvailability' state. An Animation
+  // waiting for target availibility will run as soon as its target property
+  // is free (and all the animations animating with it are also able to run).
+  // When this time arrives, the controller will move the animation into the
+  // Starting state, and then 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.
   enum RunState {
-    WAITING_FOR_TARGET_AVAILABILITY = 0,
-    WAITING_FOR_DELETION,
-    STARTING,
-    RUNNING,
-    PAUSED,
-    FINISHED,
-    ABORTED,
+    WaitingForTargetAvailability = 0,
+    WaitingForDeletion,
+    Starting,
+    Running,
+    Paused,
+    Finished,
+    Aborted,
     // This sentinel must be last.
-    LAST_RUN_STATE = ABORTED
+    RunStateEnumSize
   };
 
   enum TargetProperty {
-    TRANSFORM = 0,
-    OPACITY,
-    FILTER,
-    SCROLL_OFFSET,
-    BACKGROUND_COLOR,
+    Transform = 0,
+    Opacity,
+    Filter,
+    ScrollOffset,
+    BackgroundColor,
     // This sentinel must be last.
-    LAST_TARGET_PROPERTY = BACKGROUND_COLOR
+    TargetPropertyEnumSize
   };
 
-  enum Direction {
-    DIRECTION_NORMAL,
-    DIRECTION_REVERSE,
-    DIRECTION_ALTERNATE,
-    DIRECTION_ALTERNATE_REVERSE
-  };
+  enum Direction { Normal, Reverse, Alternate, AlternateReverse };
 
   enum FillMode {
-    FILL_MODE_NONE,
-    FILL_MODE_FORWARDS,
-    FILL_MODE_BACKWARDS,
-    FILL_MODE_BOTH
+    FillModeNone,
+    FillModeForwards,
+    FillModeBackwards,
+    FillModeBoth
   };
 
   static scoped_ptr<Animation> Create(scoped_ptr<AnimationCurve> curve,
                                       int animation_id,
                                       int group_id,
                                       TargetProperty target_property);
 
   virtual ~Animation();
 
   int id() const { return id_; }
@@ skipping 35 matching lines @@
   FillMode fill_mode() { return fill_mode_; }
   void set_fill_mode(FillMode fill_mode) { fill_mode_ = fill_mode; }
 
   double playback_rate() { return playback_rate_; }
   void set_playback_rate(double playback_rate) {
     playback_rate_ = playback_rate;
   }
 
   bool IsFinishedAt(base::TimeTicks monotonic_time) const;
   bool is_finished() const {
-    return run_state_ == FINISHED || run_state_ == ABORTED ||
-           run_state_ == WAITING_FOR_DELETION;
+    return run_state_ == Finished ||
+        run_state_ == Aborted ||
+        run_state_ == WaitingForDeletion;
   }
 
   bool InEffect(base::TimeTicks monotonic_time) const;
 
   AnimationCurve* curve() { return curve_.get(); }
   const AnimationCurve* curve() const { return 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 needs_synchronized_start_time() const {
     return needs_synchronized_start_time_;
   }
   void set_needs_synchronized_start_time(bool needs_synchronized_start_time) {
     needs_synchronized_start_time_ = needs_synchronized_start_time;
   }
 
-  // This is true for animations running on the main thread when the FINISHED
+  // This is true for animations running on the main thread when the Finished
   // event sent by the corresponding impl animation has been received.
   bool received_finished_event() const {
     return received_finished_event_;
   }
   void set_received_finished_event(bool received_finished_event) {
     received_finished_event_ = received_finished_event;
   }
 
   // Takes the given absolute time, and using the start time and the number
   // of iterations, returns the relative time in the current iteration.
@@ skipping 75 matching lines @@
   // 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 is_controlling_instance_;
 
   bool is_impl_only_;
 
   // When pushed from a main-thread controller to a compositor-thread
   // controller, an animation will initially only affect pending observers
   // (corresponding to layers in the pending tree). Animations that only
-  // affect pending observers are able to reach the STARTING state and tick
+  // affect pending observers are able to reach the Starting state and tick
   // pending observers, but cannot proceed any further and do not tick active
   // observers. After activation, such animations affect both kinds of observers
-  // and are able to proceed past the STARTING state. When the removal of
+  // and are able to proceed past the Starting state. When the removal of
   // an animation is pushed from a main-thread controller to a
   // compositor-thread controller, this initially only makes the animation
   // stop affecting pending observers. After activation, such animations no
   // longer affect any observers, and are deleted.
   bool affects_active_observers_;
   bool affects_pending_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(Animation);
 };
 
 }  // namespace cc
 
 #endif  // CC_ANIMATION_ANIMATION_H_