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"
@@ skipping 106 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 (cc_layer_->layer_animation_controller())
+    cc_layer_->RemoveLayerAnimationEventObserver(this);
+
   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);
+void Layer::SetCompositor(Compositor* compositor,
+                          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_);
-  if (compositor_) {
+
+  compositor_ = compositor;
+  OnDeviceScaleFactorChanged(compositor->device_scale_factor());
+  AddAnimatorsInTreeToCollection(compositor_->layer_animator_collection());
+
+  root_layer->AddChild(cc_layer_);
+  SendPendingThreadedAnimations();
+}
+
+void Layer::ResetCompositor() {
+  DCHECK(!parent_);
+  if (compositor_)
     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_);
@@ skipping 160 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 116 matching lines @@
   fills_bounds_opaquely_ = fills_bounds_opaquely;
 
   cc_layer_->SetContentsOpaque(fills_bounds_opaquely);
 }
 
 void Layer::SetFillsBoundsCompletely(bool fills_bounds_completely) {
   fills_bounds_completely_ = fills_bounds_completely;
 }
 
 void Layer::SwitchToLayer(scoped_refptr<cc::Layer> new_layer) {
+  DCHECK(!new_layer->parent());
+  DCHECK(!new_layer->layer_animation_controller());
+
   // Finish animations being handled by cc_layer_.
   if (animator_.get()) {
     animator_->StopAnimatingProperty(LayerAnimationElement::TRANSFORM);
     animator_->StopAnimatingProperty(LayerAnimationElement::OPACITY);
   }
 
   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 (cc_layer_->layer_animation_controller())
+    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 (cc_layer_->layer_animation_controller())
+    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 481 matching lines @@
                     HasAnimationId(animation_id)),
       pending_threaded_animations_.end());
 }
 
 LayerAnimatorCollection* Layer::GetLayerAnimatorCollection() {
   Compositor* compositor = GetCompositor();
   return compositor ? compositor->layer_animator_collection() : NULL;
 }
 
 void Layer::SendPendingThreadedAnimations() {
+  DCHECK(cc_layer_->layer_animation_controller());

[piman, 2015/04/30 00:40:38]

Is this DCHECK valid? SendPendingThreadedAnimations is called any time the layer
is added to the tree, regardless of animation controllers.

[loyso (OOO), 2015/04/30 01:03:04]

SendPendingThreadedAnimations is only called after AddChild so LayerTreeHost /
RegisterForAnimations are set up.

SendPendingThreadedAnimations requires LAC anyway. It adds animations into LAC.

In fact, we can remove it because we have the same one in
cc_layer_->AddLayerAnimationEventObserver.

[loyso (OOO), 2015/04/30 01:04:03]

* Remove - I meant duplicate DCHECK.

+  cc_layer_->AddLayerAnimationEventObserver(this);

[piman, 2015/04/30 00:40:38]

Is this idempotent? SendPendingThreadedAnimations is called when we add the
layer to the tree, but we don't call RemoveLayerAnimationEventObserver when we
remove from the tree.

What is the invariant wrt the AnimationEventObserver?

Can we add unit tests to verify that?

[loyso (OOO), 2015/04/30 01:03:04]

Yes, it's idempotent. Apart from SwithToLayer case, we detach ui::Layer from
cc::Layer in ui::Layer destructor only.

In general, the idea is simple. We defer AddLayerAnimationEventObserver from
CreateCCLayer call until SetCompositor OR Add cases. That's it.

"What is the invariant wrt the AnimationEventObserver?"
Sorry, I haven't caught the question.

[loyso (OOO), 2015/05/01 03:46:21]

We call SendPendingThreadedAnimations at two places: Layer::SetCompositor and
Layer::Add.
1) In this CL it's clearly seen that in Layer::SetCompositor we always have
LTHs/LACs for the whole subtree prepared (root_web_layer always has a host set
and we add root ui layer into root_webLayer in the line right before the
SendPendingThreadedAnimations call).
2) In Layer::Add we skip SendPendingThreadedAnimations if Layer is orphaned.
Once we add the orphaned sub-tree into a layer with Compositor+LTH+LAC set, we
call SendPendingThreadedAnimations recursively for the whole previously orphaned
subtree.

+
   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));
 
   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();
 }
 
 gfx::Transform Layer::transform() const {
   return cc_layer_->transform();
 }
 
 void Layer::RecomputeDrawsContentAndUVRect() {
   DCHECK(cc_layer_);
@@ skipping 37 matching lines @@
       children_.end(),
       std::bind2nd(std::mem_fun(&Layer::RemoveAnimatorsInTreeFromCollection),
                    collection));
 }
 
 bool Layer::IsAnimating() const {
   return animator_.get() && animator_->is_animating();
 }
 
 }  // namespace ui