Explicit animation support

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/stl_util.h"
-#include "ui/base/animation/animation_container.h"
+#include "base/memory/scoped_ptr.h"
 #include "ui/base/animation/animation.h"
-#include "ui/base/animation/tween.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "ui/gfx/compositor/layer.h"
-#include "ui/gfx/compositor/layer_animator_delegate.h"
-#include "ui/gfx/transform.h"
-#include "ui/gfx/rect.h"
+#include "ui/gfx/compositor/layer_animation_sequence.h"
+
+namespace ui {
+
+class LayerAnimator;
 
 namespace {
 
-void SetMatrixElement(SkMatrix44& matrix, int index, SkMScalar value) {
-  int row = index / 4;
-  int col = index % 4;
-  matrix.set(row, col, value);
-}
-
-SkMScalar GetMatrixElement(const SkMatrix44& matrix, int index) {
-  int row = index / 4;
-  int col = index % 4;
-  return matrix.get(row, col);
-}
-
-} // anonymous namespace
-
-namespace ui {
-
-LayerAnimator::LayerAnimator(Layer* layer)
-    : layer_(layer),
-      got_initial_tick_(false) {
+static const int kDefaultTransitionDurationMs = 250;
+static const int kDefaultFramerateHz = 10;
+
+class LayerAnimation : public Animation {
+ public:
+  // The layer animation does not own the animator.
+  explicit LayerAnimation(LayerAnimator* animator)
+      : Animation(base::TimeDelta::FromMilliseconds(kDefaultFramerateHz)),
+        animator_(animator) {
+  }
+  virtual ~LayerAnimation() {}
+
+ private:
+  // Implementation of Animation
+  double GetCurrentValue() const { return 0.0; }

[sky, 2011/10/19 00:06:33]

virtual/OVERRIDE

+  virtual void Step(base::TimeTicks time_now) { animator_->Step(time_now); }

[sky, 2011/10/19 00:06:33]

OVERRIDE

+
+  LayerAnimator* animator_;
+};

[sky, 2011/10/19 00:06:33]

DISALLOW_COPY_AND_ASSIGN

+
+} // namespace;
+
+/* static */

[sky, 2011/10/19 00:06:33]

/* static */ -> // static

+LayerAnimator* LayerAnimator::CreateDefaultAnimator() {
+  return new LayerAnimator(base::TimeDelta::FromMilliseconds(0));
+}
+
+/* static */
+LayerAnimator* LayerAnimator::CreateImplicitAnimator() {
+  return new LayerAnimator(
+      base::TimeDelta::FromMilliseconds(kDefaultTransitionDurationMs));
+}
+
+LayerAnimator::LayerAnimator(base::TimeDelta transition_duration)
+    : delegate_(NULL),
+      preemption_strategy_(IMMEDIATELY_SET_NEW_TARGET),
+      transition_duration_(transition_duration),
+      ALLOW_THIS_IN_INITIALIZER_LIST(animation_(new LayerAnimation(this))) {
 }
 
 LayerAnimator::~LayerAnimator() {
-}
-
-void LayerAnimator::SetAnimation(Animation* animation) {
+  ClearAnimations();
+}
+
+void LayerAnimator::SetTransform(const Transform& transform) {
+  StartAnimation(new LayerAnimationSequence(
+      LayerAnimationElement::CreateTransformElement(transform,
+                                                    transition_duration_)));
+}
+
+void LayerAnimator::SetBounds(const gfx::Rect& bounds) {
+  StartAnimation(new LayerAnimationSequence(
+      LayerAnimationElement::CreateBoundsElement(bounds,
+                                                 transition_duration_)));
+}
+
+void LayerAnimator::SetOpacity(float opacity) {
+  StartAnimation(new LayerAnimationSequence(
+      LayerAnimationElement::CreateOpacityElement(opacity,
+                                                  transition_duration_)));
+}
+
+void LayerAnimator::SetDelegate(LayerAnimationDelegate* delegate) {
+  delegate_ = delegate;
+  if (!delegate_) {

[sky, 2011/10/19 15:43:25]

remove {} Why does no delegate imply you need to clear the animations?

+    ClearAnimations();
+  }
+}
+
+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();
+}
+
+void LayerAnimator::ScheduleAnimation(LayerAnimationSequence* animation) {
+  animation_queue_.push_back(animation);
+  ProcessQueue();
+}
+
+void LayerAnimator::ScheduleTogether(
+  const std::vector<LayerAnimationSequence*>& animations) {

[sky, 2011/10/19 15:43:25]

nit: spacing

+  // Collect all the affected properties.
+  LayerAnimationElement::AnimatableProperties animated_properties;
+  std::vector<LayerAnimationSequence*>::const_iterator iter =

[sky, 2011/10/19 15:43:25]

move iterator into for loop.

+      animations.begin();
+  while (iter != animations.end()) {
+    LayerAnimationElement::AnimatableProperties::const_iterator prop_iter =

[sky, 2011/10/19 15:43:25]

Can this be animated_properties.insert((*iter)->properties().begin(), ...end())?

+        (*iter)->properties().begin();
+    while (prop_iter != (*iter)->properties().end()) {
+      animated_properties.insert(*prop_iter);
+      ++prop_iter;
+    }
+    ++iter;
+  }
+
+  // Scheduling a zero duration pause that affects all the animated properties
+  // will prevent any of the sequences from animating until all the properties
+  // are free.

[sky, 2011/10/19 15:43:25]

free? Do you mean existing animations done?

+  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.
+  iter = animations.begin();
+  while (iter != animations.end()) {
+    ScheduleAnimation(*iter);
+    ++iter;
+  }
+}
+
+bool LayerAnimator::IsAnimating() const {
+  return animation_queue_.size() > 0;

[sky, 2011/10/19 15:43:25]

!empty(). You can inline this if you want.

+}
+
+void LayerAnimator::StopAnimatingProperty(
+    LayerAnimationElement::AnimatableProperty property) {
+  while (true) {
+    RunningAnimation* running = GetRunningAnimation(property);
+    if (!running)
+      break;
+    FinishAnimation(running->sequence);
+  }
+}
+
+void LayerAnimator::StopAnimating() {
+  while (IsAnimating())
+    FinishAnimation(running_animations_[0].sequence);
+}
+
+void LayerAnimator::Step(base::TimeTicks now) {
+  TRACE_EVENT0("LayerAnimator", "Step");
+  last_step_time_ = now;
+  RunningAnimations running_animations_copy = running_animations_;

[sky, 2011/10/19 15:43:25]

Document why you need to make a copy.

+  RunningAnimations::iterator iter = running_animations_copy.begin();

[sky, 2011/10/19 15:43:25]

move iterator into for lop.

+  while (iter != running_animations_copy.end()) {
+    base::TimeDelta delta = now - (*iter).start_time;
+    if (delta >= (*iter).sequence->duration() &&
+        !(*iter).sequence->is_cyclic()) {
+      FinishAnimation((*iter).sequence);
+    } else {
+      (*iter).sequence->Progress(delta, delegate());
+    }
+    ++iter;
+  }
+}
+
+void LayerAnimator::SetAnimationForTest(Animation* animation) {
   animation_.reset(animation);
-  if (animation_.get()) {
-    static ui::AnimationContainer* container = NULL;
-    if (!container) {
-      container = new AnimationContainer;
-      container->AddRef();
-    }
-    animation_->set_delegate(this);
-    animation_->SetContainer(container);

[sky, 2011/10/19 00:06:33]

Make all animations share the same container like the old code was doing.

-    got_initial_tick_ = false;
-  }
-}
-
-void LayerAnimator::AnimateToPoint(const gfx::Point& target) {
-  StopAnimating(LOCATION);
-  const gfx::Rect& layer_bounds = layer_->bounds();
-  if (target == layer_bounds.origin())
-    return;  // Already there.
-
-  Params& element = elements_[LOCATION];
-  element.location.target_x = target.x();
-  element.location.target_y = target.y();
-  element.location.start_x = layer_bounds.origin().x();
-  element.location.start_y = layer_bounds.origin().y();
-}
-
-void LayerAnimator::AnimateTransform(const Transform& transform) {
-  StopAnimating(TRANSFORM);
-  const Transform& layer_transform = layer_->transform();
-  if (transform == layer_transform)
-    return;  // Already there.
-
-  Params& element = elements_[TRANSFORM];
-  for (int i = 0; i < 16; ++i) {
-    element.transform.start[i] =
-        GetMatrixElement(layer_transform.matrix(), i);
-    element.transform.target[i] =
-        GetMatrixElement(transform.matrix(), i);
-  }
-}
-
-void LayerAnimator::AnimateOpacity(float target_opacity) {
-  StopAnimating(OPACITY);
-  if (layer_->opacity() == target_opacity)
+}
+
+void LayerAnimator::UpdateAnimationState() {
+  if (!animation_.get())
     return;
 
-  Params& element = elements_[OPACITY];
-  element.opacity.start = layer_->opacity();
-  element.opacity.target = target_opacity;
-}
-
-gfx::Point LayerAnimator::GetTargetPoint() {
-  return IsAnimating(LOCATION) ?
-      gfx::Point(elements_[LOCATION].location.target_x,
-                 elements_[LOCATION].location.target_y) :
-      layer_->bounds().origin();
-}
-
-float LayerAnimator::GetTargetOpacity() {
-  return IsAnimating(OPACITY) ?
-      elements_[OPACITY].opacity.target : layer_->opacity();
-}
-
-ui::Transform LayerAnimator::GetTargetTransform() {
-  if (IsAnimating(TRANSFORM)) {
-    Transform transform;
-    for (int i = 0; i < 16; ++i) {
-      SetMatrixElement(transform.matrix(), i,
-                       elements_[TRANSFORM].transform.target[i]);
-    }
-    return transform;
-  }
-  return layer_->transform();
-}
-
-bool LayerAnimator::IsAnimating(AnimationProperty property) const {
-  return elements_.count(property) > 0;
-}
-
-bool LayerAnimator::IsRunning() const {
-  return animation_.get() && animation_->is_animating();
-}
-
-void LayerAnimator::AnimationProgressed(const ui::Animation* animation) {
-  got_initial_tick_ = true;
-  for (Elements::const_iterator i = elements_.begin(); i != elements_.end();
-       ++i) {
-    switch (i->first) {
-      case LOCATION: {
-        const gfx::Rect& current_bounds(layer_->bounds());
-        gfx::Rect new_bounds = animation_->CurrentValueBetween(
-            gfx::Rect(gfx::Point(i->second.location.start_x,
-                                 i->second.location.start_y),
-                      current_bounds.size()),
-            gfx::Rect(gfx::Point(i->second.location.target_x,
-                                 i->second.location.target_y),
-                      current_bounds.size()));
-        delegate()->SetBoundsFromAnimator(new_bounds);
+  if (IsAnimating())
+    animation_->Start();
+  else
+    animation_->Stop();
+}
+
+void LayerAnimator::RemoveAnimation(LayerAnimationSequence* sequence) {
+    // First remove from running animations
+  RunningAnimations::iterator iter = running_animations_.begin();

[sky, 2011/10/19 15:43:25]

move into for loop.

+  while (iter != running_animations_.end()) {
+    if ((*iter).sequence == sequence) {
+      running_animations_.erase(iter);
+      break;
+    }
+    ++iter;
+  }
+
+  // Then remove from the queue
+  AnimationQueue::iterator queue_iter = animation_queue_.begin();
+  while (queue_iter != animation_queue_.end()) {
+    if ((*queue_iter) == sequence) {
+      animation_queue_.erase(queue_iter);
+      break;
+    }
+    ++queue_iter;
+  }
+}
+
+void LayerAnimator::FinishAnimation(LayerAnimationSequence* sequence) {
+  sequence->Progress(sequence->duration(), delegate());
+  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.
+  RunningAnimations copy = running_animations_;
+  RunningAnimations::iterator iter = copy.begin();
+  while (iter != copy.end()) {
+    if ((*iter).sequence->duration() == base::TimeDelta()) {
+      (*iter).sequence->Progress((*iter).sequence->duration(), delegate());
+      RemoveAnimation((*iter).sequence);
+    }
+    ++iter;
+  }
+  ProcessQueue();
+  UpdateAnimationState();
+}
+
+void LayerAnimator::ClearAnimations() {
+  RunningAnimations::iterator iter = running_animations_.begin();
+  while (iter != running_animations_.end()) {
+    (*iter).sequence->Abort();
+    ++iter;
+  }
+  running_animations_.clear();
+  animation_queue_.reset();
+  UpdateAnimationState();
+}
+
+LayerAnimator::RunningAnimation* LayerAnimator::GetRunningAnimation(
+    LayerAnimationElement::AnimatableProperty property) {
+  RunningAnimations::iterator iter = running_animations_.begin();

[sky, 2011/10/19 15:43:25]

move into for loop.

+  while (iter != running_animations_.end()) {
+    if ((*iter).sequence->properties().find(property) !=
+        (*iter).sequence->properties().end())
+      return &(*iter);
+    ++iter;
+  }
+  return NULL;
+}
+
+void LayerAnimator::AddToQueueIfNotPresent(LayerAnimationSequence* animation) {
+  // If we don't have the animation in the queue yet, add it.
+  bool found_sequence = false;
+  AnimationQueue::iterator queue_iter = animation_queue_.begin();
+  while (queue_iter != animation_queue_.end()) {
+    if ((*queue_iter) == animation) {
+      found_sequence = true;
+      break;
+    }
+    ++queue_iter;
+  }
+
+  if (!found_sequence)
+    animation_queue_.insert(animation_queue_.begin(), animation);
+}
+
+void LayerAnimator::RemoveAllAnimationsWithACommonProperty(
+    LayerAnimationSequence* sequence,
+    bool abort) {
+  // For all the running animations, if they animate the same property,
+  // progress them to the end and remove them.
+  RunningAnimations copy = running_animations_;
+  RunningAnimations::const_iterator iter = copy.begin();
+  while (iter != copy.end()) {
+    if ((*iter).sequence->HasCommonProperty(sequence->properties())) {
+      // Finish the animation.
+      if (abort)
+        (*iter).sequence->Abort();
+      else
+        (*iter).sequence->Progress((*iter).sequence->duration(), delegate());
+      RemoveAnimation((*iter).sequence);
+    }
+    ++iter;
+  }
+  // Same for the queued animations.
+  AnimationQueue::size_type i = 0;
+  while (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]);
+    } else {
+      ++i;
+    }
+  }
+}
+
+void LayerAnimator::ImmediatelySetNewTarget(LayerAnimationSequence* sequence) {
+  const bool abort = false;
+  RemoveAllAnimationsWithACommonProperty(sequence, abort);
+  sequence->Progress(sequence->duration(), delegate());
+  RemoveAnimation(sequence);
+}
+
+void LayerAnimator::ImmediatelyAnimateToNewTarget(
+    LayerAnimationSequence* sequence) {
+  const bool abort = true;
+  RemoveAllAnimationsWithACommonProperty(sequence, abort);
+  AddToQueueIfNotPresent(sequence);
+  StartSequenceImmediately(sequence);
+}
+
+void LayerAnimator::EnqueueNewAnimation(LayerAnimationSequence* sequence) {
+  // It is assumed that if there was no conflicting animation, we would
+  // not have been called. No need to check for a collision; just
+  // add to the queue.
+  animation_queue_.push_back(sequence);
+  ProcessQueue();
+}
+
+void LayerAnimator::ReplaceQueuedAnimations(LayerAnimationSequence* sequence) {
+  // Remove all animations that aren't running.
+  AnimationQueue::size_type i = 0;
+  while (i < animation_queue_.size()) {
+    bool is_running = false;
+    RunningAnimations::const_iterator iter =
+        running_animations_.begin();
+    while (iter != running_animations_.end()) {
+      if ((*iter).sequence == animation_queue_[i]) {
+        is_running = true;
         break;
       }
-
-      case TRANSFORM: {
-        Transform transform;
-        for (int j = 0; j < 16; ++j) {
-          SkMScalar value = animation_->CurrentValueBetween(
-              i->second.transform.start[j],
-              i->second.transform.target[j]);
-          SetMatrixElement(transform.matrix(), j, value);
-        }
-        delegate()->SetTransformFromAnimator(transform);
-        break;
+      ++iter;
+    }
+    if (!is_running)
+      RemoveAnimation(animation_queue_[i]);
+    else
+      ++i;
+  }
+  animation_queue_.push_back(sequence);
+  ProcessQueue();
+}
+
+void LayerAnimator::ProcessQueue() {
+  bool started_sequence = false;
+
+  do {
+    started_sequence = false;
+
+    // Build a list of all currently animated properties.
+    LayerAnimationElement::AnimatableProperties animated;
+    RunningAnimations::const_iterator iter = running_animations_.begin();
+    while (iter != running_animations_.end()) {
+      LayerAnimationElement::AnimatableProperties::const_iterator prop_iter =
+          (*iter).sequence->properties().begin();
+      while (prop_iter != (*iter).sequence->properties().end()) {
+        animated.insert(*prop_iter);
+        ++prop_iter;
       }
-
-      case OPACITY: {
-        delegate()->SetOpacityFromAnimator(animation_->CurrentValueBetween(
-            i->second.opacity.start, i->second.opacity.target));
+      ++iter;
+    }
+
+    // Try to find an animation that doesn't conflict with an animated
+    // property or a property that will be animated before it.
+    AnimationQueue::iterator queue_iter = animation_queue_.begin();
+    while (queue_iter != animation_queue_.end()) {
+      if (!(*queue_iter)->HasCommonProperty(animated)) {
+        StartSequenceImmediately(*queue_iter);
+        started_sequence = true;
         break;
       }
-
-      default:
-        NOTREACHED();
-    }
-  }
-  layer_->ScheduleDraw();
-}
-
-void LayerAnimator::AnimationEnded(const ui::Animation* animation) {
-  AnimationProgressed(animation);
-}
-
-void LayerAnimator::StopAnimating(AnimationProperty property) {
-  if (!IsAnimating(property))
-    return;
-
-  elements_.erase(property);
-}
-
-LayerAnimatorDelegate* LayerAnimator::delegate() {
-  return static_cast<LayerAnimatorDelegate*>(layer_);
+      // Animation couldn't be started. Add its properties to the collection so
+      // that we don't start a conflicting animation. For example, if our queue
+      // has the elements { {T,B}, {B} } (that is, an element that animates both
+      // the transform and the bounds followed by an element that animates the
+      // bounds), and we're currently animating the transform, we can't start
+      // the first element because it animates the transform, too. We cannot
+      // start the second element, either, because the first element animates
+      // bounds too, and needs to go first.
+      LayerAnimationElement::AnimatableProperties::const_iterator prop_iter =
+          (*queue_iter)->properties().begin();
+      while (prop_iter != (*queue_iter)->properties().end()) {
+        animated.insert(*prop_iter);
+        ++prop_iter;
+      }
+      ++queue_iter;
+    }
+
+    // If we started a sequence, try again. We may be able to start several.
+  } while (started_sequence);
+}
+
+bool LayerAnimator::StartSequenceImmediately(LayerAnimationSequence* sequence) {
+  // Ensure that no one is animating one of the sequence's properties already.
+  RunningAnimations::const_iterator iter = running_animations_.begin();
+  while (iter != running_animations_.end()) {
+    if ((*iter).sequence->HasCommonProperty(sequence->properties()))
+      return false;
+    ++iter;
+  }
+
+  // All clear, actually start the sequence. Note: base::TimeTicks::Now has
+  // a resolution that can be as bad as 15ms. If this causes glitches in the
+  // animations, this can be switched to HighResNow() (animation uses Now()
+  // internally).
+  base::TimeTicks start_time = IsAnimating()
+      ? last_step_time_
+      : base::TimeTicks::Now();

[sky, 2011/10/19 15:43:25]

For the animating case this effectively starts the animation at 0, which isn't
always the case. Don't you need to adjust based on how far over the last
sequences duration you went?

+
+  running_animations_.push_back(RunningAnimation(sequence, start_time));
+
+  // Need to keep a reference to the animation.
+  AddToQueueIfNotPresent(sequence);
+
+  // Ensure that animations get stepped at their start time.
+  Step(start_time);
+
+  return true;
 }
 
 }  // namespace ui