CC Animations: Make LayerAnimationController creation optional

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/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/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"
 #include "ui/gfx/geometry/size_conversions.h"
@@ skipping 78 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);
+
+  DetachObservers();
+
   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) {

[ajuma, 2015/04/23 15:09:15]

This only gets called on the root layer, and only gets called with a non-null
compositor by Compositor::SetRootLayer. But later in the same call, the root
cc_layer gets added as a child of root_web_layer, which will lead to
cc::Layer::SetLayerTreeHost getting called on all the cc layers, which will lead
to them being registered. So the call to RegisterForAnimations below isn't
necessary, if we move AttachObservers so that it happens at the end of
Compositor::SetRootLayer.

[loyso (OOO), 2015/04/24 03:44:52]

Done.

+  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_) {
+    DetachObservers();
     RemoveAnimatorsInTreeFromCollection(
         compositor_->layer_animator_collection());
   }
   compositor_ = compositor;
   if (compositor) {
+    AttachObservers();
     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);

[ajuma, 2015/04/23 15:09:15]

The call to cc_layer_->AddChild(child->cc_layer_) above should lead to a call to
Layer::SetLayerTreeHost on child->cc_layer_ and all of its descendants, which in
turn will register these layers for animation, so there shouldn't be a need to
do that again here.

[loyso (OOO), 2015/04/24 03:44:52]

Done.

+    child->AttachObservers();
     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->DetachObservers();
+
   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);
+
+  DetachObservers();
+
   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);
+  AttachObservers();
+
   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 517 matching lines @@
   } 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());
+
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->RegisterForAnimations(compositor);
+}
+
+void Layer::AttachObservers() {
+  if (cc_layer_->layer_animation_controller())
+    cc_layer_->AddLayerAnimationEventObserver(this);
+
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->AttachObservers();
+}
+
+void Layer::DetachObservers() {
+  if (cc_layer_->layer_animation_controller())
+    cc_layer_->RemoveLayerAnimationEventObserver(this);
+
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->DetachObservers();
+}
+
 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