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 "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/trace_event/trace_event.h"
+#include "cc/animation/animation_id_provider.h"
+#include "cc/animation/animation_player.h"
+#include "cc/animation/animation_timeline.h"
+#include "cc/animation/element_animations.h"
 #include "cc/layers/delegated_renderer_layer.h"
 #include "cc/layers/layer_settings.h"
 #include "cc/layers/nine_patch_layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/surface_layer.h"
 #include "cc/layers/texture_layer.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/output/filter_operation.h"
 #include "cc/output/filter_operations.h"
 #include "cc/playback/display_item_list_settings.h"
 #include "cc/resources/transferable_resource.h"
+#include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/paint_context.h"
 #include "ui/gfx/animation/animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/point_conversions.h"
@@ skipping 74 matching lines @@
     compositor_->SetRootLayer(NULL);
   if (parent_)
     parent_->Remove(this);
   if (layer_mask_)
     SetMaskLayer(NULL);
   if (layer_mask_back_link_)
     layer_mask_back_link_->SetMaskLayer(NULL);
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->parent_ = NULL;
 
-  cc_layer_->RemoveLayerAnimationEventObserver(this);
+  if (animation_player_)
+    DetachPlayerLayer();
+  else
+    cc_layer_->RemoveLayerAnimationEventObserver(this);
+
   cc_layer_->RemoveFromParent();
 }
 
 // static
 const cc::LayerSettings& Layer::UILayerSettings() {
   return g_ui_layer_settings.Get();
 }
 
 // static
 void Layer::InitializeUILayerSettings() {
@@ skipping 17 matching lines @@
   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_);
+  AttachAnimationPlayers(compositor->GetAnimationTimeline());
+  AttachPlayerLayer();
   SendPendingThreadedAnimations();
 }
 
 void Layer::ResetCompositor() {
   DCHECK(!parent_);
-  if (compositor_)
+  if (compositor_) {
+    DetachPlayerLayer();
+    DetachAnimationPlayers(compositor_->GetAnimationTimeline());
     RemoveAnimatorsInTreeFromCollection(
         compositor_->layer_animator_collection());
+  }
   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->AttachAnimationPlayers(compositor->GetAnimationTimeline());
+    child->AttachPlayerLayer();
     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);
 
+  child->DetachPlayerLayer();
+  Compositor* compositor = GetCompositor();
+  if (compositor)
+    child->DetachAnimationPlayers(compositor->GetAnimationTimeline());
+
   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 285 matching lines @@
 
   if (texture_layer_.get())
     texture_layer_->ClearClient();
   // TODO(piman): delegated_renderer_layer_ cleanup.
 
   cc_layer_->RemoveAllChildren();
   if (cc_layer_->parent()) {
     cc_layer_->parent()->ReplaceChild(cc_layer_, new_layer);
   }
   cc_layer_->SetLayerClient(NULL);
-  cc_layer_->RemoveLayerAnimationEventObserver(this);
+
+  if (animation_player_)
+    DetachPlayerLayer();
+  else
+    cc_layer_->RemoveLayerAnimationEventObserver(this);
+
   new_layer->SetOpacity(cc_layer_->opacity());
   new_layer->SetTransform(cc_layer_->transform());
   new_layer->SetPosition(cc_layer_->position());
   new_layer->SetBackgroundColor(cc_layer_->background_color());
 
   cc_layer_ = new_layer.get();
   content_layer_ = NULL;
   solid_color_layer_ = NULL;
   texture_layer_ = NULL;
   delegated_renderer_layer_ = NULL;
   surface_layer_ = NULL;
 
-  cc_layer_->AddLayerAnimationEventObserver(this);
+  if (animation_player_)
+    AttachPlayerLayer();
+  else
+    cc_layer_->AddLayerAnimationEventObserver(this);
+
   for (size_t i = 0; i < children_.size(); ++i) {
     DCHECK(children_[i]->cc_layer_);
     cc_layer_->AddChild(children_[i]->cc_layer_);
   }
   cc_layer_->SetLayerClient(this);
   cc_layer_->SetTransformOrigin(gfx::Point3F());
   cc_layer_->SetContentsOpaque(fills_bounds_opaquely_);
   cc_layer_->SetForceRenderSurface(force_render_surface_);
   cc_layer_->SetIsDrawable(type_ != LAYER_NOT_DRAWN);
   cc_layer_->SetHideLayerAndSubtree(!visible_);
@@ skipping 448 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(animation.Pass());
-  else
+  if (GetCompositor()) {
+    animation_player_ ? animation_player_->AddAnimation(animation.Pass())
+                      : (void)cc_layer_->AddAnimation(animation.Pass());
+  } else {
     pending_threaded_animations_.push_back(animation.Pass());
+  }
 }
 
 void Layer::RemoveThreadedAnimation(int animation_id) {
   DCHECK(cc_layer_);
   if (pending_threaded_animations_.size() == 0) {
-    cc_layer_->RemoveAnimation(animation_id);
+    animation_player_ ? animation_player_->RemoveAnimation(animation_id)
+                      : 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;
 }
 
 void Layer::SendPendingThreadedAnimations() {
-  for (auto& animation : pending_threaded_animations_)
-    cc_layer_->AddAnimation(std::move(animation));
+  for (auto& animation : pending_threaded_animations_) {
+    animation_player_
+        ? animation_player_->AddAnimation(std::move(animation))
+        : (void)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();
   } else if (type_ == LAYER_NINE_PATCH) {
     nine_patch_layer_ = cc::NinePatchLayer::Create(UILayerSettings());
     cc_layer_ = nine_patch_layer_.get();
   } else {
     content_layer_ = cc::PictureLayer::Create(UILayerSettings(), this);
     cc_layer_ = content_layer_.get();
   }
   cc_layer_->SetTransformOrigin(gfx::Point3F());
   cc_layer_->SetContentsOpaque(true);
   cc_layer_->SetIsDrawable(type_ != LAYER_NOT_DRAWN);
-  cc_layer_->AddLayerAnimationEventObserver(this);
+  if (UILayerSettings().use_compositor_animation_timelines)
+    animation_player_ =
+        cc::AnimationPlayer::Create(cc::AnimationIdProvider::NextPlayerId());
+  else
+    cc_layer_->AddLayerAnimationEventObserver(this);
   cc_layer_->SetLayerClient(this);
   RecomputePosition();
 }
 
+void Layer::AttachPlayerLayer() {
+  DCHECK(cc_layer_);
+
+  if (animation_player_) {
+    animation_player_->AttachLayer(cc_layer_->id());
+    DCHECK(animation_player_->element_animations());
+    animation_player_->element_animations()
+        ->layer_animation_controller()
+        ->AddEventObserver(this);
+  }
+
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->AttachPlayerLayer();
+}
+
+void Layer::DetachPlayerLayer() {
+  if (animation_player_) {
+    if (animation_player_->element_animations()) {
+      animation_player_->element_animations()
+          ->layer_animation_controller()
+          ->RemoveEventObserver(this);
+      animation_player_->DetachLayer();
+    }
+  }
+
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->DetachPlayerLayer();
+}
+
+void Layer::AttachAnimationPlayers(cc::AnimationTimeline* timeline) {
+  if (!timeline)
+    return;
+
+  if (animation_player_)
+    timeline->AttachPlayer(animation_player_);
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->AttachAnimationPlayers(timeline);
+}
+
+void Layer::DetachAnimationPlayers(cc::AnimationTimeline* timeline) {
+  if (!timeline)
+    return;
+
+  if (animation_player_)
+    timeline->DetachPlayer(animation_player_);
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->DetachAnimationPlayers(timeline);
+}
+
 gfx::Transform Layer::transform() const {
   return cc_layer_->transform();
 }
 
 void Layer::RecomputeDrawsContentAndUVRect() {
   DCHECK(cc_layer_);
   gfx::Size size(bounds_.size());
   if (texture_layer_.get()) {
     size.SetToMin(frame_size_in_dip_);
     gfx::PointF uv_top_left(0.f, 0.f);
@@ skipping 28 matching lines @@
     animator_->RemoveFromCollection(collection);
   for (auto* child : children_)
     child->RemoveAnimatorsInTreeFromCollection(collection);
 }
 
 bool Layer::IsAnimating() const {
   return animator_.get() && animator_->is_animating();
 }
 
 }  // namespace ui