Migrate ui::Transform to gfx::Transform

ui/gfx/interpolated_transform.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/gfx/interpolated_transform.h"
 
 #include <cmath>
 
 #ifndef M_PI
 #define M_PI 3.14159265358979323846
@@ skipping 10 matching lines @@
 {
   float remainder = fabs(fmod(degrees, 90.0f));
   return remainder < EPSILON || 90.0f - remainder < EPSILON;
 }
 
 // Returns false if |degrees| is not a multiple of ninety degrees or if
 // |rotation| is NULL. It does not affect |rotation| in this case. Otherwise
 // *rotation is set to be the appropriate sanitized rotation matrix. That is,
 // the rotation matrix corresponding to |degrees| which has entries that are all
 // either 0, 1 or -1.
-bool MassageRotationIfMultipleOfNinetyDegrees(ui::Transform* rotation,
+bool MassageRotationIfMultipleOfNinetyDegrees(gfx::Transform* rotation,
                                               float degrees)
 {
   if (!IsMultipleOfNinetyDegrees(degrees) || !rotation)
     return false;
 
-  ui::Transform transform;
+  gfx::Transform transform;
   SkMatrix44& m = transform.matrix();
   float degrees_by_ninety = degrees / 90.0f;
 
   int n = static_cast<int>(degrees_by_ninety > 0
       ? floor(degrees_by_ninety + 0.5f)
       : ceil(degrees_by_ninety - 0.5f));
 
   n %= 4;
   if (n < 0)
     n += 4;
@@ skipping 33 matching lines @@
 
 InterpolatedTransform::InterpolatedTransform(float start_time,
                                              float end_time)
     : start_time_(start_time),
       end_time_(end_time),
       reversed_(false) {
 }
 
 InterpolatedTransform::~InterpolatedTransform() {}
 
-ui::Transform InterpolatedTransform::Interpolate(float t) const {
+gfx::Transform InterpolatedTransform::Interpolate(float t) const {
   if (reversed_)
     t = 1.0f - t;
-  ui::Transform result = InterpolateButDoNotCompose(t);
+  gfx::Transform result = InterpolateButDoNotCompose(t);
   if (child_.get()) {
     result.ConcatTransform(child_->Interpolate(t));
   }
   return result;
 }
 
 void InterpolatedTransform::SetChild(InterpolatedTransform* child) {
   child_.reset(child);
 }
 
-bool InterpolatedTransform::FactorTRS(const ui::Transform& transform,
+bool InterpolatedTransform::FactorTRS(const gfx::Transform& transform,
                                       gfx::Point* translation,
                                       float* rotation,
                                       gfx::Point3f* scale) {
   const SkMatrix44& m = transform.matrix();
   float m00 = m.get(0, 0);
   float m01 = m.get(0, 1);
   float m10 = m.get(1, 0);
   float m11 = m.get(1, 1);
 
   // A factorable 2D TRS matrix must be of the form:
@@ skipping 80 matching lines @@
                                            float end_degrees,
                                            float start_time,
                                            float end_time)
     : InterpolatedTransform(start_time, end_time),
       start_degrees_(start_degrees),
       end_degrees_(end_degrees) {
 }
 
 InterpolatedRotation::~InterpolatedRotation() {}
 
-ui::Transform InterpolatedRotation::InterpolateButDoNotCompose(float t) const {
-  ui::Transform result;
+gfx::Transform InterpolatedRotation::InterpolateButDoNotCompose(float t) const {
+  gfx::Transform result;
   float interpolated_degrees = ValueBetween(t, start_degrees_, end_degrees_);
   result.SetRotate(interpolated_degrees);
   if (t == 0.0f || t == 1.0f)
     MassageRotationIfMultipleOfNinetyDegrees(&result, interpolated_degrees);
   return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // InterpolatedAxisAngleRotation
 //
@@ skipping 15 matching lines @@
     float start_time,
     float end_time)
     : InterpolatedTransform(start_time, end_time),
       axis_(axis),
       start_degrees_(start_degrees),
       end_degrees_(end_degrees) {
 }
 
 InterpolatedAxisAngleRotation::~InterpolatedAxisAngleRotation() {}
 
-ui::Transform
+gfx::Transform
 InterpolatedAxisAngleRotation::InterpolateButDoNotCompose(float t) const {
-  ui::Transform result;
+  gfx::Transform result;
   result.SetRotateAbout(axis_, ValueBetween(t, start_degrees_, end_degrees_));
   return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // InterpolatedScale
 //
 
 InterpolatedScale::InterpolatedScale(float start_scale, float end_scale)
     : InterpolatedTransform(),
@@ skipping 19 matching lines @@
                                      const gfx::Point3f& end_scale,
                                      float start_time,
                                      float end_time)
     : InterpolatedTransform(start_time, end_time),
       start_scale_(start_scale),
       end_scale_(end_scale) {
 }
 
 InterpolatedScale::~InterpolatedScale() {}
 
-ui::Transform InterpolatedScale::InterpolateButDoNotCompose(float t) const {
-  ui::Transform result;
+gfx::Transform InterpolatedScale::InterpolateButDoNotCompose(float t) const {
+  gfx::Transform result;
   float scale_x = ValueBetween(t, start_scale_.x(), end_scale_.x());
   float scale_y = ValueBetween(t, start_scale_.y(), end_scale_.y());
   // TODO(vollick) 3d xforms.
   result.SetScale(scale_x, scale_y);
   return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // InterpolatedTranslation
 //
 
 InterpolatedTranslation::InterpolatedTranslation(const gfx::Point& start_pos,
                                                  const gfx::Point& end_pos)
     : InterpolatedTransform(),
       start_pos_(start_pos),
       end_pos_(end_pos) {
 }
 
 InterpolatedTranslation::InterpolatedTranslation(const gfx::Point& start_pos,
                                                  const gfx::Point& end_pos,
                                                  float start_time,
                                                  float end_time)
     : InterpolatedTransform(start_time, end_time),
       start_pos_(start_pos),
       end_pos_(end_pos) {
 }
 
 InterpolatedTranslation::~InterpolatedTranslation() {}
 
-ui::Transform
+gfx::Transform
 InterpolatedTranslation::InterpolateButDoNotCompose(float t) const {
-  ui::Transform result;
+  gfx::Transform result;
   // TODO(vollick) 3d xforms.
   result.SetTranslate(ValueBetween(t, start_pos_.x(), end_pos_.x()),
                       ValueBetween(t, start_pos_.y(), end_pos_.y()));
   return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // InterpolatedConstantTransform
 //
 
 InterpolatedConstantTransform::InterpolatedConstantTransform(
-  const ui::Transform& transform)
+  const gfx::Transform& transform)
     : InterpolatedTransform(),
   transform_(transform) {
 }
 
-ui::Transform
+gfx::Transform
 InterpolatedConstantTransform::InterpolateButDoNotCompose(float t) const {
   return transform_;
 }
 
 InterpolatedConstantTransform::~InterpolatedConstantTransform() {}
 
 ///////////////////////////////////////////////////////////////////////////////
 // InterpolatedTransformAboutPivot
 //
 
 InterpolatedTransformAboutPivot::InterpolatedTransformAboutPivot(
   const gfx::Point& pivot,
   InterpolatedTransform* transform)
     : InterpolatedTransform() {
   Init(pivot, transform);
 }
 
 InterpolatedTransformAboutPivot::InterpolatedTransformAboutPivot(
   const gfx::Point& pivot,
   InterpolatedTransform* transform,
   float start_time,
   float end_time)
     : InterpolatedTransform() {
   Init(pivot, transform);
 }
 
 InterpolatedTransformAboutPivot::~InterpolatedTransformAboutPivot() {}
 
-ui::Transform
+gfx::Transform
 InterpolatedTransformAboutPivot::InterpolateButDoNotCompose(float t) const {
   if (transform_.get()) {
     return transform_->Interpolate(t);
   }
-  return Transform();
+  return gfx::Transform();
 }
 
 void InterpolatedTransformAboutPivot::Init(const gfx::Point& pivot,
                                            InterpolatedTransform* xform) {
-  ui::Transform to_pivot;
-  ui::Transform from_pivot;
+  gfx::Transform to_pivot;
+  gfx::Transform from_pivot;
   to_pivot.SetTranslate(-pivot.x(), -pivot.y());
   from_pivot.SetTranslate(pivot.x(), pivot.y());
 
   scoped_ptr<InterpolatedTransform> pre_transform(
     new InterpolatedConstantTransform(to_pivot));
   scoped_ptr<InterpolatedTransform> post_transform(
     new InterpolatedConstantTransform(from_pivot));
 
   pre_transform->SetChild(xform);
   xform->SetChild(post_transform.release());
   transform_.reset(pre_transform.release());
 }
 
 InterpolatedTRSTransform::InterpolatedTRSTransform(
-    const ui::Transform& start_transform,
-    const ui::Transform& end_transform)
+    const gfx::Transform& start_transform,
+    const gfx::Transform& end_transform)
     : InterpolatedTransform() {
   Init(start_transform, end_transform);
 }
 
 InterpolatedTRSTransform::InterpolatedTRSTransform(
-    const ui::Transform& start_transform,
-    const ui::Transform& end_transform,
+    const gfx::Transform& start_transform,
+    const gfx::Transform& end_transform,
     float start_time,
     float end_time)
     : InterpolatedTransform() {
   Init(start_transform, end_transform);
 }
 
 InterpolatedTRSTransform::~InterpolatedTRSTransform() {}
 
-ui::Transform
+gfx::Transform
 InterpolatedTRSTransform::InterpolateButDoNotCompose(float t) const {
   if (transform_.get()) {
     return transform_->Interpolate(t);
   }
-  return Transform();
+  return gfx::Transform();
 }
 
-void InterpolatedTRSTransform::Init(const Transform& start_transform,
-                                    const Transform& end_transform) {
+void InterpolatedTRSTransform::Init(const gfx::Transform& start_transform,
+                                    const gfx::Transform& end_transform) {
   gfx::Point start_translation, end_translation;
   gfx::Point3f start_scale, end_scale;
   float start_degrees, end_degrees;
   if (FactorTRS(start_transform,
                 &start_translation,
                 &start_degrees,
                 &start_scale) &&
       FactorTRS(end_transform,
                 &end_translation,
                 &end_degrees,
@@ skipping 12 matching lines @@
 
     rotation->SetChild(translation.release());
     scale->SetChild(rotation.release());
     transform_.reset(scale.release());
   } else {
     transform_.reset(new InterpolatedConstantTransform(end_transform));
   }
 }
 
 } // namespace ui