Thread ui opacity animations

ui/compositor/layer_animation_element.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_animation_element.h"
 
 #include "base/compiler_specific.h"
+#include "cc/animation.h"
+#include "cc/animation_id_provider.h"
 #include "ui/base/animation/tween.h"
+#include "ui/compositor/float_animation_curve_adapter.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/gfx/interpolated_transform.h"
 
 namespace ui {
 
 namespace {
 
 // Pause -----------------------------------------------------------------------
 class Pause : public LayerAnimationElement {
  public:
   Pause(const AnimatableProperties& properties, base::TimeDelta duration)
       : LayerAnimationElement(properties, duration) {
   }
   virtual ~Pause() {}
 
  private:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {}
   virtual bool OnProgress(double t,
                           LayerAnimationDelegate* delegate) OVERRIDE {
     return false;
   }
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {}
-  virtual void OnAbort() OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
   DISALLOW_COPY_AND_ASSIGN(Pause);
 };
 
 // TransformTransition ---------------------------------------------------------
 
 class TransformTransition : public LayerAnimationElement {
  public:
     TransformTransition(const gfx::Transform& target, base::TimeDelta duration)
       : LayerAnimationElement(GetProperties(), duration),
         target_(target) {
   }
   virtual ~TransformTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetTransformForAnimation();
   }
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetTransformFromAnimation(
         Tween::ValueBetween(t, start_, target_));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->transform = target_;
   }
 
-  virtual void OnAbort() OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
   static AnimatableProperties GetProperties() {
     AnimatableProperties properties;
     properties.insert(LayerAnimationElement::TRANSFORM);
     return properties;
   }
 
   gfx::Transform start_;
   const gfx::Transform target_;
@@ skipping 19 matching lines @@
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetTransformFromAnimation(
         interpolated_transform_->Interpolate(static_cast<float>(t)));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->transform = interpolated_transform_->Interpolate(1.0f);
   }
 
-  virtual void OnAbort() OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
   static AnimatableProperties GetProperties() {
     AnimatableProperties properties;
     properties.insert(LayerAnimationElement::TRANSFORM);
     return properties;
   }
 
   scoped_ptr<InterpolatedTransform> interpolated_transform_;
 
@@ skipping 17 matching lines @@
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetBoundsFromAnimation(Tween::ValueBetween(t, start_, target_));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->bounds = target_;
   }
 
-  virtual void OnAbort() OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
   static AnimatableProperties GetProperties() {
     AnimatableProperties properties;
     properties.insert(LayerAnimationElement::BOUNDS);
     return properties;
   }
 
   gfx::Rect start_;
   const gfx::Rect target_;
@@ skipping 19 matching lines @@
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetOpacityFromAnimation(Tween::ValueBetween(t, start_, target_));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->opacity = target_;
   }
 
-  virtual void OnAbort() OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
   static AnimatableProperties GetProperties() {
     AnimatableProperties properties;
     properties.insert(LayerAnimationElement::OPACITY);
     return properties;
   }
 
   float start_;
   const float target_;
@@ skipping 19 matching lines @@
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetVisibilityFromAnimation(t == 1.0 ? target_ : start_);
     return t == 1.0;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->visibility = target_;
   }
 
-  virtual void OnAbort() OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
   static AnimatableProperties GetProperties() {
     AnimatableProperties properties;
     properties.insert(LayerAnimationElement::VISIBILITY);
     return properties;
   }
 
   bool start_;
   const bool target_;
@@ skipping 20 matching lines @@
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetBrightnessFromAnimation(
         Tween::ValueBetween(t, start_, target_));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->brightness = target_;
   }
 
-  virtual void OnAbort() OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
   static AnimatableProperties GetProperties() {
     AnimatableProperties properties;
     properties.insert(LayerAnimationElement::BRIGHTNESS);
     return properties;
   }
 
   float start_;
   const float target_;
@@ skipping 20 matching lines @@
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetGrayscaleFromAnimation(
         Tween::ValueBetween(t, start_, target_));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->grayscale = target_;
   }
 
-  virtual void OnAbort() OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
   static AnimatableProperties GetProperties() {
     AnimatableProperties properties;
     properties.insert(LayerAnimationElement::GRAYSCALE);
     return properties;
   }
 
   float start_;
   const float target_;
@@ skipping 32 matching lines @@
             Tween::ValueBetween(t,
                                 static_cast<int>(SkColorGetB(start_)),
                                 static_cast<int>(SkColorGetB(target_)))));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->color = target_;
   }
 
-  virtual void OnAbort() OVERRIDE {}
+  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
   static AnimatableProperties GetProperties() {
     AnimatableProperties properties;
     properties.insert(LayerAnimationElement::COLOR);
     return properties;
   }
 
   SkColor start_;
   const SkColor target_;
 
   DISALLOW_COPY_AND_ASSIGN(ColorTransition);
 };
 
+// ThreadedLayerAnimationElement -----------------------------------------------
+
+class ThreadedLayerAnimationElement : public LayerAnimationElement {
+ public:
+  ThreadedLayerAnimationElement(const AnimatableProperties& properties,
+                                base::TimeDelta duration)
+      : LayerAnimationElement(properties, duration) {
+  }
+  virtual ~ThreadedLayerAnimationElement() {}
+
+  bool IsThreaded() const {

[sky, 2013/02/19 17:06:56]

virtual OVERRIDE

[ajuma, 2013/02/20 16:09:10]

Done.

+    return (duration() != base::TimeDelta());

[sky, 2013/02/19 17:06:56]

Should whether a LayerAnimationElement is threaded be pushed up to
LayerAnimationElement? By that I mean this check could easily be moved there.

[ajuma, 2013/02/20 16:09:10]

No. Simply checking for non-zero duration in LayerAnimationElement isn't
sufficient, since there will continue to exist non-threaded
LayerAnimationElements (everything other than opacity and transform). Only
descendants of ThreadedLayerAnimationElement that have non-zero duration are
threaded, so the check needs to go here.

+  }
+
+ protected:
+  virtual bool OnProgress(double t,
+                          LayerAnimationDelegate* delegate) OVERRIDE {
+    if (t < 1.0)
+      return false;
+
+    if (animation_id()) {
+      delegate->RemoveThreadedAnimation(animation_id());
+      set_animation_id(0);
+    }
+
+    OnEnd(delegate);
+    return true;
+  }
+
+  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {
+    if (delegate && animation_id()) {
+      delegate->RemoveThreadedAnimation(animation_id());
+      set_animation_id(0);
+    }
+  }
+
+  virtual void RequestEffectiveStart(
+      LayerAnimationDelegate* delegate) OVERRIDE {
+    DCHECK(animation_group_id());
+    set_animation_id(cc::AnimationIdProvider::NextAnimationId());
+    set_effective_start_time(base::TimeTicks());
+    scoped_ptr<cc::Animation> animation = CreateCCAnimation();
+    animation->setNeedsSynchronizedStartTime(true);
+    delegate->AddThreadedAnimation(animation.Pass());
+  }
+
+  virtual void OnEnd(LayerAnimationDelegate* delegate) = 0;
+
+  virtual scoped_ptr<cc::Animation> CreateCCAnimation() = 0;
+
+ private:
+

[sky, 2013/02/19 17:06:56]

nit: remove newline.

[ajuma, 2013/02/20 16:09:10]

Done.

+  DISALLOW_COPY_AND_ASSIGN(ThreadedLayerAnimationElement);
+};
+
+// ThreadedOpacityTransition ---------------------------------------------------
+
+class ThreadedOpacityTransition : public ThreadedLayerAnimationElement {
+ public:
+  ThreadedOpacityTransition(float target, base::TimeDelta duration)
+      : ThreadedLayerAnimationElement(GetProperties(), duration),
+        start_(0.0f),
+        target_(target) {
+  }
+  virtual ~ThreadedOpacityTransition() {}
+
+ protected:
+  virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
+    start_ = delegate->GetOpacityForAnimation();
+  }
+
+  virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {
+    if (delegate && animation_id()) {
+      ThreadedLayerAnimationElement::OnAbort(delegate);
+      delegate->SetOpacityFromAnimation(
+          Tween::ValueBetween(last_progressed_fraction(), start_, target_));
+    }
+  }
+
+  virtual void OnEnd(LayerAnimationDelegate* delegate) OVERRIDE {
+    delegate->SetOpacityFromAnimation(target_);
+  }
+
+  virtual scoped_ptr<cc::Animation> CreateCCAnimation() OVERRIDE {
+    scoped_ptr<cc::AnimationCurve> animation_curve(
+        new FloatAnimationCurveAdapter(tween_type(),
+                                       start_,
+                                       target_,
+                                       duration()));
+    scoped_ptr<cc::Animation> animation(
+        cc::Animation::create(animation_curve.Pass(),
+                              animation_id(),
+                              animation_group_id(),
+                              cc::Animation::Opacity));
+    return animation.Pass();
+  }
+
+  virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
+    target->opacity = target_;
+  }
+
+ private:
+  static AnimatableProperties GetProperties() {
+    AnimatableProperties properties;
+    properties.insert(LayerAnimationElement::OPACITY);
+    return properties;
+  }
+
+  float start_;
+  const float target_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadedOpacityTransition);
+};
+
 }  // namespace
 
 // LayerAnimationElement::TargetValue ------------------------------------------
 
 LayerAnimationElement::TargetValue::TargetValue()
     : opacity(0.0f),
       visibility(false),
       brightness(0.0f),
       grayscale(0.0f),
       color(SK_ColorBLACK) {
@@ skipping 12 matching lines @@
 }
 
 // LayerAnimationElement -------------------------------------------------------
 
 LayerAnimationElement::LayerAnimationElement(
     const AnimatableProperties& properties,
     base::TimeDelta duration)
     : first_frame_(true),
       properties_(properties),
       duration_(GetEffectiveDuration(duration)),
-      tween_type_(Tween::LINEAR) {
+      tween_type_(Tween::LINEAR),
+      animation_id_(0),
+      animation_group_id_(0),
+      last_progressed_fraction_(0.0) {
 }
 
 LayerAnimationElement::~LayerAnimationElement() {
 }
 
+void LayerAnimationElement::ProgressToEffectiveStart(
+    LayerAnimationDelegate* delegate) {
+  DCHECK(first_frame_);
+  last_progressed_fraction_ = 0.0;
+  if (!IsThreaded())
+    return;
+
+  OnStart(delegate);
+  RequestEffectiveStart(delegate);
+  first_frame_ = false;
+}
+
 bool LayerAnimationElement::Progress(base::TimeTicks now,
                                      LayerAnimationDelegate* delegate) {
-  DCHECK(start_time_ != base::TimeTicks());
-  base::TimeDelta elapsed = now - start_time_;
+  DCHECK(requested_start_time_ != base::TimeTicks());
   if (first_frame_)
     OnStart(delegate);
+
+  bool need_draw;
   double t = 1.0;
+
+  if (first_frame_ && (now - requested_start_time_ >= duration_)) {
+    // This can be finished immediately, without waiting for an effective start.
+    need_draw = OnProgress(t, delegate);
+    last_progressed_fraction_ = t;
+    return need_draw;
+  }
+
+  if (first_frame_) {
+    RequestEffectiveStart(delegate);
+    first_frame_ = false;
+  }
+
+  if (effective_start_time_ == base::TimeTicks()) {
+    // This hasn't actually started yet.
+    need_draw = false;
+    last_progressed_fraction_ = 0.0;
+    return need_draw;
+  }
+
+  base::TimeDelta elapsed = now - effective_start_time_;
   if ((duration_ > base::TimeDelta()) && (elapsed < duration_))
     t = elapsed.InMillisecondsF() / duration_.InMillisecondsF();
-  bool need_draw = OnProgress(Tween::CalculateValue(tween_type_, t), delegate);
+  need_draw = OnProgress(Tween::CalculateValue(tween_type_, t), delegate);
   first_frame_ = t == 1.0;
+  last_progressed_fraction_ = t;
   return need_draw;
 }
 
 bool LayerAnimationElement::IsFinished(base::TimeTicks time,
                                        base::TimeDelta* total_duration) {
-  base::TimeDelta elapsed = time - start_time_;
-  if (elapsed >= duration_) {
-    *total_duration = duration_;
+  // If an effective start has been requested but the effective start time
+  // hasn't yet been set, the animation is not finished, regardless of the
+  // value of |time|.
+  if (!first_frame_ && (effective_start_time_ == base::TimeTicks()))
+    return false;
+
+  base::TimeDelta queueing_delay;
+  if (!first_frame_)
+    queueing_delay = effective_start_time_ - requested_start_time_;
+
+  base::TimeDelta elapsed = time - requested_start_time_;
+  if (elapsed >= duration_ + queueing_delay) {
+    *total_duration = duration_ + queueing_delay;
     return true;
   }
   return false;
 }
 
 bool LayerAnimationElement::ProgressToEnd(LayerAnimationDelegate* delegate) {
   if (first_frame_)
     OnStart(delegate);
   bool need_draw = OnProgress(1.0, delegate);
+  last_progressed_fraction_ = 1.0;
   first_frame_ = true;
   return need_draw;
 }
 
 void LayerAnimationElement::GetTargetValue(TargetValue* target) const {
   OnGetTarget(target);
 }
 
-void LayerAnimationElement::Abort() {
+bool LayerAnimationElement::IsThreaded() const {
+  return false;
+}
+
+void LayerAnimationElement::Abort(LayerAnimationDelegate* delegate) {
   first_frame_ = true;
-  OnAbort();
+  OnAbort(delegate);
+}
+
+void LayerAnimationElement::RequestEffectiveStart(
+    LayerAnimationDelegate* delegate) {
+  DCHECK(requested_start_time_ != base::TimeTicks());
+  effective_start_time_ = requested_start_time_;
 }
 
 // static
+LayerAnimationElement::AnimatableProperty
+LayerAnimationElement::ToAnimatableProperty(
+    cc::Animation::TargetProperty property) {
+  switch (property) {
+    case cc::Animation::Transform:
+      return TRANSFORM;
+    case cc::Animation::Opacity:
+      return OPACITY;
+    default:
+      NOTREACHED();
+      return AnimatableProperty();
+  }
+}
+
+// static
 base::TimeDelta LayerAnimationElement::GetEffectiveDuration(
     const base::TimeDelta& duration) {
   if (LayerAnimator::disable_animations_for_test())
     return base::TimeDelta();
 
   if (LayerAnimator::slow_animation_mode())
     return duration * LayerAnimator::slow_animation_scale_factor();
 
   return duration;
 }
@@ skipping 17 matching lines @@
 LayerAnimationElement* LayerAnimationElement::CreateBoundsElement(
     const gfx::Rect& bounds,
     base::TimeDelta duration) {
   return new BoundsTransition(bounds, duration);
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateOpacityElement(
     float opacity,
     base::TimeDelta duration) {
-  return new OpacityTransition(opacity, duration);
+  return new ThreadedOpacityTransition(opacity, duration);
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateVisibilityElement(
     bool visibility,
     base::TimeDelta duration) {
   return new VisibilityTransition(visibility, duration);
 }
 
 // static
@@ skipping 18 matching lines @@
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateColorElement(
     SkColor color,
     base::TimeDelta duration) {
   return new ColorTransition(color, duration);
 }
 
 }  // namespace ui