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/base/scoped_ptr_algorithm.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/delegated_renderer_layer.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/resources/transferable_resource.h"
+#include "cc/trees/layer_tree_host.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer_animator.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"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/interpolated_transform.h"
@@ skipping 79 matching lines @@
   if (compositor_)
     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 (compositor_)
+    DetachLayer();
+
   cc_layer_->RemoveFromParent();
 }
 
 // static
 bool Layer::UsingPictureLayer() {
   return g_ui_impl_side_painting_status.Get().enabled;
 }
 
 const Compositor* Layer::GetCompositor() const {
   return GetRoot(this)->compositor_;
 }
 
 float Layer::opacity() const {
   return cc_layer_->opacity();
 }
 
 void Layer::SetCompositor(Compositor* compositor) {
+  if (compositor)
+    RegisterForAnimations(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_) {
+    DetachLayer();
+    DetachAnimationPlayer();
+
     RemoveAnimatorsInTreeFromCollection(
         compositor_->layer_animator_collection());
   }
   compositor_ = compositor;
   if (compositor) {
+    AttachAnimationPlayer();
+    AttachLayer();
+
     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())
+  Compositor* compositor = GetCompositor();
+  if (compositor) {
+    child->RegisterForAnimations(compositor);
+    child->AttachAnimationPlayer();
+    child->AttachLayer();
+
     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->DetachLayer();
+    child->DetachAnimationPlayer();
+  }
+
   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 286 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);
+
+  DetachLayer();
+
   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);
+  AttachLayer();
+
   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 443 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());
 }
 
 namespace{
 
 struct HasAnimationId {
   HasAnimationId(int id): id_(id) {
   }
 
   bool operator()(cc::Animation* animation) const {
     return animation->id() == id_;
   }
 
  private:
   int id_;
 };
 
 }
 
 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(
       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));
+       it != pending_threaded_animations_.end(); ++it) {
+    animation_player_
+        ? animation_player_->AddAnimation(pending_threaded_animations_.take(it))
+        : (void)cc_layer_->AddAnimation(pending_threaded_animations_.take(it));
+  }
 
   pending_threaded_animations_.clear();
 
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SendPendingThreadedAnimations();
 }
 
 void Layer::CreateCcLayer() {
   if (type_ == LAYER_SOLID_COLOR) {
     solid_color_layer_ = cc::SolidColorLayer::Create();
     cc_layer_ = solid_color_layer_.get();
   } else if (type_ == LAYER_NINE_PATCH) {
     nine_patch_layer_ = cc::NinePatchLayer::Create();
     cc_layer_ = nine_patch_layer_.get();
   } else {
     if (Layer::UsingPictureLayer())
       content_layer_ = cc::PictureLayer::Create(this);
     else
       content_layer_ = cc::ContentLayer::Create(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);
   cc_layer_->SetLayerClient(this);
   RecomputePosition();
 }
 
+void Layer::RegisterForAnimations(Compositor* compositor) {
+  DCHECK(compositor);
+  const cc::LayerTreeHost& host = compositor->GetLayerTreeHost();
+  cc_layer_->RegisterForAnimations(host.animation_registrar(), host.settings());
+
+  if (host.settings().use_compositor_animation_timelines) {
+    if (!animation_player_) {
+      animation_player_ =
+          cc::AnimationPlayer::Create(cc::AnimationIdProvider::NextPlayerId());
+    }
+  }
+
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->RegisterForAnimations(compositor);
+}
+
+void Layer::AttachLayer() {
+  DCHECK(cc_layer_);
+
+  if (animation_player_) {
+    animation_player_->AttachLayer(cc_layer_->id());
+    DCHECK(animation_player_->layer_animation_controller());
+    animation_player_->layer_animation_controller()->AddEventObserver(this);
+  } else {
+    cc_layer_->AddLayerAnimationEventObserver(this);
+  }
+
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->AttachLayer();
+}
+
+void Layer::DetachLayer() {
+  if (animation_player_) {
+    DCHECK(animation_player_->layer_animation_controller());
+    animation_player_->layer_animation_controller()->RemoveEventObserver(this);
+    animation_player_->DetachLayer();
+  } else {
+    cc_layer_->RemoveLayerAnimationEventObserver(this);
+  }
+
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->DetachLayer();
+}
+
+void Layer::AttachAnimationPlayer() {
+  Compositor* compositor = GetCompositor();
+  DCHECK(compositor);
+
+  if (animation_player_)
+    compositor->GetAnimationTimeline()->AttachPlayer(animation_player_.get());
+
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->AttachAnimationPlayer();
+}
+
+void Layer::DetachAnimationPlayer() {
+  Compositor* compositor = GetCompositor();
+  DCHECK(compositor);
+
+  if (animation_player_)
+    compositor->GetAnimationTimeline()->DetachPlayer(animation_player_.get());
+
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->DetachAnimationPlayer();
+}
+
 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 33 matching lines @@
       children_.end(),
       std::bind2nd(std::mem_fun(&Layer::RemoveAnimatorsInTreeFromCollection),
                    collection));
 }
 
 bool Layer::IsAnimating() const {
   return animator_.get() && animator_->is_animating();
 }
 
 }  // namespace ui