Refactor TransformPoint{,Reverse}.

These methods now take pointers instead of non-const references, this was
previously a violation of the style guide.

R=vollick@chromium.org
BUG=160417

Review URL: https://chromiumcodereview.appspot.com/23724024

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@222864 0039d316-1c4b-4281-b951-d872f2087c98

15 files changed, 69 insertions, 63 deletions

diff --git a/ash/display/display_controller_unittest.cc b/ash/display/display_controller_unittest.cc
index 5024ef9..5ff0d7e 100644
--- a/ash/display/display_controller_unittest.cc
+++ b/ash/display/display_controller_unittest.cc
@@ -891,12 +891,12 @@ TEST_F(DisplayControllerTest, OverscanInsets) {
   UpdateDisplay("400x300*2,600x400/o");
   root_windows = Shell::GetAllRootWindows();
   gfx::Point point;
-  Shell::GetAllRootWindows()[1]->GetRootTransform().TransformPoint(point);
+  Shell::GetAllRootWindows()[1]->GetRootTransform().TransformPoint(&point);
   EXPECT_EQ("15,10", point.ToString());
 
   display_controller->SwapPrimaryDisplay();
   point.SetPoint(0, 0);
-  Shell::GetAllRootWindows()[1]->GetRootTransform().TransformPoint(point);
+  Shell::GetAllRootWindows()[1]->GetRootTransform().TransformPoint(&point);
   EXPECT_EQ("15,10", point.ToString());
 
   Shell::GetInstance()->RemovePreTargetHandler(&event_handler);
diff --git a/ash/magnifier/magnification_controller.cc b/ash/magnifier/magnification_controller.cc
index c8becce..d3119ed 100644
--- a/ash/magnifier/magnification_controller.cc
+++ b/ash/magnifier/magnification_controller.cc
@@ -44,7 +44,7 @@ const int kPanningMergin = 100;
 void MoveCursorTo(aura::RootWindow* root_window,
                   const gfx::Point& root_location) {
   gfx::Point3F host_location_3f(root_location);
-  root_window->GetRootTransform().TransformPoint(host_location_3f);
+  root_window->GetRootTransform().TransformPoint(&host_location_3f);
   root_window->MoveCursorToHostLocation(
       gfx::ToCeiledPoint(host_location_3f.AsPointF()));
 }
diff --git a/ash/rotator/screen_rotation.cc b/ash/rotator/screen_rotation.cc
index 248394a..9352d81 100644
--- a/ash/rotator/screen_rotation.cc
+++ b/ash/rotator/screen_rotation.cc
@@ -73,9 +73,9 @@ void ScreenRotation::InitTransform(ui::Layer* layer) {
   }
 
   // Convert points to world space.
-  current_transform.TransformPoint(old_pivot);
-  current_transform.TransformPoint(new_pivot);
-  current_transform.TransformPoint(new_origin_);
+  current_transform.TransformPoint(&old_pivot);
+  current_transform.TransformPoint(&new_pivot);
+  current_transform.TransformPoint(&new_origin_);
 
   scoped_ptr<ui::InterpolatedTransform> rotation(
       new ui::InterpolatedTransformAboutPivot(
diff --git a/ash/wm/window_manager_unittest.cc b/ash/wm/window_manager_unittest.cc
index 9351cc76..221311df6 100644
--- a/ash/wm/window_manager_unittest.cc
+++ b/ash/wm/window_manager_unittest.cc
@@ -596,7 +596,7 @@ TEST_F(WindowManagerTest, MAYBE_TransformActivate) {
   w1->Show();
 
   gfx::Point miss_point(5, 5);
-  transform.TransformPoint(miss_point);
+  transform.TransformPoint(&miss_point);
   ui::MouseEvent mouseev1(ui::ET_MOUSE_PRESSED,
                           miss_point,
                           miss_point,
@@ -610,7 +610,7 @@ TEST_F(WindowManagerTest, MAYBE_TransformActivate) {
   root_window->AsRootWindowHostDelegate()->OnHostMouseEvent(&mouseup);
 
   gfx::Point hit_point(5, 15);
-  transform.TransformPoint(hit_point);
+  transform.TransformPoint(&hit_point);
   ui::MouseEvent mouseev2(ui::ET_MOUSE_PRESSED,
                           hit_point,
                           hit_point,
diff --git a/ui/aura/root_window.cc b/ui/aura/root_window.cc
index 0c7253b..df8b672 100644
--- a/ui/aura/root_window.cc
+++ b/ui/aura/root_window.cc
@@ -445,13 +445,13 @@ void RootWindow::ConvertPointFromNativeScreen(gfx::Point* point) const {
 
 void RootWindow::ConvertPointToHost(gfx::Point* point) const {
   gfx::Point3F point_3f(*point);
-  GetRootTransform().TransformPoint(point_3f);
+  GetRootTransform().TransformPoint(&point_3f);
   *point = gfx::ToFlooredPoint(point_3f.AsPointF());
 }
 
 void RootWindow::ConvertPointFromHost(gfx::Point* point) const {
   gfx::Point3F point_3f(*point);
-  GetInverseRootTransform().TransformPoint(point_3f);
+  GetInverseRootTransform().TransformPoint(&point_3f);
   *point = gfx::ToFlooredPoint(point_3f.AsPointF());
 }
 
diff --git a/ui/base/events/event.cc b/ui/base/events/event.cc
index 0281310..a95565a 100644
--- a/ui/base/events/event.cc
+++ b/ui/base/events/event.cc
@@ -284,7 +284,7 @@ void LocatedEvent::UpdateForRootTransform(
     const gfx::Transform& reversed_root_transform) {
   // Transform has to be done at root level.
   gfx::Point3F p(location_);
-  reversed_root_transform.TransformPoint(p);
+  reversed_root_transform.TransformPoint(&p);
   root_location_ = location_ = gfx::ToFlooredPoint(p.AsPointF());
 }
 
diff --git a/ui/compositor/debug_utils.cc b/ui/compositor/debug_utils.cc
index b9ee5ce..e1f62f9 100644
--- a/ui/compositor/debug_utils.cc
+++ b/ui/compositor/debug_utils.cc
@@ -29,7 +29,7 @@ void PrintLayerHierarchyImp(const Layer* layer,
                             std::wostringstream* out) {
   std::string indent_str(indent, ' ');
 
-  layer->transform().TransformPointReverse(mouse_location);
+  layer->transform().TransformPointReverse(&mouse_location);
   bool mouse_inside_layer_bounds = layer->bounds().Contains(mouse_location);
   mouse_location.Offset(-layer->bounds().x(), -layer->bounds().y());
 
diff --git a/ui/compositor/layer.cc b/ui/compositor/layer.cc
index c464ed7..357a9f9 100644
--- a/ui/compositor/layer.cc
+++ b/ui/compositor/layer.cc
@@ -714,7 +714,7 @@ bool Layer::ConvertPointForAncestor(const Layer* ancestor,
   gfx::Transform transform;
   bool result = GetTargetTransformRelativeTo(ancestor, &transform);
   gfx::Point3F p(*point);
-  transform.TransformPoint(p);
+  transform.TransformPoint(&p);
   *point = gfx::ToFlooredPoint(p.AsPointF());
   return result;
 }
@@ -724,7 +724,7 @@ bool Layer::ConvertPointFromAncestor(const Layer* ancestor,
   gfx::Transform transform;
   bool result = GetTargetTransformRelativeTo(ancestor, &transform);
   gfx::Point3F p(*point);
-  transform.TransformPointReverse(p);
+  transform.TransformPointReverse(&p);
   *point = gfx::ToFlooredPoint(p.AsPointF());
   return result;
 }
diff --git a/ui/gfx/interpolated_transform_unittest.cc b/ui/gfx/interpolated_transform_unittest.cc
index dd31b8b..acea465 100644
--- a/ui/gfx/interpolated_transform_unittest.cc
+++ b/ui/gfx/interpolated_transform_unittest.cc
@@ -90,10 +90,10 @@ TEST(InterpolatedTransformTest, InterpolatedRotationAboutPivot) {
   CheckApproximatelyEqual(gfx::Transform(), result);
   result = interpolated_xform.Interpolate(1.0f);
   gfx::Point expected_result = pivot;
-  result.TransformPoint(pivot);
+  result.TransformPoint(&pivot);
   EXPECT_EQ(expected_result, pivot);
   expected_result = gfx::Point(0, 100);
-  result.TransformPoint(above_pivot);
+  result.TransformPoint(&above_pivot);
   EXPECT_EQ(expected_result, above_pivot);
 }
 
@@ -107,10 +107,10 @@ TEST(InterpolatedTransformTest, InterpolatedScaleAboutPivot) {
   CheckApproximatelyEqual(gfx::Transform(), result);
   result = interpolated_xform.Interpolate(1.0f);
   gfx::Point expected_result = pivot;
-  result.TransformPoint(pivot);
+  result.TransformPoint(&pivot);
   EXPECT_EQ(expected_result, pivot);
   expected_result = gfx::Point(100, 300);
-  result.TransformPoint(above_pivot);
+  result.TransformPoint(&above_pivot);
   EXPECT_EQ(expected_result, above_pivot);
 }
 
diff --git a/ui/gfx/transform.cc b/ui/gfx/transform.cc
index 25cd6e6..9022ece 100644
--- a/ui/gfx/transform.cc
+++ b/ui/gfx/transform.cc
@@ -369,15 +369,19 @@ Vector2dF Transform::To2dTranslation() const {
                         SkMScalarToFloat(matrix_.get(1, 3)));
 }
 
-void Transform::TransformPoint(Point& point) const {
+void Transform::TransformPoint(Point* point) const {
+  DCHECK(point);
   TransformPointInternal(matrix_, point);
 }
 
-void Transform::TransformPoint(Point3F& point) const {
+void Transform::TransformPoint(Point3F* point) const {
+  DCHECK(point);
   TransformPointInternal(matrix_, point);
 }
 
-bool Transform::TransformPointReverse(Point& point) const {
+bool Transform::TransformPointReverse(Point* point) const {
+  DCHECK(point);
+
   // TODO(sad): Try to avoid trying to invert the matrix.
   SkMatrix44 inverse(SkMatrix44::kUninitialized_Constructor);
   if (!matrix_.invert(&inverse))
@@ -387,7 +391,9 @@ bool Transform::TransformPointReverse(Point& point) const {
   return true;
 }
 
-bool Transform::TransformPointReverse(Point3F& point) const {
+bool Transform::TransformPointReverse(Point3F* point) const {
+  DCHECK(point);
+
   // TODO(sad): Try to avoid trying to invert the matrix.
   SkMatrix44 inverse(SkMatrix44::kUninitialized_Constructor);
   if (!matrix_.invert(&inverse))
@@ -437,33 +443,33 @@ bool Transform::Blend(const Transform& from, SkMScalar progress) {
 }
 
 void Transform::TransformPointInternal(const SkMatrix44& xform,
-                                       Point3F& point) const {
+                                       Point3F* point) const {
   if (xform.isIdentity())
     return;
 
-  SkMScalar p[4] = {SkFloatToMScalar(point.x()), SkFloatToMScalar(point.y()),
-                    SkFloatToMScalar(point.z()), 1};
+  SkMScalar p[4] = {SkFloatToMScalar(point->x()), SkFloatToMScalar(point->y()),
+                    SkFloatToMScalar(point->z()), 1};
 
   xform.mapMScalars(p);
 
   if (p[3] != 1 && abs(p[3]) > 0) {
-    point.SetPoint(p[0] / p[3], p[1] / p[3], p[2]/ p[3]);
+    point->SetPoint(p[0] / p[3], p[1] / p[3], p[2]/ p[3]);
   } else {
-    point.SetPoint(p[0], p[1], p[2]);
+    point->SetPoint(p[0], p[1], p[2]);
   }
 }
 
 void Transform::TransformPointInternal(const SkMatrix44& xform,
-                                       Point& point) const {
+                                       Point* point) const {
   if (xform.isIdentity())
     return;
 
-  SkMScalar p[4] = {SkFloatToMScalar(point.x()), SkFloatToMScalar(point.y()), 0,
-                    1};
+  SkMScalar p[4] = {SkFloatToMScalar(point->x()), SkFloatToMScalar(point->y()),
+                    0, 1};
 
   xform.mapMScalars(p);
 
-  point.SetPoint(ToRoundedInt(p[0]), ToRoundedInt(p[1]));
+  point->SetPoint(ToRoundedInt(p[0]), ToRoundedInt(p[1]));
 }
 
 std::string Transform::ToString() const {
diff --git a/ui/gfx/transform.h b/ui/gfx/transform.h
index f9819f3..0c68656 100644
--- a/ui/gfx/transform.h
+++ b/ui/gfx/transform.h
@@ -182,19 +182,19 @@ class UI_EXPORT Transform {
 
   // Applies the transformation on the point. Returns true if the point is
   // transformed successfully.
-  void TransformPoint(Point3F& point) const;
+  void TransformPoint(Point3F* point) const;
 
   // Applies the transformation on the point. Returns true if the point is
   // transformed successfully. Rounds the result to the nearest point.
-  void TransformPoint(Point& point) const;
+  void TransformPoint(Point* point) const;
 
   // Applies the reverse transformation on the point. Returns true if the
   // transformation can be inverted.
-  bool TransformPointReverse(Point3F& point) const;
+  bool TransformPointReverse(Point3F* point) const;
 
   // Applies the reverse transformation on the point. Returns true if the
   // transformation can be inverted. Rounds the result to the nearest point.
-  bool TransformPointReverse(Point& point) const;
+  bool TransformPointReverse(Point* point) const;
 
   // Applies transformation on the rectangle. Returns true if the transformed
   // rectangle was axis aligned. If it returns false, rect will be the
@@ -237,10 +237,10 @@ class UI_EXPORT Transform {
 
  private:
   void TransformPointInternal(const SkMatrix44& xform,
-                              Point& point) const;
+                              Point* point) const;
 
   void TransformPointInternal(const SkMatrix44& xform,
-                              Point3F& point) const;
+                              Point3F* point) const;
 
   SkMatrix44 matrix_;
 
diff --git a/ui/gfx/transform_unittest.cc b/ui/gfx/transform_unittest.cc
index 95ffa1f..4394af6789 100644
--- a/ui/gfx/transform_unittest.cc
+++ b/ui/gfx/transform_unittest.cc
@@ -207,7 +207,7 @@ TEST(XFormTest, ConcatTranslate) {
     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));
@@ -236,7 +236,7 @@ TEST(XFormTest, ConcatScale) {
     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));
     }
@@ -267,7 +267,7 @@ TEST(XFormTest, ConcatRotate) {
     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));
     }
@@ -312,11 +312,11 @@ TEST(XFormTest, SetTranslate) {
         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));
       }
     }
@@ -359,11 +359,11 @@ TEST(XFormTest, SetScale) {
         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));
         }
       }
@@ -399,9 +399,9 @@ TEST(XFormTest, SetRotate) {
     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));
     }
   }
@@ -434,7 +434,7 @@ TEST(XFormTest, ConcatTranslate2D) {
     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());
@@ -464,7 +464,7 @@ TEST(XFormTest, ConcatScale2D) {
     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());
@@ -496,7 +496,7 @@ TEST(XFormTest, ConcatRotate2D) {
     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());
@@ -545,12 +545,12 @@ TEST(XFormTest, SetTranslate2D) {
           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());
         }
@@ -600,12 +600,12 @@ TEST(XFormTest, SetScale2D) {
           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());
           }
@@ -643,10 +643,10 @@ TEST(XFormTest, SetRotate2D) {
       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);
       }
@@ -2293,10 +2293,10 @@ static bool EmpiricallyPreserves2dAxisAlignment(const Transform& transform) {
                  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()),
diff --git a/ui/gfx/transform_util_unittest.cc b/ui/gfx/transform_util_unittest.cc
index 01ddbe5..94195c2 100644
--- a/ui/gfx/transform_util_unittest.cc
+++ b/ui/gfx/transform_util_unittest.cc
@@ -21,7 +21,7 @@ TEST(TransformUtilTest, GetScaleTransform) {
     for (int sign_y = -1; sign_y <= 1; ++sign_y) {
       Point test(kAnchor.x() + sign_x * kOffset,
                  kAnchor.y() + sign_y * kOffset);
-      scale.TransformPoint(test);
+      scale.TransformPoint(&test);
 
       EXPECT_EQ(Point(kAnchor.x() + sign_x * kOffset * kScale,
                       kAnchor.y() + sign_y * kOffset * kScale),
diff --git a/ui/views/view.cc b/ui/views/view.cc
index 81f0207..14238ca 100644
--- a/ui/views/view.cc
+++ b/ui/views/view.cc
@@ -1999,7 +1999,7 @@ bool View::ConvertPointForAncestor(const View* ancestor,
   // TODO(sad): Have some way of caching the transformation results.
   bool result = GetTransformRelativeTo(ancestor, &trans);
   gfx::Point3F p(*point);
-  trans.TransformPoint(p);
+  trans.TransformPoint(&p);
   *point = gfx::ToFlooredPoint(p.AsPointF());
   return result;
 }
@@ -2009,7 +2009,7 @@ bool View::ConvertPointFromAncestor(const View* ancestor,
   gfx::Transform trans;
   bool result = GetTransformRelativeTo(ancestor, &trans);
   gfx::Point3F p(*point);
-  trans.TransformPointReverse(p);
+  trans.TransformPointReverse(&p);
   *point = gfx::ToFlooredPoint(p.AsPointF());
   return result;
 }
diff --git a/webkit/renderer/compositor_bindings/web_layer_impl_fixed_bounds_unittest.cc b/webkit/renderer/compositor_bindings/web_layer_impl_fixed_bounds_unittest.cc
index 65f1b52..02a2ac3 100644
--- a/webkit/renderer/compositor_bindings/web_layer_impl_fixed_bounds_unittest.cc
+++ b/webkit/renderer/compositor_bindings/web_layer_impl_fixed_bounds_unittest.cc
@@ -33,7 +33,7 @@ TEST(WebLayerImplFixedBoundsTest, IdentityBounds) {
 gfx::Point3F TransformPoint(const gfx::Transform& transform,
                             const gfx::Point3F& point) {
   gfx::Point3F result = point;
-  transform.TransformPoint(result);
+  transform.TransformPoint(&result);
   return result;
 }