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

ui/compositor/layer.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.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 124 matching lines @@
 float Layer::opacity() const {
   return cc_layer_->opacity();
 }
 
 void Layer::SetCompositor(Compositor* compositor) {
   // This function must only be called to set the compositor on the root layer,
   // or to reset it.
   DCHECK(!compositor || !compositor_);
   DCHECK(!compositor || compositor->root_layer() == this);
   DCHECK(!parent_);
+  if (compositor_) {
+    RemoveAnimatorsInTreeFromCollection(
+        compositor_->layer_animator_collection());
+  }
   compositor_ = compositor;
   if (compositor) {
     OnDeviceScaleFactorChanged(compositor->device_scale_factor());
     SendPendingThreadedAnimations();
+    AddAnimatorsInTreeToCollection(compositor_->layer_animator_collection());
   }
 }
 
 void Layer::Add(Layer* child) {
   DCHECK(!child->compositor_);
   if (child->parent_)
     child->parent_->Remove(child);
   child->parent_ = this;
   children_.push_back(child);
   cc_layer_->AddChild(child->cc_layer_);
   child->OnDeviceScaleFactorChanged(device_scale_factor_);
   if (GetCompositor())
     child->SendPendingThreadedAnimations();
+  LayerAnimatorCollection* collection = GetLayerAnimatorCollection();
+  if (collection)
+    child->AddAnimatorsInTreeToCollection(collection);
 }
 
 void Layer::Remove(Layer* child) {
   // Current bounds are used to calculate offsets when layers are reparented.
   // Stop (and complete) an ongoing animation to update the bounds immediately.
-  if (child->GetAnimator()) {
-    child->GetAnimator()->StopAnimatingProperty(
-        ui::LayerAnimationElement::BOUNDS);
-  }
+  LayerAnimator* child_animator = child->animator_;
+  if (child_animator)
+    child_animator->StopAnimatingProperty(ui::LayerAnimationElement::BOUNDS);
+  LayerAnimatorCollection* collection = GetLayerAnimatorCollection();
+  if (collection)
+    child->RemoveAnimatorsInTreeFromCollection(collection);
+
   std::vector<Layer*>::iterator i =
       std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
   children_.erase(i);
   child->parent_ = NULL;
   child->cc_layer_->RemoveFromParent();
 }
 
 void Layer::StackAtTop(Layer* child) {
   if (children_.size() <= 1 || child == children_.back())
@@ skipping 417 matching lines @@
           sk_damaged.width(),
           sk_damaged.height());
       cc_layer_->SetNeedsDisplayRect(damaged);
     }
     damaged_region_.setEmpty();
   }
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SendDamagedRects();
 }
 
+void Layer::CompleteAllAnimations() {
+  std::vector<scoped_refptr<LayerAnimator> > animators;
+  CollectAnimators(&animators);
+  std::for_each(animators.begin(), animators.end(),
+                std::mem_fun(&LayerAnimator::StopAnimating));
+}
+
 void Layer::SuppressPaint() {
   if (!delegate_)
     return;
   delegate_ = NULL;
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SuppressPaint();
 }
 
 void Layer::OnDeviceScaleFactorChanged(float device_scale_factor) {
   if (device_scale_factor_ == device_scale_factor)
@@ skipping 64 matching lines @@
 
 scoped_refptr<base::debug::ConvertableToTraceFormat> Layer::TakeDebugInfo() {
   return new LayerDebugInfo(name_);
 }
 
 void Layer::OnAnimationStarted(const cc::AnimationEvent& event) {
   if (animator_.get())
     animator_->OnThreadedAnimationStarted(event);
 }
 
+void Layer::CollectAnimators(
+    std::vector<scoped_refptr<LayerAnimator> >* animators) {
+  if (IsAnimating())
+    animators->push_back(animator_);
+  std::for_each(children_.begin(), children_.end(),
+                std::bind2nd(std::mem_fun(&Layer::CollectAnimators),
+                             animators));
+}
+
 void Layer::StackRelativeTo(Layer* child, Layer* other, bool above) {
   DCHECK_NE(child, other);
   DCHECK_EQ(this, child->parent());
   DCHECK_EQ(this, other->parent());
 
   const size_t child_i =
       std::find(children_.begin(), children_.end(), child) - children_.begin();
   const size_t other_i =
       std::find(children_.begin(), children_.end(), other) - children_.begin();
   if ((above && child_i == other_i + 1) || (!above && child_i + 1 == other_i))
@@ skipping 164 matching lines @@
   }
 
   pending_threaded_animations_.erase(
       cc::remove_if(&pending_threaded_animations_,
                     pending_threaded_animations_.begin(),
                     pending_threaded_animations_.end(),
                     HasAnimationId(animation_id)),
       pending_threaded_animations_.end());
 }
 
+LayerAnimatorCollection* Layer::GetLayerAnimatorCollection() {
+  Compositor* compositor = GetCompositor();
+  return compositor ? compositor->layer_animator_collection() : NULL;
+}
+
 void Layer::SendPendingThreadedAnimations() {
   for (cc::ScopedPtrVector<cc::Animation>::iterator it =
            pending_threaded_animations_.begin();
        it != pending_threaded_animations_.end();
        ++it)
     cc_layer_->AddAnimation(pending_threaded_animations_.take(it));
 
   pending_threaded_animations_.clear();
 
   for (size_t i = 0; i < children_.size(); ++i)
@@ skipping 37 matching lines @@
     size.SetToMin(frame_size_in_dip_);
     delegated_renderer_layer_->SetDisplaySize(frame_size_in_dip_);
   }
   cc_layer_->SetBounds(size);
 }
 
 void Layer::RecomputePosition() {
   cc_layer_->SetPosition(gfx::PointF(bounds_.x(), bounds_.y()));
 }
 
+void Layer::AddAnimatorsInTreeToCollection(
+    LayerAnimatorCollection* collection) {
+  DCHECK(collection);
+  if (IsAnimating())
+    animator_->AddToCollection(collection);
+  std::for_each(
+      children_.begin(),
+      children_.end(),
+      std::bind2nd(std::mem_fun(&Layer::AddAnimatorsInTreeToCollection),
+                   collection));
+}
+
+void Layer::RemoveAnimatorsInTreeFromCollection(
+    LayerAnimatorCollection* collection) {
+  DCHECK(collection);
+  if (IsAnimating())
+    animator_->RemoveFromCollection(collection);
+  std::for_each(
+      children_.begin(),
+      children_.end(),
+      std::bind2nd(std::mem_fun(&Layer::RemoveAnimatorsInTreeFromCollection),
+                   collection));
+}
+
+bool Layer::IsAnimating() const {
+  return animator_ && animator_->is_animating();
+}
+
 }  // namespace ui