gfx::Transform API clean-up

ui/gfx/interpolated_transform_unittest.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 "base/basictypes.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect.h"
 
@@ skipping 20 matching lines @@
 
 } // namespace
 
 TEST(InterpolatedTransformTest, InterpolatedRotation) {
   ui::InterpolatedRotation interpolated_rotation(0, 100);
   ui::InterpolatedRotation interpolated_rotation_diff_start_end(
       0, 100, 100, 200);
 
   for (int i = 0; i <= 100; ++i) {
     gfx::Transform rotation;
-    rotation.SetRotate(i);
+    rotation.Rotate(i);
     gfx::Transform interpolated = interpolated_rotation.Interpolate(i / 100.0f);
     CheckApproximatelyEqual(rotation, interpolated);
     interpolated = interpolated_rotation_diff_start_end.Interpolate(i + 100);
     CheckApproximatelyEqual(rotation, interpolated);
   }
 }
 
 TEST(InterpolatedTransformTest, InterpolatedScale) {
   ui::InterpolatedScale interpolated_scale(gfx::Point3F(0, 0, 0),
                                            gfx::Point3F(100, 100, 100));
   ui::InterpolatedScale interpolated_scale_diff_start_end(
       gfx::Point3F(0, 0, 0), gfx::Point3F(100, 100, 100), 100, 200);
 
   for (int i = 0; i <= 100; ++i) {
     gfx::Transform scale;
-    scale.SetScale(i, i);
+    scale.Scale(i, i);
     gfx::Transform interpolated = interpolated_scale.Interpolate(i / 100.0f);
     CheckApproximatelyEqual(scale, interpolated);
     interpolated = interpolated_scale_diff_start_end.Interpolate(i + 100);
     CheckApproximatelyEqual(scale, interpolated);
   }
 }
 
 TEST(InterpolatedTransformTest, InterpolatedTranslate) {
   ui::InterpolatedTranslation interpolated_xform(gfx::Point(0, 0),
                                                  gfx::Point(100, 100));
 
   ui::InterpolatedTranslation interpolated_xform_diff_start_end(
       gfx::Point(0, 0), gfx::Point(100, 100), 100, 200);
 
   for (int i = 0; i <= 100; ++i) {
     gfx::Transform xform;
-    xform.SetTranslate(i, i);
+    xform.Translate(i, i);
     gfx::Transform interpolated = interpolated_xform.Interpolate(i / 100.0f);
     CheckApproximatelyEqual(xform, interpolated);
     interpolated = interpolated_xform_diff_start_end.Interpolate(i + 100);
     CheckApproximatelyEqual(xform, interpolated);
   }
 }
 
 TEST(InterpolatedTransformTest, InterpolatedRotationAboutPivot) {
   gfx::Point pivot(100, 100);
   gfx::Point above_pivot(100, 200);
@@ skipping 22 matching lines @@
   CheckApproximatelyEqual(gfx::Transform(), result);
   result = interpolated_xform.Interpolate(1.0f);
   gfx::Point expected_result = pivot;
   result.TransformPoint(pivot);
   EXPECT_EQ(expected_result, pivot);
   expected_result = gfx::Point(100, 300);
   result.TransformPoint(above_pivot);
   EXPECT_EQ(expected_result, above_pivot);
 }
 
-TEST(InterpolatedTransformTest, FactorTRS) {

[danakj, 2012/11/16 19:46:12]

Can you point me at the test that replaces this?

[Ian Vollick, 2012/11/16 21:51:24]

This test did still seem useful, so I've ported it and put it in
transform_unittest.

-  for (int degrees = 0; degrees < 360; ++degrees) {
-    // build a transformation matrix.
-    gfx::Transform transform;
-    transform.SetScale(degrees + 1, 2 * degrees + 1);
-    transform.ConcatRotate(degrees);
-    transform.ConcatTranslate(degrees * 2, -degrees * 3);
-
-    // factor the matrix
-    gfx::Point translation;
-    float rotation;
-    gfx::Point3F scale;
-    bool success = ui::InterpolatedTransform::FactorTRS(transform,
-                                                        &translation,
-                                                        &rotation,
-                                                        &scale);
-    EXPECT_TRUE(success);
-    EXPECT_FLOAT_EQ(translation.x(), degrees * 2);
-    EXPECT_FLOAT_EQ(translation.y(), -degrees * 3);
-    EXPECT_FLOAT_EQ(NormalizeAngle(rotation), degrees);
-    EXPECT_FLOAT_EQ(scale.x(), degrees + 1);
-    EXPECT_FLOAT_EQ(scale.y(), 2 * degrees + 1);
-  }
-}
-
 ui::InterpolatedTransform* GetScreenRotation(int degrees, bool reversed) {
   gfx::Point old_pivot;
   gfx::Point new_pivot;
 
   int width = 1920;
   int height = 180;
 
   switch (degrees) {
     case 90:
       new_pivot = gfx::Point(width, 0);
@@ skipping 98 matching lines @@
   gfx::Transform interpolated = maximize->Interpolate(1.0f);
   SkMatrix44& m = interpolated.matrix();
   // Upper-left 3x3 matrix should all be 0, 1 or -1.
   for (int row = 0; row < 3; ++row) {
     for (int col = 0; col < 3; ++col) {
       float entry = m.get(row, col);
       EXPECT_TRUE(entry == 0 || entry == 1 || entry == -1);
     }
   }
 }
-