UI Compositor: Erase old CC animation system (continued)

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"
@@ skipping 50 matching lines @@
       cc::AnimationPlayer::Create(cc::AnimationIdProvider::NextPlayerId());
 }
 
 LayerAnimator::~LayerAnimator() {
   for (size_t i = 0; i < running_animations_.size(); ++i) {
     if (running_animations_[i].is_sequence_alive())
       running_animations_[i].sequence()->OnAnimatorDestroyed();
   }
   ClearAnimationsInternal();
   delegate_ = NULL;
-  DCHECK(!animation_player_ || !animation_player_->animation_timeline());
+  DCHECK(!animation_player_->animation_timeline());
 }
 
 // static
 LayerAnimator* LayerAnimator::CreateDefaultAnimator() {
   return new LayerAnimator(base::TimeDelta::FromMilliseconds(0));
 }
 
 // static
 LayerAnimator* LayerAnimator::CreateImplicitAnimator() {
   return new LayerAnimator(
@@ skipping 52 matching lines @@
     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);
-  }
+  if (delegate_)
+    DetachLayerFromAnimationPlayer();
+  if (new_layer)
+    AttachLayerToAnimationPlayer(new_layer->id());
 }
 
 void LayerAnimator::SetCompositor(Compositor* compositor) {
   DCHECK(compositor);
-  if (animation_player_) {
-    cc::AnimationTimeline* timeline = compositor->GetAnimationTimeline();
-    DCHECK(timeline);
 
-    DCHECK(delegate_->GetCcLayer());
+  cc::AnimationTimeline* timeline = compositor->GetAnimationTimeline();
+  DCHECK(timeline);
 
-    // 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());
-    }
+  DCHECK(delegate_->GetCcLayer());
 
-    timeline->AttachPlayer(animation_player_);
+  // 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());
+  }
 
-    AttachLayerToAnimationPlayer(delegate_->GetCcLayer()->id());
+  timeline->AttachPlayer(animation_player_);
 
-    // Release LAC (it is referenced in ElementAnimations).
-    animation_controller_state_ = nullptr;
-  }
+  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();
+  // 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();
+  }
 
-    cc::AnimationTimeline* timeline = compositor->GetAnimationTimeline();
-    DCHECK(timeline);
-    timeline->DetachPlayer(animation_player_);
-  }
+  DetachLayerFromAnimationPlayer();
+
+  cc::AnimationTimeline* timeline = compositor->GetAnimationTimeline();
+  DCHECK(timeline);
+  timeline->DetachPlayer(animation_player_);
 }
 
 void LayerAnimator::AttachLayerToAnimationPlayer(int layer_id) {
-  DCHECK(animation_player_);
-
   if (!animation_player_->layer_id())
     animation_player_->AttachLayer(layer_id);
   else
     DCHECK_EQ(animation_player_->layer_id(), layer_id);
 
   if (animation_player_->element_animations()) {
     animation_player_->element_animations()
         ->layer_animation_controller()
         ->AddEventObserver(this);
   }
 }
 
 void LayerAnimator::DetachLayerFromAnimationPlayer() {
-  DCHECK(animation_player_);
-
   if (animation_player_->element_animations()) {
     animation_player_->element_animations()
         ->layer_animation_controller()
         ->RemoveEventObserver(this);
   }
 
   if (animation_player_->layer_id())
     animation_player_->DetachLayer();
 }
 
 void LayerAnimator::AddThreadedAnimation(scoped_ptr<cc::Animation> animation) {
-  DCHECK(animation_player_);
   animation_player_->AddAnimation(std::move(animation));
 }
 
 void LayerAnimator::RemoveThreadedAnimation(int animation_id) {
-  DCHECK(animation_player_);
   animation_player_->RemoveAnimation(animation_id);
 }
 
 bool LayerAnimator::HasPendingThreadedAnimationsForTesting() const {
-  DCHECK(animation_player_);
   return animation_player_->has_pending_animations_for_testing();
 }
 
 cc::AnimationPlayer* LayerAnimator::GetAnimationPlayerForTesting() const {
   return animation_player_.get();
 }
 
 void LayerAnimator::StartAnimation(LayerAnimationSequence* animation) {
   scoped_refptr<LayerAnimator> retain(this);
   OnScheduled(animation);
@@ skipping 729 matching lines @@
     const base::WeakPtr<LayerAnimationSequence>& sequence)
     : sequence_(sequence) {
 }
 
 LayerAnimator::RunningAnimation::RunningAnimation(
     const RunningAnimation& other) = default;
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui