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

ui/events/gestures/motion_event_aura_unittest.cc

 // Copyright 2014 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 <cmath>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/gestures/motion_event_aura.h"
 #include "ui/events/test/motion_event_test_utils.h"
 
 namespace {
 
 ui::TouchEvent TouchWithType(ui::EventType type, int id) {
-  return ui::TouchEvent(
-      type, gfx::PointF(0, 0), id, base::TimeDelta::FromMilliseconds(0));
+  return ui::TouchEvent(type, gfx::Point(0, 0), id,
+                        base::TimeDelta::FromMilliseconds(0));
 }
 
 ui::TouchEvent TouchWithPosition(ui::EventType type,
                                  int id,
                                  float x,
                                  float y,
                                  float raw_x,
                                  float raw_y) {
-  ui::TouchEvent event(type,
-                       gfx::PointF(x, y),
-                       0,
-                       id,
-                       base::TimeDelta::FromMilliseconds(0),
-                       0,
-                       0,
-                       0,
-                       0);
-  event.set_root_location(gfx::PointF(raw_x, raw_y));
+  ui::TouchEvent event(type, gfx::Point(), 0, id,
+                       base::TimeDelta::FromMilliseconds(0), 0, 0, 0, 0);
+  event.set_location_f(gfx::PointF(x, y));
+  event.set_root_location_f(gfx::PointF(raw_x, raw_y));
   return event;
 }
 
 ui::TouchEvent TouchWithTapParams(ui::EventType type,
                                  int id,
                                  float radius_x,
                                  float radius_y,
                                  float rotation_angle,
                                  float pressure) {
-  ui::TouchEvent event(type,
-                       gfx::PointF(1, 1),
-                       0,
-                       id,
-                       base::TimeDelta::FromMilliseconds(0),
-                       radius_x,
-                       radius_y,
-                       rotation_angle,
-                       pressure);
-  event.set_root_location(gfx::PointF(1, 1));
+  ui::TouchEvent event(type, gfx::Point(1, 1), 0, id,
+                       base::TimeDelta::FromMilliseconds(0), radius_x, radius_y,
+                       rotation_angle, pressure);
   return event;
 }
 
 ui::TouchEvent TouchWithTime(ui::EventType type, int id, int ms) {
-  return ui::TouchEvent(
-      type, gfx::PointF(0, 0), id, base::TimeDelta::FromMilliseconds(ms));
+  return ui::TouchEvent(type, gfx::Point(0, 0), id,
+                        base::TimeDelta::FromMilliseconds(ms));
 }
 
 base::TimeTicks MsToTicks(int ms) {
   return base::TimeTicks() + base::TimeDelta::FromMilliseconds(ms);
 }
 
 }  // namespace
 
 namespace ui {
 
@@ skipping 280 matching lines @@
   EXPECT_TRUE(event.OnTouch(press0));
   EXPECT_EQ(MsToTicks(times_in_ms[0]), event.GetEventTime());
 
   TouchEvent press1 = TouchWithTime(
       ui::ET_TOUCH_PRESSED, ids[1], times_in_ms[1]);
   EXPECT_TRUE(event.OnTouch(press1));
   EXPECT_EQ(MsToTicks(times_in_ms[1]), event.GetEventTime());
 
   TouchEvent move0 = TouchWithTime(
       ui::ET_TOUCH_MOVED, ids[0], times_in_ms[2]);
-  move0.set_location(gfx::PointF(12, 21));
+  move0.set_location(gfx::Point(12, 21));
   EXPECT_TRUE(event.OnTouch(move0));
   EXPECT_EQ(MsToTicks(times_in_ms[2]), event.GetEventTime());
 
   // Test cloning of timestamp information.
   scoped_ptr<MotionEvent> clone = event.Clone();
   EXPECT_EQ(MsToTicks(times_in_ms[2]), clone->GetEventTime());
 }
 
 TEST(MotionEventAuraTest, CachedAction) {
   // Test that the cached action and cached action index are correct.
@@ skipping 10 matching lines @@
   EXPECT_EQ(MotionEvent::ACTION_POINTER_DOWN, event.GetAction());
   EXPECT_EQ(1, event.GetActionIndex());
   EXPECT_EQ(2U, event.GetPointerCount());
 
   // Test cloning of CachedAction information.
   scoped_ptr<MotionEvent> clone = event.Clone();
   EXPECT_EQ(MotionEvent::ACTION_POINTER_DOWN, clone->GetAction());
   EXPECT_EQ(1, clone->GetActionIndex());
 
   TouchEvent move0 = TouchWithType(ET_TOUCH_MOVED, ids[0]);
-  move0.set_location(gfx::PointF(10, 12));
+  move0.set_location(gfx::Point(10, 12));
   EXPECT_TRUE(event.OnTouch(move0));
   EXPECT_EQ(MotionEvent::ACTION_MOVE, event.GetAction());
   EXPECT_EQ(2U, event.GetPointerCount());
 
   TouchEvent release0 = TouchWithType(ET_TOUCH_RELEASED, ids[0]);
   EXPECT_TRUE(event.OnTouch(release0));
   EXPECT_EQ(MotionEvent::ACTION_POINTER_UP, event.GetAction());
   EXPECT_EQ(2U, event.GetPointerCount());
   event.CleanupRemovedTouchPoints(release0);
   EXPECT_EQ(1U, event.GetPointerCount());
@@ skipping 125 matching lines @@
     int id = i + kIdOffset;
     TouchEvent release = TouchWithType(ET_TOUCH_RELEASED, id);
     if (i < MotionEvent::MAX_TOUCH_POINT_COUNT)
       EXPECT_TRUE(event.OnTouch(release));
     else
       EXPECT_FALSE(event.OnTouch(release));
   }
 }
 
 }  // namespace ui