CC Animations: Port UI Browser Compositor to use compositor animation timelines.

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 <utility>
 
 #include "base/auto_reset.h"
@@ skipping 137 matching lines @@
                           scoped_refptr<cc::Layer> root_layer) {
   // This function must only be called to set the compositor on the root ui
   // layer.
   DCHECK(compositor);
   DCHECK(!compositor_);
   DCHECK(compositor->root_layer() == this);
   DCHECK(!parent_);
 
   compositor_ = compositor;
   OnDeviceScaleFactorChanged(compositor->device_scale_factor());
-  AddAnimatorsInTreeToCollection(compositor_->layer_animator_collection());
 
   root_layer->AddChild(cc_layer_);
+  SetCompositorForAnimatorsInTree(compositor);
   SendPendingThreadedAnimations();
 }
 
 void Layer::ResetCompositor() {
   DCHECK(!parent_);
-  if (compositor_)
-    RemoveAnimatorsInTreeFromCollection(
-        compositor_->layer_animator_collection());
-  compositor_ = nullptr;
+  if (compositor_) {
+    ResetCompositorForAnimatorsInTree(compositor_);
+    compositor_ = nullptr;
+  }
 }
 
 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())
+  Compositor* compositor = GetCompositor();
+  if (compositor) {
+    child->SetCompositorForAnimatorsInTree(compositor);
     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.
   LayerAnimator* child_animator = child->animator_.get();
   if (child_animator)
     child_animator->StopAnimatingProperty(ui::LayerAnimationElement::BOUNDS);
-  LayerAnimatorCollection* collection = GetLayerAnimatorCollection();
-  if (collection)
-    child->RemoveAnimatorsInTreeFromCollection(collection);
+
+  Compositor* compositor = GetCompositor();
+  if (compositor)
+    child->ResetCompositorForAnimatorsInTree(compositor);
 
   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) {
@@ skipping 607 matching lines @@
   std::string name_;
 };
 
 scoped_refptr<base::trace_event::ConvertableToTraceFormat> Layer::TakeDebugInfo(
     cc::Layer* layer) {
   return new LayerDebugInfo(name_);
 }
 
 void Layer::CollectAnimators(
     std::vector<scoped_refptr<LayerAnimator>>* animators) {
-  if (IsAnimating())
+  if (animator_ && animator_->is_animating())
     animators->push_back(animator_);
   for (auto* child : children_)
     child->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());
 
@@ skipping 132 matching lines @@
 }
 
 float Layer::GetDeviceScaleFactor() const {
   return device_scale_factor_;
 }
 
 void Layer::AddThreadedAnimation(scoped_ptr<cc::Animation> animation) {
   DCHECK(cc_layer_);
   // Until this layer has a compositor (and hence cc_layer_ has a
   // LayerTreeHost), addAnimation will fail.
-  if (GetCompositor())
-    cc_layer_->AddAnimation(std::move(animation));
-  else
+  if (GetCompositor()) {
+    if (UILayerSettings().use_compositor_animation_timelines) {
+      DCHECK(animator_);
+      animator_->AddThreadedAnimation(std::move(animation));
+    } else {
+      cc_layer_->AddAnimation(std::move(animation));
+    }
+  } else {
     pending_threaded_animations_.push_back(std::move(animation));
+  }
 }
 
 void Layer::RemoveThreadedAnimation(int animation_id) {
   DCHECK(cc_layer_);
   if (pending_threaded_animations_.size() == 0) {
-    cc_layer_->RemoveAnimation(animation_id);
+    if (UILayerSettings().use_compositor_animation_timelines) {
+      DCHECK(animator_);
+      animator_->RemoveThreadedAnimation(animation_id);
+    } else {
+      cc_layer_->RemoveAnimation(animation_id);
+    }
     return;
   }
 
   pending_threaded_animations_.erase(
       std::remove_if(
           pending_threaded_animations_.begin(),
           pending_threaded_animations_.end(),
           [animation_id](const scoped_ptr<cc::Animation>& animation) {
             return animation->id() == animation_id;
           }),
       pending_threaded_animations_.end());
 }
 
 LayerAnimatorCollection* Layer::GetLayerAnimatorCollection() {
   Compositor* compositor = GetCompositor();
   return compositor ? compositor->layer_animator_collection() : NULL;
 }
 
 cc::Layer* Layer::GetCcLayer() const {
   return cc_layer_;
 }
 
 void Layer::SendPendingThreadedAnimations() {
-  for (auto& animation : pending_threaded_animations_)
-    cc_layer_->AddAnimation(std::move(animation));
+  for (auto& animation : pending_threaded_animations_) {
+    if (UILayerSettings().use_compositor_animation_timelines) {
+      DCHECK(animator_);
+      animator_->AddThreadedAnimation(std::move(animation));
+    } else {
+      cc_layer_->AddAnimation(std::move(animation));
+    }
+  }
   pending_threaded_animations_.clear();
 
   for (auto* child : children_)
     child->SendPendingThreadedAnimations();
 }
 
 void Layer::CreateCcLayer() {
   if (type_ == LAYER_SOLID_COLOR) {
     solid_color_layer_ = cc::SolidColorLayer::Create(UILayerSettings());
     cc_layer_ = solid_color_layer_.get();
@@ skipping 29 matching lines @@
     size.SetToMin(frame_size_in_dip_);
   }
   cc_layer_->SetBounds(size);
 }
 
 void Layer::RecomputePosition() {
   cc_layer_->SetPosition(gfx::PointF(bounds_.origin()) +
                          subpixel_position_offset_);
 }
 
-void Layer::AddAnimatorsInTreeToCollection(
-    LayerAnimatorCollection* collection) {
-  DCHECK(collection);
-  if (IsAnimating())
-    animator_->AddToCollection(collection);
+void Layer::SetCompositorForAnimatorsInTree(Compositor* compositor) {
+  DCHECK(compositor);
+  LayerAnimatorCollection* collection = compositor->layer_animator_collection();
+
+  if (animator_) {
+    if (animator_->is_animating())
+      animator_->AddToCollection(collection);
+    animator_->SetCompositor(compositor);
+  }
+
   for (auto* child : children_)
-    child->AddAnimatorsInTreeToCollection(collection);
+    child->SetCompositorForAnimatorsInTree(compositor);
 }
 
-void Layer::RemoveAnimatorsInTreeFromCollection(
-    LayerAnimatorCollection* collection) {
-  DCHECK(collection);
-  if (IsAnimating())
-    animator_->RemoveFromCollection(collection);
+void Layer::ResetCompositorForAnimatorsInTree(Compositor* compositor) {
+  DCHECK(compositor);
+  LayerAnimatorCollection* collection = compositor->layer_animator_collection();
+
+  if (animator_) {
+    animator_->ResetCompositor(compositor);
+    if (animator_->is_animating())
+      animator_->RemoveFromCollection(collection);
+  }
+
   for (auto* child : children_)
-    child->RemoveAnimatorsInTreeFromCollection(collection);
-}
-
-bool Layer::IsAnimating() const {
-  return animator_.get() && animator_->is_animating();
+    child->ResetCompositorForAnimatorsInTree(compositor);
 }
 
 }  // namespace ui