Migrate ui::Transform to gfx::Transform

ui/compositor/layer_animation_element.h

 // 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.
 
 #ifndef UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_
 #define UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_
 
 #include <set>
 
 #include "base/time.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/animation/tween.h"
 #include "ui/compositor/compositor_export.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 
 namespace ui {
 
 class InterpolatedTransform;
 class LayerAnimationDelegate;
-class Transform;
 
 // LayerAnimationElements represent one segment of an animation between two
 // keyframes. They know how to update a LayerAnimationDelegate given a value
 // between 0 and 1 (0 for initial, and 1 for final).
 class COMPOSITOR_EXPORT LayerAnimationElement {
  public:
   enum AnimatableProperty {
     TRANSFORM = 0,
     BOUNDS,
     OPACITY,
     VISIBILITY,
     BRIGHTNESS,
     GRAYSCALE,
     COLOR,
   };
 
   struct COMPOSITOR_EXPORT TargetValue {
     TargetValue();
     // Initializes the target value to match the delegate. NULL may be supplied.
     explicit TargetValue(const LayerAnimationDelegate* delegate);
 
     gfx::Rect bounds;
-    Transform transform;
+    gfx::Transform transform;
     float opacity;
     bool visibility;
     float brightness;
     float grayscale;
     SkColor color;
   };
 
   typedef std::set<AnimatableProperty> AnimatableProperties;
 
   LayerAnimationElement(const AnimatableProperties& properties,
                         base::TimeDelta duration);
   virtual ~LayerAnimationElement();
 
   // Creates an element that transitions to the given transform. The caller owns
   // the return value.
   static LayerAnimationElement* CreateTransformElement(
-      const Transform& transform,
+      const gfx::Transform& transform,
       base::TimeDelta duration);
 
   // Creates an element that transitions to another in a way determined by an
   // interpolated transform. The element accepts ownership of the interpolated
   // transform. NB: at every step, the interpolated transform clobbers the
   // existing transform. That is, it does not interpolate between the existing
   // transform and the last value the interpolated transform will assume. It is
   // therefore important that the value of the interpolated at time 0 matches
   // the current transform.
   static LayerAnimationElement* CreateInterpolatedTransformElement(
@@ skipping 82 matching lines @@
   const AnimatableProperties properties_;
   const base::TimeDelta duration_;
   Tween::Type tween_type_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerAnimationElement);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_ANIMATION_ELEMENT_H_