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

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 "cc/animation/animation_id_provider.h"
 #include "cc/output/begin_frame_args.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/gfx/animation/animation_container.h"
+#include "ui/compositor/layer_animator_collection.h"
 #include "ui/gfx/frame_time.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 {
 
 const int kDefaultTransitionDurationMs = 120;
-const int kTimerIntervalMs = 10;
-
-// Returns the AnimationContainer we're added to.
-gfx::AnimationContainer* GetAnimationContainer() {
-  static gfx::AnimationContainer* container = NULL;
-  if (!container) {
-    container = new gfx::AnimationContainer();
-    container->AddRef();
-  }
-  return container;
-}
 
 }  // namespace
 
 // LayerAnimator public --------------------------------------------------------
 
 LayerAnimator::LayerAnimator(base::TimeDelta transition_duration)
     : delegate_(NULL),
       preemption_strategy_(IMMEDIATELY_SET_NEW_TARGET),
       is_transition_duration_locked_(false),
       transition_duration_(transition_duration),
@@ skipping 57 matching lines @@
 ANIMATED_PROPERTY(bool, VISIBILITY, Visibility, bool, visibility);
 ANIMATED_PROPERTY(float, BRIGHTNESS, Brightness, float, brightness);
 ANIMATED_PROPERTY(float, GRAYSCALE, Grayscale, float, grayscale);
 ANIMATED_PROPERTY(SkColor, COLOR, Color, SkColor, color);
 
 base::TimeDelta LayerAnimator::GetTransitionDuration() const {
   return transition_duration_;
 }
 
 void LayerAnimator::SetDelegate(LayerAnimationDelegate* delegate) {
+  if (delegate_ && is_started_) {
+    LayerAnimatorCollection* collection = GetLayerAnimatorCollection();
+    if (collection)
+      collection->StopAnimator(this);
+  }
   delegate_ = delegate;
+  if (delegate_ && is_started_) {
+    LayerAnimatorCollection* collection = GetLayerAnimatorCollection();
+    if (collection)
+      collection->StartAnimator(this);
+  }
 }
 
 void LayerAnimator::StartAnimation(LayerAnimationSequence* animation) {
   scoped_refptr<LayerAnimator> retain(this);
   OnScheduled(animation);
   if (!StartSequenceImmediately(animation)) {
     // Attempt to preempt a running animation.
     switch (preemption_strategy_) {
       case IMMEDIATELY_SET_NEW_TARGET:
         ImmediatelySetNewTarget(animation);
@@ skipping 36 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();
+    LayerAnimatorCollection* collection = GetLayerAnimatorCollection();
+    if (collection && collection->HasActiveAnimators())
+      last_step_time_ = collection->last_tick_time();
     else
       last_step_time_ = gfx::FrameTime::Now();
   }
 
   // Collect all the affected properties.
   LayerAnimationElement::AnimatableProperties animated_properties =
       LayerAnimationElement::UNKNOWN;
 
   std::vector<LayerAnimationSequence*>::const_iterator iter;
   for (iter = animations.begin(); iter != animations.end(); ++iter)
@@ skipping 140 matching lines @@
     if (((*iter).sequence()->animation_group_id() == event.group_id) &&
         !(*iter).sequence()->IsFirstElementThreaded() &&
         (*iter).sequence()->waiting_for_group_start()) {
       (*iter).sequence()->set_start_time(start_time);
       (*iter).sequence()->set_waiting_for_group_start(false);
       (*iter).sequence()->Start(delegate());
     }
   }
 }
 
+void LayerAnimator::AddToCollection(LayerAnimatorCollection* collection) {
+  if (is_animating() && !is_started_) {
+    collection->StartAnimator(this);
+    is_started_ = true;
+  }
+}
+
+void LayerAnimator::RemoveFromCollection(LayerAnimatorCollection* collection) {
+  if (is_animating() && is_started_) {
+    collection->StopAnimator(this);
+    is_started_ = false;
+  }
+}
+
 // LayerAnimator protected -----------------------------------------------------
 
 void LayerAnimator::ProgressAnimation(LayerAnimationSequence* sequence,
                                       base::TimeTicks now) {
   if (!delegate() || sequence->waiting_for_group_start())
     return;
 
   sequence->Progress(now, delegate());
 }
 
@@ skipping 32 matching lines @@
       continue;
 
     if (running_animations_copy[i].sequence()->IsFinished(now)) {
       SAFE_INVOKE_VOID(FinishAnimation, running_animations_copy[i], false);
     } else {
       SAFE_INVOKE_VOID(ProgressAnimation, running_animations_copy[i], now);
     }
   }
 }
 
-void LayerAnimator::SetStartTime(base::TimeTicks start_time) {
-  // Do nothing.
-}
-
-base::TimeDelta LayerAnimator::GetTimerInterval() const {
-  return base::TimeDelta::FromMilliseconds(kTimerIntervalMs);
-}
-
 void LayerAnimator::StopAnimatingInternal(bool abort) {
   scoped_refptr<LayerAnimator> retain(this);
   while (is_animating()) {
     // We're going to attempt to finish the first running animation. Let's
     // ensure that it's valid.
     PurgeDeletedAnimations();
 
     // If we've purged all running animations, attempt to start one up.
     if (running_animations_.empty())
       ProcessQueue();
 
     DCHECK(!running_animations_.empty());
 
     // Still no luck, let's just bail and clear all animations.
     if (running_animations_.empty()) {
       ClearAnimationsInternal();
       break;
     }
 
     SAFE_INVOKE_VOID(FinishAnimation, running_animations_[0], abort);
   }
 }
 
 void LayerAnimator::UpdateAnimationState() {
   if (disable_timer_for_test_)
     return;
 
   const bool should_start = is_animating();
-  if (should_start && !is_started_)
-    GetAnimationContainer()->Start(this);
-  else if (!should_start && is_started_)
-    GetAnimationContainer()->Stop(this);
-
-  is_started_ = should_start;
+  LayerAnimatorCollection* collection = GetLayerAnimatorCollection();
+  if (collection) {
+    if (should_start && !is_started_)
+      collection->StartAnimator(this);
+    else if (!should_start && is_started_)
+      collection->StopAnimator(this);
+    is_started_ = should_start;
+  } else {
+    is_started_ = false;
+  }
 }
 
 LayerAnimationSequence* LayerAnimator::RemoveAnimation(
     LayerAnimationSequence* sequence) {
   linked_ptr<LayerAnimationSequence> to_return;
 
   bool is_running = false;
 
   // First remove from running animations
   for (RunningAnimations::iterator iter = running_animations_.begin();
@@ skipping 296 matching lines @@
   for (RunningAnimations::const_iterator iter = running_animations_.begin();
        iter != running_animations_.end(); ++iter) {
     if ((*iter).sequence()->HasConflictingProperty(sequence->properties()))
       return false;
   }
 
   // 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
+  // All LayerAnimators share the same LayerAnimatorCollection. Use the
   // last_tick_time() from there to ensure animations started during the same
   // event complete at the same time.
   base::TimeTicks start_time;
+  LayerAnimatorCollection* collection = GetLayerAnimatorCollection();
   if (is_animating() || adding_animations_)
     start_time = last_step_time_;
-  else if (GetAnimationContainer()->is_running())
-    start_time = GetAnimationContainer()->last_tick_time();
+  else if (collection && collection->HasActiveAnimators())
+    start_time = collection->last_tick_time();
   else
     start_time = gfx::FrameTime::Now();
 
   if (!sequence->animation_group_id())
     sequence->set_animation_group_id(cc::AnimationIdProvider::NextGroupId());
   if (!sequence->waiting_for_group_start() ||
       sequence->IsFirstElementThreaded()) {
     sequence->set_start_time(start_time);
     sequence->Start(delegate());
   }
@@ skipping 58 matching lines @@
 
 void LayerAnimator::PurgeDeletedAnimations() {
   for (size_t i = 0; i < running_animations_.size();) {
     if (!running_animations_[i].is_sequence_alive())
       running_animations_.erase(running_animations_.begin() + i);
     else
       i++;
   }
 }
 
+LayerAnimatorCollection* LayerAnimator::GetLayerAnimatorCollection() {
+  return delegate_ ? delegate_->GetLayerAnimatorCollection() : NULL;
+}
+
 LayerAnimator::RunningAnimation::RunningAnimation(
     const base::WeakPtr<LayerAnimationSequence>& sequence)
     : sequence_(sequence) {
 }
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui