Migrate ui::Transform to gfx::Transform

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 "ui/base/animation/tween.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animator.h"
@@ skipping 20 matching lines @@
   virtual void OnGetTarget(TargetValue* target) const OVERRIDE {}
   virtual void OnAbort() OVERRIDE {}
 
   DISALLOW_COPY_AND_ASSIGN(Pause);
 };
 
 // TransformTransition ---------------------------------------------------------
 
 class TransformTransition : public LayerAnimationElement {
  public:
-  TransformTransition(const Transform& target, base::TimeDelta duration)
+    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 {}
 
  private:
   static AnimatableProperties GetProperties() {
     AnimatableProperties properties;
     properties.insert(LayerAnimationElement::TRANSFORM);
     return properties;
   }
 
-  Transform start_;
-  const Transform target_;
+  gfx::Transform start_;
+  const gfx::Transform target_;
 
   DISALLOW_COPY_AND_ASSIGN(TransformTransition);
 };
 
 // InterpolatedTransformTransition ---------------------------------------------
 
 class InterpolatedTransformTransition : public LayerAnimationElement {
  public:
   InterpolatedTransformTransition(InterpolatedTransform* interpolated_transform,
                                   base::TimeDelta duration)
@@ skipping 292 matching lines @@
     : opacity(0.0f),
       visibility(false),
       brightness(0.0f),
       grayscale(0.0f),
       color(SK_ColorBLACK) {
 }
 
 LayerAnimationElement::TargetValue::TargetValue(
     const LayerAnimationDelegate* delegate)
     : bounds(delegate ? delegate->GetBoundsForAnimation() : gfx::Rect()),
-      transform(delegate ? delegate->GetTransformForAnimation() : Transform()),
+      transform(delegate ? delegate->GetTransformForAnimation() : gfx::Transform()),
       opacity(delegate ? delegate->GetOpacityForAnimation() : 0.0f),
       visibility(delegate ? delegate->GetVisibilityForAnimation() : false),
       brightness(delegate ? delegate->GetBrightnessForAnimation() : 0.0f),
       grayscale(delegate ? delegate->GetGrayscaleForAnimation() : 0.0f),
       color(delegate ? delegate->GetColorForAnimation() : 0.0f) {
 }
 
 // LayerAnimationElement -------------------------------------------------------
 
 LayerAnimationElement::LayerAnimationElement(
@@ skipping 33 matching lines @@
     return base::TimeDelta();
 
   if (LayerAnimator::slow_animation_mode())
     return duration * LayerAnimator::slow_animation_scale_factor();
 
   return duration;
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateTransformElement(
-    const Transform& transform,
+    const gfx::Transform& transform,
     base::TimeDelta duration) {
   return new TransformTransition(transform, duration);
 }
 
 // static
 LayerAnimationElement*
 LayerAnimationElement::CreateInterpolatedTransformElement(
     InterpolatedTransform* interpolated_transform,
     base::TimeDelta duration) {
   return new InterpolatedTransformTransition(interpolated_transform, duration);
@@ skipping 42 matching lines @@
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateColorElement(
     SkColor color,
     base::TimeDelta duration) {
   return new ColorTransition(color, duration);
 }
 
 }  // namespace ui