compositor: Tick the UI animations from cc, instead of from timer callbacks.

ui/compositor/layer_animator.h

 // Copyright (c) 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 UI_COMPOSITOR_LAYER_ANIMATOR_H_
 #define UI_COMPOSITOR_LAYER_ANIMATOR_H_
 
 #include <deque>
 #include <vector>
 
 #include "base/compiler_specific.h"
+#include "base/gtest_prod_util.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
 #include "ui/compositor/compositor_export.h"
 #include "ui/compositor/layer_animation_element.h"
-#include "ui/gfx/animation/animation_container_element.h"
 #include "ui/gfx/animation/tween.h"
 
 namespace gfx {
 class Animation;
 class Rect;
 class Transform;
 }
 
 namespace ui {
 class Layer;
 class LayerAnimationSequence;
 class LayerAnimationDelegate;
 class LayerAnimationObserver;
+class LayerAnimatorCollection;
 class ScopedLayerAnimationSettings;
 
 // When a property of layer needs to be changed it is set by way of
 // LayerAnimator. This enables LayerAnimator to animate property changes.
 // NB: during many tests, set_disable_animations_for_test is used and causes
 // all animations to complete immediately. The layer animation is ref counted
 // so that if its owning layer is deleted (and the owning layer is only other
 // class that should ever hold a ref ptr to a LayerAnimator), the animator can
 // ensure that it is not disposed of until it finishes executing. It does this
 // by holding a reference to itself for the duration of methods for which it
 // must guarantee that |this| is valid.
-class COMPOSITOR_EXPORT LayerAnimator
-    : public gfx::AnimationContainerElement,
-      public base::RefCounted<LayerAnimator> {
+class COMPOSITOR_EXPORT LayerAnimator : public base::RefCounted<LayerAnimator> {
  public:
   enum PreemptionStrategy {
     IMMEDIATELY_SET_NEW_TARGET,
     IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
     ENQUEUE_NEW_ANIMATION,
     REPLACE_QUEUED_ANIMATIONS,
     BLEND_WITH_CURRENT_ANIMATION
   };
 
   explicit LayerAnimator(base::TimeDelta transition_duration);
@@ skipping 125 matching lines @@
   // For testing purposes only.
   void set_disable_timer_for_test(bool disable_timer) {
     disable_timer_for_test_ = disable_timer;
   }
 
   void set_last_step_time(base::TimeTicks time) {
     last_step_time_ = time;
   }
   base::TimeTicks last_step_time() const { return last_step_time_; }
 
+  void Step(base::TimeTicks time_now);
+
+  void AddToCollection(LayerAnimatorCollection* collection);
+  void RemoveFromCollection(LayerAnimatorCollection* collection);
+
  protected:
   virtual ~LayerAnimator();
 
   LayerAnimationDelegate* delegate() { return delegate_; }
   const LayerAnimationDelegate* delegate() const { return delegate_; }
 
   // Virtual for testing.
   virtual void ProgressAnimation(LayerAnimationSequence* sequence,
                                  base::TimeTicks now);
 
   void ProgressAnimationToEnd(LayerAnimationSequence* sequence);
 
   // Returns true if the sequence is owned by this animator.
   bool HasAnimation(LayerAnimationSequence* sequence) const;
 
  private:
   friend class base::RefCounted<LayerAnimator>;
   friend class ScopedLayerAnimationSettings;
   friend class LayerAnimatorTestController;
+  FRIEND_TEST_ALL_PREFIXES(LayerAnimatorTest, AnimatorStartedCorrectly);
+  FRIEND_TEST_ALL_PREFIXES(LayerAnimatorTest,
+                           AnimatorRemovedFromCollectionWhenLayerIsDestroyed);
 
   class RunningAnimation {
    public:
     RunningAnimation(const base::WeakPtr<LayerAnimationSequence>& sequence);
     ~RunningAnimation();
 
     bool is_sequence_alive() const { return !!sequence_.get(); }
     LayerAnimationSequence* sequence() const { return sequence_.get(); }
 
    private:
     base::WeakPtr<LayerAnimationSequence> sequence_;
 
     // Copy and assign are allowed.
   };
 
   typedef std::vector<RunningAnimation> RunningAnimations;
   typedef std::deque<linked_ptr<LayerAnimationSequence> > AnimationQueue;
 
-  // 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;
-
   // Finishes all animations by either advancing them to their final state or by
   // aborting them.
   void StopAnimatingInternal(bool abort);
 
   // Starts or stops stepping depending on whether thare are running animations.
   void UpdateAnimationState();
 
   // Removes the sequences from both the running animations and the queue.
   // Returns a pointer to the removed animation, if any. NOTE: the caller is
   // responsible for deleting the returned pointer.
@@ skipping 57 matching lines @@
   // Sets |transition_duration_| unless |is_transition_duration_locked_| is set.
   void SetTransitionDuration(base::TimeDelta duration);
 
   // Clears the animation queues and notifies any running animations that they
   // have been aborted.
   void ClearAnimationsInternal();
 
   // Cleans up any running animations that may have been deleted.
   void PurgeDeletedAnimations();
 
+  LayerAnimatorCollection* GetLayerAnimatorCollection();
+
   // This is the queue of animations to run.
   AnimationQueue animation_queue_;
 
   // The target of all layer animations.
   LayerAnimationDelegate* delegate_;
 
   // The currently running animations.
   RunningAnimations running_animations_;
 
   // Determines how animations are replaced.
@@ skipping 26 matching lines @@
   // Observers are notified when layer animations end, are scheduled or are
   // aborted.
   ObserverList<LayerAnimationObserver> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerAnimator);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_ANIMATOR_H_