ui/base/animation -> ui/gfx/animation

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/animation.h"
 #include "cc/animation/animation_id_provider.h"
-#include "ui/base/animation/tween.h"
 #include "ui/compositor/float_animation_curve_adapter.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/compositor/transform_animation_curve_adapter.h"
+#include "ui/gfx/animation/tween.h"
 #include "ui/gfx/interpolated_transform.h"
 
 namespace ui {
 
 namespace {
 
 // The factor by which duration is scaled up or down when
 // ScopedAnimationDurationScaleMode::duration_scale_mode() is SLOW_DURATION or
 // FAST_DURATION.
 const int kSlowDurationScaleFactor = 4;
@@ skipping 29 matching lines @@
   }
   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_));
+        gfx::Tween::ValueBetween(t, start_, target_));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->transform = target_;
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
@@ skipping 57 matching lines @@
         target_(target) {
   }
   virtual ~BoundsTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetBoundsForAnimation();
   }
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
-    delegate->SetBoundsFromAnimation(Tween::ValueBetween(t, start_, target_));
+    delegate->SetBoundsFromAnimation(
+        gfx::Tween::ValueBetween(t, start_, target_));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->bounds = target_;
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
@@ skipping 19 matching lines @@
         target_(target) {
   }
   virtual ~OpacityTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetOpacityForAnimation();
   }
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
-    delegate->SetOpacityFromAnimation(Tween::ValueBetween(t, start_, target_));
+    delegate->SetOpacityFromAnimation(
+        gfx::Tween::ValueBetween(t, start_, target_));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->opacity = target_;
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
@@ skipping 60 matching lines @@
   }
   virtual ~BrightnessTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetBrightnessForAnimation();
   }
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetBrightnessFromAnimation(
-        Tween::ValueBetween(t, start_, target_));
+        gfx::Tween::ValueBetween(t, start_, target_));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->brightness = target_;
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
@@ skipping 20 matching lines @@
   }
   virtual ~GrayscaleTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetGrayscaleForAnimation();
   }
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetGrayscaleFromAnimation(
-        Tween::ValueBetween(t, start_, target_));
+        gfx::Tween::ValueBetween(t, start_, target_));
     return true;
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->grayscale = target_;
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
@@ skipping 21 matching lines @@
   virtual ~ColorTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetColorForAnimation();
   }
 
   virtual bool OnProgress(double t, LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetColorFromAnimation(
         SkColorSetARGB(
-            Tween::ValueBetween(t,
-                                static_cast<int>(SkColorGetA(start_)),
-                                static_cast<int>(SkColorGetA(target_))),
-            Tween::ValueBetween(t,
-                                static_cast<int>(SkColorGetR(start_)),
-                                static_cast<int>(SkColorGetR(target_))),
-            Tween::ValueBetween(t,
-                                static_cast<int>(SkColorGetG(start_)),
-                                static_cast<int>(SkColorGetG(target_))),
-            Tween::ValueBetween(t,
-                                static_cast<int>(SkColorGetB(start_)),
-                                static_cast<int>(SkColorGetB(target_)))));
+            gfx::Tween::ValueBetween(t,
+                                     static_cast<int>(SkColorGetA(start_)),
+                                     static_cast<int>(SkColorGetA(target_))),
+            gfx::Tween::ValueBetween(t,
+                                     static_cast<int>(SkColorGetR(start_)),
+                                     static_cast<int>(SkColorGetR(target_))),
+            gfx::Tween::ValueBetween(t,
+                                     static_cast<int>(SkColorGetG(start_)),
+                                     static_cast<int>(SkColorGetG(target_))),
+            gfx::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(LayerAnimationDelegate* delegate) OVERRIDE {}
 
  private:
@@ skipping 80 matching lines @@
   virtual ~ThreadedOpacityTransition() {}
 
  protected:
   virtual void OnStart(LayerAnimationDelegate* delegate) OVERRIDE {
     start_ = delegate->GetOpacityForAnimation();
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {
     if (delegate && Started()) {
       ThreadedLayerAnimationElement::OnAbort(delegate);
-      delegate->SetOpacityFromAnimation(Tween::ValueBetween(
-            Tween::CalculateValue(tween_type(), last_progressed_fraction()),
-            start_,
-            target_));
+      delegate->SetOpacityFromAnimation(gfx::Tween::ValueBetween(
+          gfx::Tween::CalculateValue(tween_type(), 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(),
@@ skipping 42 matching lines @@
     float device_scale_factor = delegate->GetDeviceScaleFactor();
     cc_start_ = Layer::ConvertTransformToCCTransform(start_,
                                                      device_scale_factor);
     cc_target_ = Layer::ConvertTransformToCCTransform(target_,
                                                       device_scale_factor);
   }
 
   virtual void OnAbort(LayerAnimationDelegate* delegate) OVERRIDE {
     if (delegate && Started()) {
       ThreadedLayerAnimationElement::OnAbort(delegate);
-      delegate->SetTransformFromAnimation(Tween::ValueBetween(
-          Tween::CalculateValue(tween_type(), last_progressed_fraction()),
+      delegate->SetTransformFromAnimation(gfx::Tween::ValueBetween(
+          gfx::Tween::CalculateValue(tween_type(), last_progressed_fraction()),
           start_,
           target_));
     }
   }
 
   virtual void OnEnd(LayerAnimationDelegate* delegate) OVERRIDE {
     delegate->SetTransformFromAnimation(target_);
   }
 
   virtual scoped_ptr<cc::Animation> CreateCCAnimation() OVERRIDE {
@@ skipping 100 matching lines @@
                               cc::Animation::Transform));
     return animation.Pass();
   }
 
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {
     target->transform = computed_target_transform_;
   }
 
  private:
   gfx::Transform ComputeCurrentTransform() const {
-    gfx::Transform base_current = Tween::ValueBetween(
-        Tween::CalculateValue(tween_type(), last_progressed_fraction()),
+    gfx::Transform base_current = gfx::Tween::ValueBetween(
+        gfx::Tween::CalculateValue(tween_type(), last_progressed_fraction()),
         base_transform_,
         base_target_);
     return ComputeWithBaseTransform(effective_start_, base_current);
   }
 
   gfx::Transform ComputeWithBaseTransform(gfx::Transform start,
                                           gfx::Transform target) const {
     gfx::Transform to_return(gfx::Transform::kSkipInitialization);
     bool success = target.GetInverse(&to_return);
     DCHECK(success) << "Target transform must be invertible.";
@@ skipping 53 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_(gfx::Tween::LINEAR),
       animation_id_(cc::AnimationIdProvider::NextAnimationId()),
       animation_group_id_(0),
       last_progressed_fraction_(0.0) {
 }
 
 LayerAnimationElement::LayerAnimationElement(
     const LayerAnimationElement &element)
     : first_frame_(element.first_frame_),
       properties_(element.properties_),
       duration_(element.duration_),
@@ skipping 29 matching lines @@
       (now < effective_start_time_))  {
     // 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();
-  need_draw = OnProgress(Tween::CalculateValue(tween_type_, t), delegate);
+  need_draw = OnProgress(gfx::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) {
   // 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|.
@@ skipping 144 matching lines @@
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateColorElement(
     SkColor color,
     base::TimeDelta duration) {
   return new ColorTransition(color, duration);
 }
 
 }  // namespace ui