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);
+
+  DetachAnimationObservers();
+
   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) {
-  // 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);
+  // 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());
+}
+
+void Layer::SetCompositorRootCCLayer(scoped_refptr<cc::Layer> root_layer) {
+  // This function must only be called on the root ui layer.
+  root_layer->AddChild(cc_layer_);
+  AttachAnimationObservers();
+  SendPendingThreadedAnimations();
+}
+
+void Layer::ResetCompositor() {
   DCHECK(!parent_);
   if (compositor_) {
+    DetachAnimationObservers();
     RemoveAnimatorsInTreeFromCollection(
         compositor_->layer_animator_collection());
   }
-  compositor_ = compositor;
-  if (compositor) {
-    OnDeviceScaleFactorChanged(compositor->device_scale_factor());
-    SendPendingThreadedAnimations();
-    AddAnimatorsInTreeToCollection(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->AttachAnimationObservers();
     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->DetachAnimationObservers();
+
   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 133 matching lines @@
           layer_mask->children().empty() &&
           !layer_mask->layer_mask_back_link_));
   DCHECK(!layer_mask_back_link_);
   if (layer_mask_ == layer_mask)
     return;
   // We need to de-reference the currently linked object so that no problem
   // arises if the mask layer gets deleted before this object.
   if (layer_mask_)
     layer_mask_->layer_mask_back_link_ = NULL;
   layer_mask_ = layer_mask;
-  cc_layer_->SetMaskLayer(
-      layer_mask ? layer_mask->cc_layer() : NULL);
+  cc_layer_->SetMaskLayer(layer_mask ? layer_mask->cc_layer_ : NULL);
   // We need to reference the linked object so that it can properly break the
   // link to us when it gets deleted.
   if (layer_mask) {
     layer_mask->layer_mask_back_link_ = this;
     layer_mask->OnDeviceScaleFactorChanged(device_scale_factor_);
   }
 }
 
 void Layer::SetBackgroundZoom(float zoom, int inset) {
   zoom_ = zoom;
@@ skipping 131 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);
+
+  DetachAnimationObservers();
+
   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);
+  AttachAnimationObservers();
+
   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 510 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::AttachAnimationObservers() {
+  if (cc_layer_->layer_animation_controller())

[ajuma, 2015/04/27 14:51:56]

It's probably better to move this null check to
cc::Layer::AddLayerAnimationEventObserver.

[loyso (OOO), 2015/04/28 05:10:36]

This is the only place in the project where
cc::Layer::AddLayerAnimationEventObserver is called.
And you mentioned that it would be fragile.
In that case a subscriber can subscribe and don't get any notification. That
would be a bug which is hard to track.

[loyso (OOO), 2015/04/28 05:23:13]

May we put a DCHECK here?

[ajuma, 2015/04/28 14:36:04]

If a DCHECK works, that'd be great. If not, perhaps add a TODO to fix this when
we switch over to the new system (e.g. so that either the call to
AddLayerAnimationEventObserver returns false when it fails, or it  always
succeeds).

+    cc_layer_->AddLayerAnimationEventObserver(this);
+
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->AttachAnimationObservers();
+}
+
+void Layer::DetachAnimationObservers() {
+  if (cc_layer_->layer_animation_controller())
+    cc_layer_->RemoveLayerAnimationEventObserver(this);
+
+  for (size_t i = 0; i < children_.size(); ++i)
+    children_[i]->DetachAnimationObservers();
+}
+
 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