CC: Add fill mode to compositor animations

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"
@@ skipping 33 matching lines @@
     Opacity,
     Filter,
     ScrollOffset,
     BackgroundColor,
     // This sentinel must be last.
     TargetPropertyEnumSize
   };
 
   enum Direction { Normal, Reverse, Alternate, AlternateReverse };
 
+  enum FillMode {
+    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_; }
   int group() const { return group_; }
   TargetProperty target_property() const { return target_property_; }
@@ skipping 23 matching lines @@
   void set_time_offset(base::TimeDelta monotonic_time) {
     time_offset_ = monotonic_time;
   }
 
   void Suspend(base::TimeTicks monotonic_time);
   void Resume(base::TimeTicks monotonic_time);
 
   Direction direction() { return direction_; }
   void set_direction(Direction direction) { direction_ = direction; }
 
+  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_ == 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) {
@@ skipping 31 matching lines @@
     affects_pending_observers_ = affects_pending_observers;
   }
   bool affects_pending_observers() const { return affects_pending_observers_; }
 
  private:
   Animation(scoped_ptr<AnimationCurve> curve,
             int animation_id,
             int group_id,
             TargetProperty target_property);
 
+  double ConvertToActiveTime(base::TimeTicks monotonic_time) const;
+
   scoped_ptr<AnimationCurve> curve_;
 
   // IDs are not necessarily unique.
   int 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 group_;
 
   TargetProperty target_property_;
   RunState run_state_;
   double iterations_;
   double iteration_start_;
   base::TimeTicks start_time_;
   Direction direction_;
   double playback_rate_;
+  FillMode fill_mode_;
 
   // The time offset effectively pushes the start of the animation back in time.
   // This is used for resuming paused animations -- an animation is added with a
   // non-zero time offset, causing the animation to skip ahead to the desired
   // point in time.
   base::TimeDelta time_offset_;
 
   bool needs_synchronized_start_time_;
   bool received_finished_event_;
 
@@ skipping 33 matching lines @@
   // 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_