1 files changed, 155 insertions, 74 deletions

diff --git a/ui/gfx/compositor/layer_animator.h b/ui/gfx/compositor/layer_animator.h
index 52b8870..a51079c 100644
--- a/ui/gfx/compositor/layer_animator.h
+++ b/ui/gfx/compositor/layer_animator.h
@@ -6,119 +6,200 @@
 #define UI_GFX_COMPOSITOR_LAYER_ANIMATOR_H_
 #pragma once
 
-#include <map>
+#include <deque>
+#include <vector>
 
-#include "base/basictypes.h"
-#include "base/compiler_specific.h"
+#include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
-#include "third_party/skia/include/core/SkScalar.h"
-#include "third_party/skia/include/utils/SkMatrix44.h"
-#include "ui/base/animation/animation_delegate.h"
+#include "base/time.h"
+#include "ui/base/animation/animation_container_element.h"
 #include "ui/gfx/compositor/compositor_export.h"
+#include "ui/gfx/compositor/layer_animation_element.h"
 
 namespace gfx {
-class Point;
+class Rect;
 }
 
 namespace ui {
-
 class Animation;
 class Layer;
-class LayerAnimatorDelegate;
+class LayerAnimationSequence;
 class Transform;
 
-// LayerAnimator manages animating various properties of a Layer.
-class COMPOSITOR_EXPORT LayerAnimator : public ui::AnimationDelegate {
+// When a property of layer needs to be changed it is set by way of
+// LayerAnimator. This enables LayerAnimator to animate property
+// changes.
+class COMPOSITOR_EXPORT LayerAnimator : public AnimationContainerElement {
  public:
-  // Types of properties that can be animated.
-  enum AnimationProperty {
-    LOCATION,
-    OPACITY,
-    TRANSFORM,
+  enum PreemptionStrategy {
+    IMMEDIATELY_SET_NEW_TARGET,
+    IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
+    ENQUEUE_NEW_ANIMATION,
+    REPLACE_QUEUED_ANIMATIONS,
+    BLEND_WITH_CURRENT_ANIMATION
   };
 
-  explicit LayerAnimator(Layer* layer);
+  explicit LayerAnimator(base::TimeDelta transition_duration);
   virtual ~LayerAnimator();
 
-  // Sets the animation to use. LayerAnimator takes ownership of the animation.
-  void SetAnimation(Animation* animation);
+  // No implicit animations when properties are set.
+  static LayerAnimator* CreateDefaultAnimator();
+
+  // Implicitly animates when properties are set.
+  static LayerAnimator* CreateImplicitAnimator();
+
+  // Sets the transform on the delegate. May cause an implicit animation.
+  virtual void SetTransform(const Transform& transform);
+
+  // Sets the bounds on the delegate. May cause an implicit animation.
+  virtual void SetBounds(const gfx::Rect& bounds);
+
+  // Sets the opacity on the delegate. May cause an implicit animation.
+  virtual void SetOpacity(float opacity);
+
+  // Sets the layer animation delegate the animator is associated with. The
+  // animator does not own the delegate.
+  void SetDelegate(LayerAnimationDelegate* delegate);
 
-  ui::Layer* layer() { return layer_; }
+  // Sets the animation preemption strategy. This determines the behaviour if
+  // a property is set during an animation. The default is
+  // IMMEDIATELY_SET_NEW_TARGET (see ImmediatelySetNewTarget below).
+  void set_preemption_strategy(PreemptionStrategy strategy) {
+    preemption_strategy_ = strategy;
+  }
 
-  // Animates the layer to the specified point. The point is relative to the
-  // parent layer.
-  void AnimateToPoint(const gfx::Point& target);
+  // Start an animation sequence. If an animation for the same property is in
+  // progress, it needs to be interrupted with the new animation. The animator
+  // takes ownership of this animation sequence.
+  void StartAnimation(LayerAnimationSequence* animation);
 
-  // Animates the transform from the current transform to |transform|.
-  void AnimateTransform(const Transform& transform);
+  // Schedule an animation to be run when possible. The animator takes ownership
+  // of this animation sequence.
+  void ScheduleAnimation(LayerAnimationSequence* animation);
 
-  // Animates the opacity from the current opacity to |target_opacity|.
-  void AnimateOpacity(float target_opacity);
+  // Schedules the animations to be run together. Obviously will no work if
+  // they animate any common properties. The animator takes ownership of the
+  // animation sequences.
+  void ScheduleTogether(const std::vector<LayerAnimationSequence*>& animations);
 
-  // Returns the target value for the specified type. If the specified property
-  // is not animating, the current value is returned.
-  gfx::Point GetTargetPoint();
-  float GetTargetOpacity();
-  ui::Transform GetTargetTransform();
+  // Returns true if there is an animation in the queue (animations remain in
+  // the queue until they complete).
+  bool is_animating() const { return !animation_queue_.empty(); }
 
-  // Returns true if animating |property|.
-  bool IsAnimating(AnimationProperty property) const;
+  // Stops animating the given property. No effect if there is no running
+  // animation for the given property. Skips to the final state of the
+  // animation.
+  void StopAnimatingProperty(
+      LayerAnimationElement::AnimatableProperty property);
 
-  // Returns true if the animation is running.
-  bool IsRunning() const;
+  // Stops all animation and clears any queued animations.
+  void StopAnimating();
 
-  // Returns true if the animation has progressed at least once since
-  // SetAnimation() was invoked.
-  bool got_initial_tick() const { return got_initial_tick_; }
+  // For testing purposes only.
+  void set_disable_timer_for_test(bool enabled) {
+    disable_timer_for_test_ = enabled;
+  }
+  base::TimeTicks get_last_step_time_for_test() { return last_step_time_; }
 
-  // AnimationDelegate:
-  virtual void AnimationProgressed(const Animation* animation) OVERRIDE;
-  virtual void AnimationEnded(const Animation* animation) OVERRIDE;
+ protected:
+  LayerAnimationDelegate* delegate() { return delegate_; }
 
  private:
-  // Parameters used when animating the location.
-  struct LocationParams {
-    int start_x;
-    int start_y;
-    int target_x;
-    int target_y;
+  // We need to keep track of the start time of every running animation.
+  struct RunningAnimation {
+    RunningAnimation(LayerAnimationSequence* sequence,
+                     base::TimeTicks start_time)
+        : sequence(sequence),
+          start_time(start_time) {
+    }
+    LayerAnimationSequence* sequence;
+    base::TimeTicks start_time;
   };
 
-  // Parameters used when animating the transform.
-  struct TransformParams {
-    SkMScalar start[16];
-    SkMScalar target[16];
-  };
+  typedef std::vector<RunningAnimation> RunningAnimations;
+  typedef std::deque<linked_ptr<LayerAnimationSequence> > AnimationQueue;
 
-  // Parameters used when animating the opacity.
-  struct OpacityParams {
-    float start;
-    float target;
-  };
+  // Implementation of AnimationContainerElement
+  virtual void SetStartTime(base::TimeTicks start_time) OVERRIDE;
+  virtual void Step(base::TimeTicks time_now) OVERRIDE;
+  virtual base::TimeDelta GetTimerInterval() const OVERRIDE;
 
-  union Params {
-    LocationParams location;
-    OpacityParams opacity;
-    TransformParams transform;
-  };
+  // Starts or stops stepping depending on whether thare are running animations.
+  void UpdateAnimationState();
+
+  // Removes the sequences from both the running animations and the queue.
+  void RemoveAnimation(LayerAnimationSequence* sequence);
+
+  // Progresses to the end of the sequence before removing it.
+  void FinishAnimation(LayerAnimationSequence* sequence);
+
+  // Finishes any running animation with zero duration.
+  void FinishAnyAnimationWithZeroDuration();
+
+  // Clears the running animations and the queue. No sequences are progressed.
+  void ClearAnimations();
+
+  // Returns the running animation animating the given property, if any.
+  RunningAnimation* GetRunningAnimation(
+      LayerAnimationElement::AnimatableProperty property);
+
+  // Checks if the sequence has already been added to the queue and adds it
+  // to the front if note.
+  void AddToQueueIfNotPresent(LayerAnimationSequence* sequence);
+
+  // Any running or queued animation that affects a property in common with
+  // |sequence| is either finished or aborted depending on |abort|.
+  void RemoveAllAnimationsWithACommonProperty(LayerAnimationSequence* sequence,
+                                              bool abort);
+
+  // Preempts a running animation by progressing both the running animation and
+  // the given sequence to the end.
+  void ImmediatelySetNewTarget(LayerAnimationSequence* sequence);
+
+  // Preempts by aborting the running animation, and starts the given animation.
+  void ImmediatelyAnimateToNewTarget(LayerAnimationSequence* sequence);
+
+  // Preempts by adding the new animation to the queue.
+  void EnqueueNewAnimation(LayerAnimationSequence* sequence);
+
+  // Preempts by wiping out any unstarted animation in the queue and then
+  // enqueuing this animation.
+  void ReplaceQueuedAnimations(LayerAnimationSequence* sequence);
+
+  // If there's an animation in the queue that doesn't animate the same property
+  // as a running animation, or an animation schedule to run before it, start it
+  // up. Repeat until there are no such animations.
+  void ProcessQueue();
+
+  // Attempts to add the sequence to the list of running animations. Returns
+  // false if there is an animation running that already animates one of the
+  // properties affected by |sequence|.
+  bool StartSequenceImmediately(LayerAnimationSequence* sequence);
+
+  // This is the queue of animations to run.
+  AnimationQueue animation_queue_;
 
-  typedef std::map<AnimationProperty, Params> Elements;
+  // The target of all layer animations.
+  LayerAnimationDelegate* delegate_;
 
-  // Stops animating the specified property. This does not set the property
-  // being animated to its final value.
-  void StopAnimating(AnimationProperty property);
+  // The currently running animations.
+  RunningAnimations running_animations_;
 
-  LayerAnimatorDelegate* delegate();
+  // Determines how animations are replaced.
+  PreemptionStrategy preemption_strategy_;
 
-  // The layer.
-  Layer* layer_;
+  // The default length of animations.
+  base::TimeDelta transition_duration_;
 
-  // Properties being animated.
-  Elements elements_;
+  // Used for coordinating the starting of animations.
+  base::TimeTicks last_step_time_;
 
-  scoped_ptr<ui::Animation> animation_;
+  // True if we are being stepped by our container.
+  bool is_started_;
 
-  bool got_initial_tick_;
+  // This prevents the animator from automatically stepping through animations
+  // and allows for manual stepping.
+  bool disable_timer_for_test_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerAnimator);
 };