Reland r107720 - Enable the new layer animation framework.

ui/gfx/compositor/layer_animator.cc

 // Copyright (c) 2011 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/gfx/compositor/layer_animator.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/base/animation/animation_container.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/layer.h"
-#include "ui/gfx/compositor/layer_animation_delegate.h"
+#include "ui/gfx/compositor/layer_animator_delegate.h"
 #include "ui/gfx/compositor/layer_animation_sequence.h"
 
 namespace ui {
 
 class LayerAnimator;
 
 namespace {
 
 static const base::TimeDelta kDefaultTransitionDuration =
-    base::TimeDelta::FromMilliseconds(250);
+    base::TimeDelta::FromMilliseconds(200);
 
 static const base::TimeDelta kTimerInterval =
     base::TimeDelta::FromMilliseconds(10);
 
 } // namespace;
 
 // LayerAnimator public --------------------------------------------------------
 
 LayerAnimator::LayerAnimator(base::TimeDelta transition_duration)
     : delegate_(NULL),
@@ skipping 14 matching lines @@
 
 // static
 LayerAnimator* LayerAnimator::CreateImplicitAnimator() {
   return new LayerAnimator(kDefaultTransitionDuration);
 }
 
 void LayerAnimator::SetTransform(const Transform& transform) {
   if (transition_duration_ == base::TimeDelta())
     delegate_->SetTransformFromAnimation(transform);
   else
-    StartAnimation(new LayerAnimationSequence(
-        LayerAnimationElement::CreateTransformElement(transform,
-                                                      transition_duration_)));
+    StartAnimationElement(LayerAnimationElement::CreateTransformElement(
+        transform, transition_duration_));
+}
+
+Transform LayerAnimator::GetTargetTransform() const {
+  LayerAnimationElement::TargetValue target;
+  GetTargetValue(&target);
+  return target.transform;
 }
 
 void LayerAnimator::SetBounds(const gfx::Rect& bounds) {
   if (transition_duration_ == base::TimeDelta())
     delegate_->SetBoundsFromAnimation(bounds);
   else
-    StartAnimation(new LayerAnimationSequence(
-        LayerAnimationElement::CreateBoundsElement(bounds,
-                                                   transition_duration_)));
+    StartAnimationElement(LayerAnimationElement::CreateBoundsElement(
+        bounds, transition_duration_));
+}
+
+gfx::Rect LayerAnimator::GetTargetBounds() const {
+  LayerAnimationElement::TargetValue target;
+  GetTargetValue(&target);
+  return target.bounds;
 }
 
 void LayerAnimator::SetOpacity(float opacity) {
   if (transition_duration_ == base::TimeDelta())
     delegate_->SetOpacityFromAnimation(opacity);
   else
-    StartAnimation(new LayerAnimationSequence(
-        LayerAnimationElement::CreateOpacityElement(opacity,
-                                                    transition_duration_)));
+    StartAnimationElement(LayerAnimationElement::CreateOpacityElement(
+        opacity, transition_duration_));
 }
 
-void LayerAnimator::SetDelegate(LayerAnimationDelegate* delegate) {
+float LayerAnimator::GetTargetOpacity() const {
+  LayerAnimationElement::TargetValue target;
+  GetTargetValue(&target);
+  return target.opacity;
+}
+
+void LayerAnimator::SetDelegate(LayerAnimatorDelegate* delegate) {
   DCHECK(delegate);
   delegate_ = delegate;
 }
 
 void LayerAnimator::StartAnimation(LayerAnimationSequence* animation) {
   if (!StartSequenceImmediately(animation)) {
     // Attempt to preempt a running animation.
     switch (preemption_strategy_) {
       case IMMEDIATELY_SET_NEW_TARGET:
         ImmediatelySetNewTarget(animation);
         break;
       case IMMEDIATELY_ANIMATE_TO_NEW_TARGET:
         ImmediatelyAnimateToNewTarget(animation);
         break;
       case ENQUEUE_NEW_ANIMATION:
         EnqueueNewAnimation(animation);
         break;
       case REPLACE_QUEUED_ANIMATIONS:
         ReplaceQueuedAnimations(animation);
         break;
       case BLEND_WITH_CURRENT_ANIMATION: {
         // TODO(vollick) Add support for blended sequences and use them here.
         NOTIMPLEMENTED();
         break;
       }
     }
   }
   FinishAnyAnimationWithZeroDuration();
+  UpdateAnimationState();
 }
 
 void LayerAnimator::ScheduleAnimation(LayerAnimationSequence* animation) {
   if (is_animating()) {
     animation_queue_.push_back(make_linked_ptr(animation));
     ProcessQueue();
   } else {
     StartSequenceImmediately(animation);
   }
+  UpdateAnimationState();
 }
 
 void LayerAnimator::ScheduleTogether(
     const std::vector<LayerAnimationSequence*>& animations) {
   // Collect all the affected properties.
   LayerAnimationElement::AnimatableProperties animated_properties;
   std::vector<LayerAnimationSequence*>::const_iterator iter;
   for (iter = animations.begin(); iter != animations.end(); ++iter) {
     animated_properties.insert((*iter)->properties().begin(),
                                (*iter)->properties().end());
   }
 
   // Scheduling a zero duration pause that affects all the animated properties
   // will prevent any of the sequences from animating until there are no
   // running animations that affect any of these properties.
   ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreatePauseElement(animated_properties,
                                                     base::TimeDelta())));
 
   // These animations (provided they don't animate any common properties) will
   // now animate together if trivially scheduled.
   for (iter = animations.begin(); iter != animations.end(); ++iter) {
     ScheduleAnimation(*iter);
   }
+
+  UpdateAnimationState();
+}
+
+void LayerAnimator::StartAnimationElement(LayerAnimationElement* animation) {
+  StartAnimation(new LayerAnimationSequence(animation));
+}
+
+void LayerAnimator::ScheduleAnimationElement(LayerAnimationElement* animation) {
+  ScheduleAnimation(new LayerAnimationSequence(animation));
+}
+
+void LayerAnimator::ScheduleElementsTogether(
+    const std::vector<LayerAnimationElement*>& animations) {
+  std::vector<LayerAnimationSequence*> sequences;
+  for (size_t i = 0; i < animations.size(); ++i)
+    sequences.push_back(new LayerAnimationSequence(animations[i]));
+  ScheduleTogether(sequences);
 }
 
 void LayerAnimator::StopAnimatingProperty(
     LayerAnimationElement::AnimatableProperty property) {
   while (true) {
     RunningAnimation* running = GetRunningAnimation(property);
     if (!running)
       break;
     FinishAnimation(running->sequence);
   }
 }
 
 void LayerAnimator::StopAnimating() {
   while (is_animating())
     FinishAnimation(running_animations_[0].sequence);
 }
 
+LayerAnimator::ScopedSettings::ScopedSettings(LayerAnimator* animator)
+    : animator_(animator),
+      old_transition_duration_(animator->transition_duration_) {
+  SetTransitionDuration(kDefaultTransitionDuration);
+}
+
+LayerAnimator::ScopedSettings::~ScopedSettings() {
+  animator_->transition_duration_ = old_transition_duration_;
+}
+
+void LayerAnimator::ScopedSettings::SetTransitionDuration(
+    base::TimeDelta duration) {
+  animator_->transition_duration_ = duration;
+}
+
 // LayerAnimator private -------------------------------------------------------
 
 void LayerAnimator::Step(base::TimeTicks now) {
-  TRACE_EVENT0("LayerAnimator", "Step");
   last_step_time_ = now;
   std::vector<LayerAnimationSequence*> to_finish;
   for (RunningAnimations::iterator iter = running_animations_.begin();
        iter != running_animations_.end(); ++iter) {
     base::TimeDelta delta = now - (*iter).start_time;
     if (delta >= (*iter).sequence->duration() &&
         !(*iter).sequence->is_cyclic()) {
       to_finish.push_back((*iter).sequence);
     } else {
       (*iter).sequence->Progress(delta, delegate());
@@ skipping 46 matching lines @@
        queue_iter != animation_queue_.end(); ++queue_iter) {
     if ((*queue_iter) == sequence) {
       animation_queue_.erase(queue_iter);
       break;
     }
   }
 }
 
 void LayerAnimator::FinishAnimation(LayerAnimationSequence* sequence) {
   sequence->Progress(sequence->duration(), delegate());
+  delegate()->OnLayerAnimationEnded(sequence);
   RemoveAnimation(sequence);
   ProcessQueue();
   UpdateAnimationState();
 }
 
 void LayerAnimator::FinishAnyAnimationWithZeroDuration() {
   // Special case: if we've started a 0 duration animation, just finish it now
   // and get rid of it. Note at each iteration of the loop, we either increment
   // i or remove an element from running_animations_, so
   // running_animations_.size() - i is always decreasing and we are always
   // progressing towards the termination of the loop.
   for (size_t i = 0; i < running_animations_.size();) {
     if (running_animations_[i].sequence->duration() == base::TimeDelta()) {
       running_animations_[i].sequence->Progress(
           running_animations_[i].sequence->duration(), delegate());
+      delegate()->OnLayerAnimationEnded(running_animations_[i].sequence);
       RemoveAnimation(running_animations_[i].sequence);
     } else {
       ++i;
     }
   }
   ProcessQueue();
   UpdateAnimationState();
 }
 
 void LayerAnimator::ClearAnimations() {
@@ skipping 37 matching lines @@
     bool abort) {
   // For all the running animations, if they animate the same property,
   // progress them to the end and remove them. Note: at each iteration i is
   // incremented or an element is removed from the queue, so
   // animation_queue_.size() - i is always decreasing and we are always making
   // progress towards the loop terminating.
   for (size_t i = 0; i < running_animations_.size();) {
     if (running_animations_[i].sequence->HasCommonProperty(
             sequence->properties())) {
       // Finish the animation.
-      if (abort)
+      if (abort){
         running_animations_[i].sequence->Abort();
-      else
+      } else {
         running_animations_[i].sequence->Progress(
             running_animations_[i].sequence->duration(), delegate());
+        delegate()->OnLayerAnimationEnded(running_animations_[i].sequence);
+      }
       RemoveAnimation(running_animations_[i].sequence);
     } else {
       ++i;
     }
   }
 
   // Same for the queued animations. See comment above about loop termination.
   for (size_t i = 0; i < animation_queue_.size();) {
     if (animation_queue_[i]->HasCommonProperty(sequence->properties())) {
       // Finish the animation.
       if (abort)
         animation_queue_[i]->Abort();
       else
         animation_queue_[i]->Progress(animation_queue_[i]->duration(),
                                       delegate());
       RemoveAnimation(animation_queue_[i].get());
     } else {
       ++i;
     }
   }
 }
 
 void LayerAnimator::ImmediatelySetNewTarget(LayerAnimationSequence* sequence) {
   const bool abort = false;
   RemoveAllAnimationsWithACommonProperty(sequence, abort);
   sequence->Progress(sequence->duration(), delegate());
+  delegate()->OnLayerAnimationEnded(sequence);
   RemoveAnimation(sequence);
 }
 
 void LayerAnimator::ImmediatelyAnimateToNewTarget(
     LayerAnimationSequence* sequence) {
   const bool abort = true;
   RemoveAllAnimationsWithACommonProperty(sequence, abort);
   AddToQueueIfNotPresent(sequence);
   StartSequenceImmediately(sequence);
 }
@@ skipping 26 matching lines @@
       ++i;
   }
   animation_queue_.push_back(make_linked_ptr(sequence));
   ProcessQueue();
 }
 
 void LayerAnimator::ProcessQueue() {
   bool started_sequence = false;
   do {
     started_sequence = false;
-
     // Build a list of all currently animated properties.
     LayerAnimationElement::AnimatableProperties animated;
-
     for (RunningAnimations::const_iterator iter = running_animations_.begin();
          iter != running_animations_.end(); ++iter) {
       animated.insert((*iter).sequence->properties().begin(),
                       (*iter).sequence->properties().end());
     }
 
     // Try to find an animation that doesn't conflict with an animated
     // property or a property that will be animated before it.
     for (AnimationQueue::iterator queue_iter = animation_queue_.begin();
          queue_iter != animation_queue_.end(); ++queue_iter) {
@@ skipping 39 matching lines @@
 
   // Need to keep a reference to the animation.
   AddToQueueIfNotPresent(sequence);
 
   // Ensure that animations get stepped at their start time.
   Step(start_time);
 
   return true;
 }
 
+void LayerAnimator::GetTargetValue(
+    LayerAnimationElement::TargetValue* target) const {
+  for (RunningAnimations::const_iterator iter = running_animations_.begin();
+       iter != running_animations_.end(); ++iter) {
+    (*iter).sequence->GetTargetValue(target);
+  }
+}
+
 }  // namespace ui