CC Animations: Port UI Browser Compositor to use compositor animation timelines.

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 "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/trace_event/trace_event.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/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, ...) \
     if (running_anim.is_sequence_alive()) \
@@ skipping 19 matching lines @@
 
 LayerAnimator::LayerAnimator(base::TimeDelta transition_duration)
     : delegate_(NULL),
       preemption_strategy_(IMMEDIATELY_SET_NEW_TARGET),
       is_transition_duration_locked_(false),
       transition_duration_(transition_duration),
       tween_type_(gfx::Tween::LINEAR),
       is_started_(false),
       disable_timer_for_test_(false),
       adding_animations_(false) {
+  if (Layer::UILayerSettings().use_compositor_animation_timelines) {
+    animation_player_ =
+        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;
 }
@@ skipping 59 matching lines @@
   delegate_ = delegate;
   if (delegate_ && is_started_) {
     LayerAnimatorCollection* collection = GetLayerAnimatorCollection();
     if (collection)
       collection->StartAnimator(this);
   }
 }
 
 void LayerAnimator::SwitchToLayer(scoped_refptr<cc::Layer> new_layer) {
   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);
+    timeline->AttachPlayer(animation_player_);
+
     DCHECK(delegate_->GetCcLayer());
-    delegate_->GetCcLayer()->RemoveLayerAnimationEventObserver(this);
+    AttachLayerToAnimationPlayer(delegate_->GetCcLayer()->id());
   }
-  if (new_layer)
-    new_layer->AddLayerAnimationEventObserver(this);
+}
+
+void LayerAnimator::ResetCompositor(Compositor* compositor) {
+  DCHECK(compositor);
+  if (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);
 }
 
 void LayerAnimator::StartAnimation(LayerAnimationSequence* animation) {
   scoped_refptr<LayerAnimator> retain(this);
   OnScheduled(animation);
   if (!StartSequenceImmediately(animation)) {
     // Attempt to preempt a running animation.
     switch (preemption_strategy_) {
       case IMMEDIATELY_SET_NEW_TARGET:
         ImmediatelySetNewTarget(animation);
@@ skipping 721 matching lines @@
 }
 
 LayerAnimator::RunningAnimation::RunningAnimation(
     const base::WeakPtr<LayerAnimationSequence>& sequence)
     : sequence_(sequence) {
 }
 
 LayerAnimator::RunningAnimation::~RunningAnimation() { }
 
 }  // namespace ui