UI Compositor: Fix threaded animation survival if layer removed and added.

ui/compositor/layer_animator.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_animator.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/animation/animation_events.h"
+#include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
+#include "cc/animation/animation_registrar.h"
 #include "cc/animation/animation_timeline.h"
 #include "cc/animation/element_animations.h"
+#include "cc/animation/layer_animation_controller.h"
 #include "cc/layers/layer_settings.h"
 #include "cc/output/begin_frame_args.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/layer_animator_collection.h"
 
 #define SAFE_INVOKE_VOID(function, running_anim, ...) \
@@ skipping 101 matching lines @@
   SwitchToLayer(delegate ? delegate->GetCcLayer() : nullptr);
   delegate_ = delegate;
   if (delegate_ && is_started_) {
     LayerAnimatorCollection* collection = GetLayerAnimatorCollection();
     if (collection)
       collection->StartAnimator(this);
   }
 }
 
 void LayerAnimator::SwitchToLayer(scoped_refptr<cc::Layer> new_layer) {
+  // Release LAC state for old layer.
+  animation_controller_state_ = nullptr;
+
   if (delegate_) {
     if (animation_player_)
       DetachLayerFromAnimationPlayer();
     else
       delegate_->GetCcLayer()->RemoveLayerAnimationEventObserver(this);
   }
   if (new_layer) {
     if (animation_player_)
       AttachLayerToAnimationPlayer(new_layer->id());
     else
       new_layer->AddLayerAnimationEventObserver(this);
   }
 }
 
 void LayerAnimator::SetCompositor(Compositor* compositor) {
   DCHECK(compositor);
   if (animation_player_) {
     cc::AnimationTimeline* timeline = compositor->GetAnimationTimeline();
     DCHECK(timeline);
+
+    DCHECK(delegate_->GetCcLayer());
+
+    // Register LAC so ElementAnimations picks it up via
+    // AnimationRegistrar::GetAnimationControllerForId.
+    if (animation_controller_state_) {
+      DCHECK_EQ(animation_controller_state_->id(),
+                delegate_->GetCcLayer()->id());
+      timeline->animation_host()
+          ->animation_registrar()
+          ->RegisterAnimationController(animation_controller_state_.get());
+    }
+
     timeline->AttachPlayer(animation_player_);
 
-    DCHECK(delegate_->GetCcLayer());
     AttachLayerToAnimationPlayer(delegate_->GetCcLayer()->id());
+
+    // Release LAC (it is referenced in ElementAnimations).
+    animation_controller_state_ = nullptr;
   }
 }
 
 void LayerAnimator::ResetCompositor(Compositor* compositor) {
   DCHECK(compositor);
   if (animation_player_) {
+    // Store a reference to LAC if any so it may be picked up in SetCompositor.
+    if (animation_player_->element_animations()) {
+      animation_controller_state_ =
+          animation_player_->element_animations()->layer_animation_controller();
+    }
+
     DetachLayerFromAnimationPlayer();
 
     cc::AnimationTimeline* timeline = compositor->GetAnimationTimeline();
     DCHECK(timeline);
     timeline->DetachPlayer(animation_player_);
   }
 }
 
 void LayerAnimator::AttachLayerToAnimationPlayer(int layer_id) {
   DCHECK(animation_player_);
@@ skipping 777 matching lines @@
     const base::WeakPtr<LayerAnimationSequence>& sequence)
     : sequence_(sequence) {
 }
 
 LayerAnimator::RunningAnimation::RunningAnimation(
     const RunningAnimation& other) = default;
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui