CC Animation: Merge LayerAnimationController into ElementAnimations.

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 <memory>
 
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
 #include "cc/animation/animation_timeline.h"
 #include "cc/animation/element_animations.h"
-#include "cc/animation/layer_animation_controller.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, ...) \
     if (running_anim.is_sequence_alive()) \
@@ skipping 100 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;
+  // Release ElementAnimations state for old layer.
+  element_animations_state_ = nullptr;
 
   if (delegate_)
     DetachLayerFromAnimationPlayer();
   if (new_layer)
     AttachLayerToAnimationPlayer(new_layer->id());
 }
 
 void LayerAnimator::SetCompositor(Compositor* compositor) {
   DCHECK(compositor);
 
   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(),
+  // Register ElementAnimations so it will be picked up by
+  // AnimationHost::RegisterPlayerForLayer via
+  // AnimationHost::GetElementAnimationsForLayerId.
+  if (element_animations_state_) {
+    DCHECK_EQ(element_animations_state_->layer_id(),
               delegate_->GetCcLayer()->id());
-    timeline->animation_host()
-        ->RegisterAnimationController(animation_controller_state_.get());
+    timeline->animation_host()->RegisterElementAnimations(
+        element_animations_state_.get());
   }
 
   timeline->AttachPlayer(animation_player_);
 
   AttachLayerToAnimationPlayer(delegate_->GetCcLayer()->id());
 
-  // Release LAC (it is referenced in ElementAnimations).
-  animation_controller_state_ = nullptr;
+  // Release ElementAnimations state.
+  element_animations_state_ = nullptr;
 }
 
 void LayerAnimator::ResetCompositor(Compositor* compositor) {
   DCHECK(compositor);
 
   cc::AnimationTimeline* timeline = compositor->GetAnimationTimeline();
   DCHECK(timeline);
 
   const int layer_id = animation_player_->layer_id();
 
-  // Store a reference to LAC if any so it may be picked up in SetCompositor.
+  // Store a reference to ElementAnimations (if any)
+  // so it may be picked up in LayerAnimator::SetCompositor.
   if (layer_id) {
-    animation_controller_state_ =
-        timeline->animation_host()->GetControllerForLayerId(layer_id);
+    element_animations_state_ =
+        timeline->animation_host()->GetElementAnimationsForLayerId(layer_id);
   }
 
   DetachLayerFromAnimationPlayer();
 
   timeline->DetachPlayer(animation_player_);
 }
 
 void LayerAnimator::AttachLayerToAnimationPlayer(int layer_id) {
   if (!animation_player_->layer_id())
     animation_player_->AttachLayer(layer_id);
@@ skipping 768 matching lines @@
     const base::WeakPtr<LayerAnimationSequence>& sequence)
     : sequence_(sequence) {
 }
 
 LayerAnimator::RunningAnimation::RunningAnimation(
     const RunningAnimation& other) = default;
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui