[Sketch] CC Animations: Torpedo the old intrusive animation system.

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/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/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"
@@ skipping 964 matching lines @@
 
 float Layer::GetDeviceScaleFactor() const {
   return device_scale_factor_;
 }
 
 void Layer::AddThreadedAnimation(scoped_ptr<cc::Animation> animation) {
   DCHECK(cc_layer_);
   // Until this layer has a compositor (and hence cc_layer_ has a
   // LayerTreeHost), addAnimation will fail.
   if (GetCompositor()) {
-    animation_player_ ? animation_player_->AddAnimation(animation.Pass())
-                      : (void)cc_layer_->AddAnimation(animation.Pass());
+    animation_player_->AddAnimation(animation.Pass());
   } else {
     pending_threaded_animations_.push_back(animation.Pass());
   }
 }
 
 namespace{
 
 struct HasAnimationId {
   HasAnimationId(int id): id_(id) {
   }
 
   bool operator()(cc::Animation* animation) const {
     return animation->id() == id_;
   }
 
  private:
   int id_;
 };
 
 }
 
 void Layer::RemoveThreadedAnimation(int animation_id) {
   DCHECK(cc_layer_);
   if (pending_threaded_animations_.size() == 0) {
-    animation_player_ ? animation_player_->RemoveAnimation(animation_id)
-                      : cc_layer_->RemoveAnimation(animation_id);
+    animation_player_->RemoveAnimation(animation_id);
     return;
   }
 
   pending_threaded_animations_.erase(
       cc::remove_if(&pending_threaded_animations_,
                     pending_threaded_animations_.begin(),
                     pending_threaded_animations_.end(),
                     HasAnimationId(animation_id)),
       pending_threaded_animations_.end());
 }
 
 LayerAnimatorCollection* Layer::GetLayerAnimatorCollection() {
   Compositor* compositor = GetCompositor();
   return compositor ? compositor->layer_animator_collection() : NULL;
 }
 
 void Layer::SendPendingThreadedAnimations() {
   for (cc::ScopedPtrVector<cc::Animation>::iterator it =
            pending_threaded_animations_.begin();
        it != pending_threaded_animations_.end(); ++it) {
-    animation_player_
-        ? animation_player_->AddAnimation(pending_threaded_animations_.take(it))
-        : (void)cc_layer_->AddAnimation(pending_threaded_animations_.take(it));
+    animation_player_->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) {
@@ skipping 12 matching lines @@
   cc_layer_->SetTransformOrigin(gfx::Point3F());
   cc_layer_->SetContentsOpaque(true);
   cc_layer_->SetIsDrawable(type_ != LAYER_NOT_DRAWN);
   cc_layer_->SetLayerClient(this);
   RecomputePosition();
 }
 
 void Layer::AttachAnimationObserversAndLayer() {
   DCHECK(cc_layer_);
 
-  if (animation_player_) {
-    animation_player_->AttachLayer(cc_layer_->id());
-    DCHECK(animation_player_->layer_animation_controller());
-    animation_player_->layer_animation_controller()->AddEventObserver(this);
-  } else {
-    if (cc_layer_->layer_animation_controller())
-      cc_layer_->AddLayerAnimationEventObserver(this);
-  }
+  animation_player_->AttachLayer(cc_layer_->id());
+  DCHECK(animation_player_->layer_animation_controller());
+  animation_player_->layer_animation_controller()->AddEventObserver(this);
 
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->AttachAnimationObserversAndLayer();
 }
 
 void Layer::DetachAnimationObserversAndLayer() {
-  if (animation_player_) {
-    if (animation_player_->layer_animation_controller()) {
-      animation_player_->layer_animation_controller()->RemoveEventObserver(this);
-      animation_player_->DetachLayer();
-    }
-  } else {
-    if (cc_layer_->layer_animation_controller())
-      cc_layer_->RemoveLayerAnimationEventObserver(this);
+  if (animation_player_->layer_animation_controller()) {
+    animation_player_->layer_animation_controller()->RemoveEventObserver(this);
+    animation_player_->DetachLayer();
   }
 
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->DetachAnimationObserversAndLayer();
 }
 
 void Layer::CreateAnimationPlayers(Compositor* compositor) {
   DCHECK(compositor);
-  const cc::LayerTreeHost& host = compositor->GetLayerTreeHost();
-  cc_layer_->RegisterForAnimations(host.animation_registrar(), host.settings());
 
-  if (host.settings().use_compositor_animation_timelines) {
-    if (!animation_player_) {
-      animation_player_ =
-          cc::AnimationPlayer::Create(cc::AnimationIdProvider::NextPlayerId());
-    }
-  }
+  animation_player_ =
+      cc::AnimationPlayer::Create(cc::AnimationIdProvider::NextPlayerId());
 
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->CreateAnimationPlayers(compositor);
 }
 
 void Layer::AttachAnimationPlayer(Compositor* compositor) {
   DCHECK(compositor);
 
-  if (animation_player_)
-    compositor->GetAnimationTimeline()->AttachPlayer(animation_player_.get());
+  compositor->GetAnimationTimeline()->AttachPlayer(animation_player_.get());
 
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->AttachAnimationPlayer(compositor);
 }
 
 void Layer::DetachAnimationPlayer() {
   Compositor* compositor = GetCompositor();
   DCHECK(compositor);
 
-  if (animation_player_)
-    compositor->GetAnimationTimeline()->DetachPlayer(animation_player_.get());
+  compositor->GetAnimationTimeline()->DetachPlayer(animation_player_.get());
 
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->DetachAnimationPlayer();
 }
 
 gfx::Transform Layer::transform() const {
   return cc_layer_->transform();
 }
 
 void Layer::RecomputeDrawsContentAndUVRect() {
@@ skipping 38 matching lines @@
       children_.end(),
       std::bind2nd(std::mem_fun(&Layer::RemoveAnimatorsInTreeFromCollection),
                    collection));
 }
 
 bool Layer::IsAnimating() const {
   return animator_.get() && animator_->is_animating();
 }
 
 }  // namespace ui