NOT READY FOR REVIEW - Add support for custom animation timers.

ui/compositor/layer_animator.cc

 // 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.
 
 #include "ui/compositor/layer_animator.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/base/animation/animation_container.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animation_sequence.h"
+#include "ui/compositor/layer_animation_timer.h"
 
 #define SAFE_INVOKE_VOID(function, running_anim, ...) \
     if (running_anim.is_sequence_alive()) \
       function(running_anim.sequence(), ##__VA_ARGS__)
 #define SAFE_INVOKE_BOOL(function, running_anim) \
     ((running_anim.is_sequence_alive()) \
         ? function(running_anim.sequence()) \
         : false)
 #define SAFE_INVOKE_PTR(function, running_anim) \
     ((running_anim.is_sequence_alive()) \
         ? function(running_anim.sequence()) \
         : NULL)
 
 namespace ui {
 
 class LayerAnimator;
 
 namespace {
 
 static const base::TimeDelta kDefaultTransitionDuration =
     base::TimeDelta::FromMilliseconds(120);
 
 static const base::TimeDelta kTimerInterval =
     base::TimeDelta::FromMilliseconds(10);
 
-// Returns the AnimationContainer we're added to.
-ui::AnimationContainer* GetAnimationContainer() {
-  static ui::AnimationContainer* container = NULL;
-  if (!container) {
-    container = new AnimationContainer();
-    container->AddRef();
+// The default timer is simply a thin wrapper around an AnimationContainer.
+class DefaultLayerAnimationTimer : public LayerAnimationTimer {
+ public:
+  DefaultLayerAnimationTimer() : container_(new AnimationContainer()) {
   }
-  return container;
+
+ private:
+  // LayerAnimationTimer implementation.
+  virtual void Start(AnimationContainerElement* element) {
+    container_->Start(element);
+  }
+
+  virtual void Stop(AnimationContainerElement* element) {
+    container_->Stop(element);
+  }
+
+  virtual base::TimeTicks last_tick_time() const {
+    return container_->last_tick_time();
+  }
+
+  virtual bool is_running() const {
+    return container_->is_running();
+  }
+
+  scoped_refptr<AnimationContainer> container_;
+
+  DISALLOW_COPY_AND_ASSIGN(DefaultLayerAnimationTimer);
+};
+
+static LayerAnimationTimer* s_timer = NULL;
+
+// Returns the LayerAnimationTimer we're added to.
+static LayerAnimationTimer* GetAnimationTimer() {
+  if (!s_timer)
+    s_timer = new DefaultLayerAnimationTimer();
+  return s_timer;
 }
 
 }  // namespace
 
 // static
 bool LayerAnimator::disable_animations_for_test_ = false;
 // static
 bool LayerAnimator::slow_animation_mode_ = false;
 // static
 int LayerAnimator::slow_animation_scale_factor_ = 4;
@@ skipping 115 matching lines @@
   if (preemption_strategy_ == IMMEDIATELY_SET_NEW_TARGET) {
     std::vector<LayerAnimationSequence*>::const_iterator iter;
     for (iter = animations.begin(); iter != animations.end(); ++iter) {
       StartAnimation(*iter);
     }
     return;
   }
 
   adding_animations_ = true;
   if (!is_animating()) {
-    if (GetAnimationContainer()->is_running())
-      last_step_time_ = GetAnimationContainer()->last_tick_time();
+    if (GetAnimationTimer()->is_running())
+      last_step_time_ = GetAnimationTimer()->last_tick_time();
     else
       last_step_time_ = base::TimeTicks::Now();
   }
 
   // Collect all the affected properties.
   LayerAnimationElement::AnimatableProperties animated_properties;
   std::vector<LayerAnimationSequence*>::const_iterator iter;
   for (iter = animations.begin(); iter != animations.end(); ++iter) {
     animated_properties.insert((*iter)->properties().begin(),
                                (*iter)->properties().end());
@@ skipping 120 matching lines @@
 
 void LayerAnimator::RemoveObserver(LayerAnimationObserver* observer) {
   observers_.RemoveObserver(observer);
   // Remove the observer from all sequences as well.
   for (AnimationQueue::iterator queue_iter = animation_queue_.begin();
        queue_iter != animation_queue_.end(); ++queue_iter) {
     (*queue_iter)->RemoveObserver(observer);
   }
 }
 
+// static
+void LayerAnimator::SetAnimationTimer(LayerAnimationTimer* timer) {
+  if (s_timer && s_timer != timer)
+    delete s_timer;
+  s_timer = timer;
+}
+
 // LayerAnimator protected -----------------------------------------------------
 
 void LayerAnimator::ProgressAnimation(LayerAnimationSequence* sequence,
                                       base::TimeDelta delta) {
   if (!delegate())
     return;
 
   sequence->Progress(delta, delegate());
 }
 
@@ skipping 45 matching lines @@
 base::TimeDelta LayerAnimator::GetTimerInterval() const {
   return kTimerInterval;
 }
 
 void LayerAnimator::UpdateAnimationState() {
   if (disable_timer_for_test_)
     return;
 
   const bool should_start = is_animating();
   if (should_start && !is_started_)
-    GetAnimationContainer()->Start(this);
+    GetAnimationTimer()->Start(this);
   else if (!should_start && is_started_)
-    GetAnimationContainer()->Stop(this);
+    GetAnimationTimer()->Stop(this);
 
   is_started_ = should_start;
 }
 
 LayerAnimationSequence* LayerAnimator::RemoveAnimation(
     LayerAnimationSequence* sequence) {
   linked_ptr<LayerAnimationSequence> to_return;
 
   // First remove from running animations
   for (RunningAnimations::iterator iter = running_animations_.begin();
@@ skipping 265 matching lines @@
   // All clear, actually start the sequence. Note: base::TimeTicks::Now has
   // a resolution that can be as bad as 15ms. If this causes glitches in the
   // animations, this can be switched to HighResNow() (animation uses Now()
   // internally).
   // All LayerAnimators share the same AnimationContainer. Use the
   // last_tick_time() from there to ensure animations started during the same
   // event complete at the same time.
   base::TimeTicks start_time;
   if (is_animating() || adding_animations_)
     start_time = last_step_time_;
-  else if (GetAnimationContainer()->is_running())
-    start_time = GetAnimationContainer()->last_tick_time();
+  else if (GetAnimationTimer()->is_running())
+    start_time = GetAnimationTimer()->last_tick_time();
   else
     start_time = base::TimeTicks::Now();
 
   running_animations_.push_back(
       RunningAnimation(sequence->AsWeakPtr(), start_time));
 
   // Need to keep a reference to the animation.
   AddToQueueIfNotPresent(sequence);
 
   // Ensure that animations get stepped at their start time.
@@ skipping 59 matching lines @@
 LayerAnimator::RunningAnimation::RunningAnimation(
     const base::WeakPtr<LayerAnimationSequence>& sequence,
     base::TimeTicks start_time)
     : sequence_(sequence),
       start_time_(start_time) {
 }
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui