Explicit animation support

ui/gfx/compositor/layer_animator.cc

Index: ui/gfx/compositor/layer_animator.cc
diff --git a/ui/gfx/compositor/layer_animator.cc b/ui/gfx/compositor/layer_animator.cc
index 5f2c63cebe3e75700e6aa514066550aa6456bc99..77a9d51eb8bbea2620b812464234f4cd959494f7 100644
--- a/ui/gfx/compositor/layer_animator.cc
+++ b/ui/gfx/compositor/layer_animator.cc
@@ -5,182 +5,265 @@
 #include "ui/gfx/compositor/layer_animator.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_preemption_strategy.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);
-}
+// TODO(vollick) match kennedy theme.

[sky, 2011/10/14 16:39:52]

?

+static const int kDefaultTransitionDurationMs = 250;
+static const int kDefaultFramerateHz = 50;
 
-SkMScalar GetMatrixElement(const SkMatrix44& matrix, int index) {
-  int row = index / 4;
-  int col = index % 4;
-  return matrix.get(row, col);
-}
+class LayerAnimation : public Animation {

[sky, 2011/10/14 16:39:52]

I think you'll be better off implementating AnimationContainerElement. Less
baggage.

+ public:
+  // The layer animation does not own the animator.
+  explicit LayerAnimation(LayerAnimator* animator)
+      : Animation(base::TimeDelta::FromMilliseconds(kDefaultFramerateHz)),
+        animator_(animator) {
+  }
+  virtual ~LayerAnimation() {}
 
-} // anonymous namespace
+ private:
+  // Implementation of Animation
+  double GetCurrentValue() const { return 0.0; }
+  virtual void Step(base::TimeTicks time_now) { animator_->Step(time_now); }
 
-namespace ui {
+  LayerAnimator* animator_;
+};
+
+} // namespace;
+
+/* static */
+LayerAnimator* LayerAnimator::CreateDefaultAnimator() {
+  return new LayerAnimator(base::TimeDelta::FromMilliseconds(0));
+}
+
+/* static */
+LayerAnimator* LayerAnimator::CreateImplicitAnimator() {
+  return new LayerAnimator(
+      base::TimeDelta::FromMilliseconds(kDefaultTransitionDurationMs));
+}
 
-LayerAnimator::LayerAnimator(Layer* layer)
-    : layer_(layer),
-      got_initial_tick_(false) {
+LayerAnimator::LayerAnimator(base::TimeDelta transition_duration)
+    : layer_(NULL),
+      preemption_strategy_(
+          LayerAnimationPreemptionStrategy::GetImmediatelySetNewTarget()),
+      transition_duration_(transition_duration),
+      ALLOW_THIS_IN_INITIALIZER_LIST(animation_(new LayerAnimation(this))) {
 }
 
 LayerAnimator::~LayerAnimator() {
+  ClearAnimations();
 }
 
-void LayerAnimator::SetAnimation(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);
-    got_initial_tick_ = false;
-  }
+void LayerAnimator::SetTransform(const Transform& transform) {
+  SetAnimation(new LayerAnimationSequence(
+      LayerAnimationElement::CreateTransformElement(transform,
+                                                    transition_duration_)));
 }
 
-void LayerAnimator::AnimateToPoint(const gfx::Point& target) {
-  StopAnimating(LOCATION);
-  const gfx::Rect& layer_bounds = layer_->bounds();
-  if (target == layer_bounds.origin())
-    return;  // Already there.
+void LayerAnimator::SetBounds(const gfx::Rect& bounds) {
+  SetAnimation(new LayerAnimationSequence(
+      LayerAnimationElement::CreateBoundsElement(bounds,
+                                                 transition_duration_)));
+}
 
-  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::SetOpacity(float opacity) {
+  SetAnimation(new LayerAnimationSequence(
+      LayerAnimationElement::CreateOpacityElement(opacity,
+                                                  transition_duration_)));
 }
 
-void LayerAnimator::AnimateTransform(const Transform& transform) {
-  StopAnimating(TRANSFORM);
-  const Transform& layer_transform = layer_->transform();
-  if (transform == layer_transform)
-    return;  // Already there.
+void LayerAnimator::SetLayer(Layer* layer) {
+  layer_ = layer;
+  if (!layer_) {
+    ClearAnimations();
+  }
+}
 
-  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::SetAnimation(LayerAnimationSequence* animation) {
+  if (!StartSequence(animation)) {
+    preemption_strategy_->Preempt(layer(),
+                                  animation,
+                                  &running_animations_,
+                                  &animation_queue_);
   }
+  FinishAnyAnimationWithZeroDuration();
 }
 
-void LayerAnimator::AnimateOpacity(float target_opacity) {
-  StopAnimating(OPACITY);
-  if (layer_->opacity() == target_opacity)
-    return;
+void LayerAnimator::EnqueueAnimation(LayerAnimationSequence* animation) {
+  animation_queue_.push_back(make_scoped_refptr(animation));
+  if (animation_queue_.size() == 1) {
+    SetAnimation(animation);
+  }
+}
 
-  Params& element = elements_[OPACITY];
-  element.opacity.start = layer_->opacity();
-  element.opacity.target = target_opacity;
+bool LayerAnimator::IsAnimating() const {
+  return running_animations_.size() > 0;
 }
 
-gfx::Point LayerAnimator::GetTargetPoint() {
-  return IsAnimating(LOCATION) ?
-      gfx::Point(elements_[LOCATION].location.target_x,
-                 elements_[LOCATION].location.target_y) :
-      layer_->bounds().origin();
+void LayerAnimator::StopAnimatingProperty(
+    LayerAnimationElement::AnimatableProperty property) {
+  while (true) {
+    RunningAnimation* running = GetRunningAnimation(property);
+    if (!running)
+      break;
+    FinishAnimation(running->sequence);
+  }
 }
 
-float LayerAnimator::GetTargetOpacity() {
-  return IsAnimating(OPACITY) ?
-      elements_[OPACITY].opacity.target : layer_->opacity();
+void LayerAnimator::StopAnimating() {
+  while (IsAnimating())
+    FinishAnimation(running_animations_[0].sequence);
 }
 
-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]);
+void LayerAnimator::Step(base::TimeTicks now) {
+  RunningAnimations running_animations_copy = running_animations_;
+  RunningAnimations::iterator iter = running_animations_copy.begin();
+  while (iter != running_animations_copy.end()) {
+    base::TimeDelta delta = now - (*iter).start_time;
+    if (delta > (*iter).sequence->duration()) {
+      FinishAnimation((*iter).sequence);
+    } else {
+      (*iter).sequence->Progress(delta, layer());
     }
-    return transform;
+    ++iter;
   }
-  return layer_->transform();
 }
 
-bool LayerAnimator::IsAnimating(AnimationProperty property) const {
-  return elements_.count(property) > 0;
+void LayerAnimator::UpdateAnimationState() {
+  if (IsAnimating())
+    animation_->Start();
+  else
+    animation_->Stop();
+}
+
+void LayerAnimator::RemoveAnimation(LayerAnimationSequence* sequence) {
+    // First remove from running animations
+  RunningAnimations::iterator iter = running_animations_.begin();
+  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).get() == sequence) {
+      animation_queue_.erase(queue_iter);
+      break;
+    }
+    ++queue_iter;
+  }
 }
 
-bool LayerAnimator::IsRunning() const {
-  return animation_.get() && animation_->is_animating();
+void LayerAnimator::FinishAnimation(LayerAnimationSequence* sequence) {
+  sequence->Progress(sequence->duration(), layer());
+  RemoveAnimation(sequence);
+  ProcessQueue();
+  UpdateAnimationState();
 }
 
-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);
-        break;
-      }
+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(), layer());
+      RemoveAnimation((*iter).sequence);
+    }
+    ++iter;
+  }
+  ProcessQueue();
+  UpdateAnimationState();
+}
 
-      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;
-      }
+void LayerAnimator::ClearAnimations() {
+  RunningAnimations::iterator iter = running_animations_.begin();
+  while (iter != running_animations_.end()) {
+    (*iter).sequence->Abort();
+    ++iter;
+  }
+  running_animations_.clear();
+  animation_queue_.clear();
+  UpdateAnimationState();
+}
 
-      case OPACITY: {
-        delegate()->SetOpacityFromAnimator(animation_->CurrentValueBetween(
-            i->second.opacity.start, i->second.opacity.target));
-        break;
-      }
+LayerAnimator::RunningAnimation* LayerAnimator::GetRunningAnimation(
+    LayerAnimationElement::AnimatableProperty property) {
+  RunningAnimations::iterator iter = running_animations_.begin();
+  while (iter != running_animations_.end()) {
+    if ((*iter).sequence->properties().find(property) !=
+        (*iter).sequence->properties().end())
+      return &(*iter);
+    ++iter;
+  }
+  return NULL;
+}
 
-      default:
-        NOTREACHED();
+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).get() == animation) {
+      found_sequence = true;
+      break;
     }
+    ++queue_iter;
   }
-  layer_->ScheduleDraw();
+
+  if (!found_sequence)
+    animation_queue_.push_front(make_scoped_refptr(animation));
 }
 
-void LayerAnimator::AnimationEnded(const ui::Animation* animation) {
-  AnimationProgressed(animation);
+void LayerAnimator::ProcessQueue() {
+  bool started_sequence = false;
+  do {
+    started_sequence = false;
+    LayerAnimator::AnimationQueue::iterator iter = animation_queue_.begin();
+    while (iter != animation_queue_.end()) {
+      if (StartSequence((*iter).get())) {
+        started_sequence = true;
+        break;
+      }
+      ++iter;
+    }
+  } while (started_sequence);
 }
 
-void LayerAnimator::StopAnimating(AnimationProperty property) {
-  if (!IsAnimating(property))
-    return;
+bool LayerAnimator::StartSequence(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))
+      return false;
+    ++iter;
+  }
 
-  elements_.erase(property);
-}
+  // 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).
+  running_animations_.push_back(
+      RunningAnimation(sequence, base::TimeTicks::Now()));

[sky, 2011/10/14 16:39:52]

The expectations of multiple calls to start an animation during the same event
are that they all start at the same time. Doing this results in skew.

 
-LayerAnimatorDelegate* LayerAnimator::delegate() {
-  return static_cast<LayerAnimatorDelegate*>(layer_);
+  // Need to keep a reference to the animation.
+  AddToQueueIfNotPresent(sequence);
+  return true;
 }
 
 }  // namespace ui