Refactor TransformPoint{,Reverse}.

ui/gfx/transform_unittest.cc

 // Copyright (c) 2011 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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "ui/gfx/transform.h"
 
 #include <cmath>
@@ skipping 189 matching lines @@
   };
 
   Transform xform;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     const TestCase& value = test_cases[i];
     Transform translation;
     translation.Translate(value.tx, value.ty);
     xform = translation * xform;
     Point3F p1(value.x1, value.y1, 0);
     Point3F p2(value.x2, value.y2, 0);
-    xform.TransformPoint(p1);
+    xform.TransformPoint(&p1);
     if (value.tx == value.tx &&
         value.ty == value.ty) {
       EXPECT_TRUE(PointsAreNearlyEqual(p1, p2));
     }
   }
 }
 
 TEST(XFormTest, ConcatScale) {
   static const struct TestCase {
     int before;
     float scale;
     int after;
   } test_cases[] = {
     { 1, 10.0f, 10 },
     { 1, .1f, 1 },
     { 1, 100.0f, 100 },
     { 1, -1.0f, -100 },
     { 1, std::numeric_limits<float>::quiet_NaN(), 1 }
   };
 
   Transform xform;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     const TestCase& value = test_cases[i];
     Transform scale;
     scale.Scale(value.scale, value.scale);
     xform = scale * xform;
     Point3F p1(value.before, value.before, 0);
     Point3F p2(value.after, value.after, 0);
-    xform.TransformPoint(p1);
+    xform.TransformPoint(&p1);
     if (value.scale == value.scale) {
       EXPECT_TRUE(PointsAreNearlyEqual(p1, p2));
     }
   }
 }
 
 TEST(XFormTest, ConcatRotate) {
   static const struct TestCase {
     int x1;
     int y1;
@@ skipping 10 matching lines @@
   };
 
   Transform xform;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     const TestCase& value = test_cases[i];
     Transform rotation;
     rotation.Rotate(value.degrees);
     xform = rotation * xform;
     Point3F p1(value.x1, value.y1, 0);
     Point3F p2(value.x2, value.y2, 0);
-    xform.TransformPoint(p1);
+    xform.TransformPoint(&p1);
     if (value.degrees == value.degrees) {
       EXPECT_TRUE(PointsAreNearlyEqual(p1, p2));
     }
   }
 }
 
 TEST(XFormTest, SetTranslate) {
   static const struct TestCase {
     int x1; int y1;
     float tx; float ty;
@@ skipping 24 matching lines @@
         p2.SetPoint(0, value.y2, 0);
         xform.Translate(0.0, value.ty);
         break;
       case 2:
         p1.SetPoint(value.x1, value.y1, 0);
         p2.SetPoint(value.x2, value.y2, 0);
         xform.Translate(value.tx, value.ty);
         break;
       }
       p0 = p1;
-      xform.TransformPoint(p1);
+      xform.TransformPoint(&p1);
       if (value.tx == value.tx &&
           value.ty == value.ty) {
         EXPECT_TRUE(PointsAreNearlyEqual(p1, p2));
-        xform.TransformPointReverse(p1);
+        xform.TransformPointReverse(&p1);
         EXPECT_TRUE(PointsAreNearlyEqual(p1, p0));
       }
     }
   }
 }
 
 TEST(XFormTest, SetScale) {
   static const struct TestCase {
     int before;
     float s;
@@ skipping 22 matching lines @@
         p2.SetPoint(0, value.after, 0);
         xform.Scale(1.0, value.s);
         break;
       case 2:
         p1.SetPoint(value.before, value.before, 0);
         p2.SetPoint(value.after, value.after, 0);
         xform.Scale(value.s, value.s);
         break;
       }
       p0 = p1;
-      xform.TransformPoint(p1);
+      xform.TransformPoint(&p1);
       if (value.s == value.s) {
         EXPECT_TRUE(PointsAreNearlyEqual(p1, p2));
         if (value.s != 0.0f) {
-          xform.TransformPointReverse(p1);
+          xform.TransformPointReverse(&p1);
           EXPECT_TRUE(PointsAreNearlyEqual(p1, p0));
         }
       }
     }
   }
 }
 
 TEST(XFormTest, SetRotate) {
   static const struct SetRotateCase {
     int x;
@@ skipping 15 matching lines @@
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(set_rotate_cases); ++i) {
     const SetRotateCase& value = set_rotate_cases[i];
     Point3F p0;
     Point3F p1(value.x, value.y, 0);
     Point3F p2(value.xprime, value.yprime, 0);
     p0 = p1;
     Transform xform;
     xform.Rotate(value.degree);
     // just want to make sure that we don't crash in the case of NaN.
     if (value.degree == value.degree) {
-      xform.TransformPoint(p1);
+      xform.TransformPoint(&p1);
       EXPECT_TRUE(PointsAreNearlyEqual(p1, p2));
-      xform.TransformPointReverse(p1);
+      xform.TransformPointReverse(&p1);
       EXPECT_TRUE(PointsAreNearlyEqual(p1, p0));
     }
   }
 }
 
 // 2D tests
 TEST(XFormTest, ConcatTranslate2D) {
   static const struct TestCase {
     int x1;
     int y1;
@@ skipping 12 matching lines @@
   };
 
   Transform xform;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     const TestCase& value = test_cases[i];
     Transform translation;
     translation.Translate(value.tx, value.ty);
     xform = translation * xform;
     Point p1(value.x1, value.y1);
     Point p2(value.x2, value.y2);
-    xform.TransformPoint(p1);
+    xform.TransformPoint(&p1);
     if (value.tx == value.tx &&
         value.ty == value.ty) {
       EXPECT_EQ(p1.x(), p2.x());
       EXPECT_EQ(p1.y(), p2.y());
     }
   }
 }
 
 TEST(XFormTest, ConcatScale2D) {
   static const struct TestCase {
     int before;
     float scale;
     int after;
   } test_cases[] = {
     { 1, 10.0f, 10},
     { 1, .1f, 1},
     { 1, 100.0f, 100},
     { 1, -1.0f, -100},
     { 1, std::numeric_limits<float>::quiet_NaN(), 1}
   };
 
   Transform xform;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     const TestCase& value = test_cases[i];
     Transform scale;
     scale.Scale(value.scale, value.scale);
     xform = scale * xform;
     Point p1(value.before, value.before);
     Point p2(value.after, value.after);
-    xform.TransformPoint(p1);
+    xform.TransformPoint(&p1);
     if (value.scale == value.scale) {
       EXPECT_EQ(p1.x(), p2.x());
       EXPECT_EQ(p1.y(), p2.y());
     }
   }
 }
 
 TEST(XFormTest, ConcatRotate2D) {
   static const struct TestCase {
     int x1;
@@ skipping 11 matching lines @@
   };
 
   Transform xform;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     const TestCase& value = test_cases[i];
     Transform rotation;
     rotation.Rotate(value.degrees);
     xform = rotation * xform;
     Point p1(value.x1, value.y1);
     Point p2(value.x2, value.y2);
-    xform.TransformPoint(p1);
+    xform.TransformPoint(&p1);
     if (value.degrees == value.degrees) {
       EXPECT_EQ(p1.x(), p2.x());
       EXPECT_EQ(p1.y(), p2.y());
     }
   }
 }
 
 TEST(XFormTest, SetTranslate2D) {
   static const struct TestCase {
     int x1; int y1;
@@ skipping 28 matching lines @@
           xform.Translate(0.0, value.ty + j * epsilon);
           break;
         case 2:
           p1.SetPoint(value.x1, value.y1);
           p2.SetPoint(value.x2, value.y2);
           xform.Translate(value.tx + j * epsilon,
                           value.ty + j * epsilon);
           break;
         }
         p0 = p1;
-        xform.TransformPoint(p1);
+        xform.TransformPoint(&p1);
         if (value.tx == value.tx &&
             value.ty == value.ty) {
           EXPECT_EQ(p1.x(), p2.x());
           EXPECT_EQ(p1.y(), p2.y());
-          xform.TransformPointReverse(p1);
+          xform.TransformPointReverse(&p1);
           EXPECT_EQ(p1.x(), p0.x());
           EXPECT_EQ(p1.y(), p0.y());
         }
       }
     }
   }
 }
 
 TEST(XFormTest, SetScale2D) {
   static const struct TestCase {
@@ skipping 29 matching lines @@
         case 2:
           p1.SetPoint(value.before,
                       value.before);
           p2.SetPoint(value.after,
                       value.after);
           xform.Scale(value.s + j * epsilon,
                       value.s + j * epsilon);
           break;
         }
         p0 = p1;
-        xform.TransformPoint(p1);
+        xform.TransformPoint(&p1);
         if (value.s == value.s) {
           EXPECT_EQ(p1.x(), p2.x());
           EXPECT_EQ(p1.y(), p2.y());
           if (value.s != 0.0f) {
-            xform.TransformPointReverse(p1);
+            xform.TransformPointReverse(&p1);
             EXPECT_EQ(p1.x(), p0.x());
             EXPECT_EQ(p1.y(), p0.y());
           }
         }
       }
     }
   }
 }
 
 TEST(XFormTest, SetRotate2D) {
@@ skipping 17 matching lines @@
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(set_rotate_cases); ++i) {
     const SetRotateCase& value = set_rotate_cases[i];
     for (int j = 1; j >= -1; --j) {
       float epsilon = 0.1f;
       Point pt(value.x, value.y);
       Transform xform;
       // should be invariant to small floating point errors.
       xform.Rotate(value.degree + j * epsilon);
       // just want to make sure that we don't crash in the case of NaN.
       if (value.degree == value.degree) {
-        xform.TransformPoint(pt);
+        xform.TransformPoint(&pt);
         EXPECT_EQ(value.xprime, pt.x());
         EXPECT_EQ(value.yprime, pt.y());
-        xform.TransformPointReverse(pt);
+        xform.TransformPointReverse(&pt);
         EXPECT_EQ(pt.x(), value.x);
         EXPECT_EQ(pt.y(), value.y);
       }
     }
   }
 }
 
 TEST(XFormTest, BlendTranslate) {
   Transform from;
   for (int i = -5; i < 15; ++i) {
@@ skipping 1626 matching lines @@
   Point3F p2(10.0f, 5.0f, 0.0f);
   Point3F p3(10.0f, 20.0f, 0.0f);
   Point3F p4(5.0f, 20.0f, 0.0f);
 
   QuadF test_quad(PointF(p1.x(), p1.y()),
                  PointF(p2.x(), p2.y()),
                  PointF(p3.x(), p3.y()),
                  PointF(p4.x(), p4.y()));
   EXPECT_TRUE(test_quad.IsRectilinear());
 
-  transform.TransformPoint(p1);
-  transform.TransformPoint(p2);
-  transform.TransformPoint(p3);
-  transform.TransformPoint(p4);
+  transform.TransformPoint(&p1);
+  transform.TransformPoint(&p2);
+  transform.TransformPoint(&p3);
+  transform.TransformPoint(&p4);
 
   QuadF transformedQuad(PointF(p1.x(), p1.y()),
                         PointF(p2.x(), p2.y()),
                         PointF(p3.x(), p3.y()),
                         PointF(p4.x(), p4.y()));
   return transformedQuad.IsRectilinear();
 }
 
 TEST(XFormTest, Preserves2dAxisAlignment) {
   static const struct TestCase {
@@ skipping 190 matching lines @@
   transform.Translate(translation.x(), translation.y() + 1);
   EXPECT_NE(translation.ToString(), transform.To2dTranslation().ToString());
   transform.MakeIdentity();
   transform.Translate(translation.x(), translation.y());
   EXPECT_EQ(translation.ToString(), transform.To2dTranslation().ToString());
 }
 
 }  // namespace
 
 }  // namespace gfx