gfx: Make conversions from gfx::Point to PointF explicit.

ui/gfx/transform_util.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/transform_util.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 
@@ skipping 213 matching lines @@
   matrix.preConcat(translation);
   matrix.preConcat(rotation);
   matrix.preConcat(skew);
   matrix.preConcat(scale);
 
   Transform to_return;
   to_return.matrix() = matrix;
   return to_return;
 }
 
-bool CheckViewportPointMapsWithinOnePixel(const Point& point,
+bool CheckViewportPointMapsWithinOnePixel(const PointF& point,
                                           const Transform& transform) {
   Point3F point_original(point);
   Point3F point_transformed(point);
 
   // Can't use TransformRect here since it would give us the axis-aligned
   // bounding rect of the 4 points in the initial rectable which is not what we
   // want.
   transform.TransformPoint(&point_transformed);
 
   if ((point_transformed - point_original).Length() > 1.f) {
     // The changed distance should not be more than 1 pixel.
     return false;
   }
   return true;
 }
 
 bool CheckTransformsMapsIntViewportWithinOnePixel(const Rect& viewport,
                                                   const Transform& original,
                                                   const Transform& snapped) {
 
   Transform original_inv(Transform::kSkipInitialization);
   bool invertible = true;
   invertible &= original.GetInverse(&original_inv);
   DCHECK(invertible) << "Non-invertible transform, cannot snap.";
 
   Transform combined = snapped * original_inv;
 
-  return CheckViewportPointMapsWithinOnePixel(viewport.origin(), combined) &&
-         CheckViewportPointMapsWithinOnePixel(viewport.top_right(), combined) &&
-         CheckViewportPointMapsWithinOnePixel(viewport.bottom_left(),
+  return CheckViewportPointMapsWithinOnePixel(gfx::PointF(viewport.origin()),
                                               combined) &&
-         CheckViewportPointMapsWithinOnePixel(viewport.bottom_right(),
-                                              combined);
+         CheckViewportPointMapsWithinOnePixel(gfx::PointF(viewport.top_right()),
+                                              combined) &&
+         CheckViewportPointMapsWithinOnePixel(
+             gfx::PointF(viewport.bottom_left()), combined) &&
+         CheckViewportPointMapsWithinOnePixel(
+             gfx::PointF(viewport.bottom_right()), combined);
 }
 
 }  // namespace
 
 Transform GetScaleTransform(const Point& anchor, float scale) {
   Transform transform;
   transform.Translate(anchor.x() * (1 - scale),
                       anchor.y() * (1 - scale));
   transform.Scale(scale, scale);
   return transform;
@@ skipping 230 matching lines @@
       perspective[1],
       perspective[2],
       perspective[3],
       quaternion[0],
       quaternion[1],
       quaternion[2],
       quaternion[3]);
 }
 
 }  // namespace gfx