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

ui/compositor/layer_animator.cc

Index: ui/compositor/layer_animator.cc
diff --git a/ui/compositor/layer_animator.cc b/ui/compositor/layer_animator.cc
index 96a184c52ab244b88e06dbec98932109635173d0..69454eaaf2e270eb66f45a00304a6654b6ba5d39 100644
--- a/ui/compositor/layer_animator.cc
+++ b/ui/compositor/layer_animator.cc
@@ -13,6 +13,7 @@
 #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()) \
@@ -38,14 +39,42 @@ static const base::TimeDelta kDefaultTransitionDuration =
 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
@@ -181,8 +210,8 @@ void LayerAnimator::StartTogether(
 
   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();
   }
@@ -323,6 +352,13 @@ void LayerAnimator::RemoveObserver(LayerAnimationObserver* 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,
@@ -388,9 +424,9 @@ void LayerAnimator::UpdateAnimationState() {
 
   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;
 }
@@ -676,8 +712,8 @@ bool LayerAnimator::StartSequenceImmediately(LayerAnimationSequence* sequence) {
   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();