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

ui/events/event_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 "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
@@ skipping 40 matching lines @@
   KeyEvent keyev3(event);
   EXPECT_EQ(10, keyev3.GetCharacter());
 
   event.InitKeyEvent(ET_KEY_PRESSED, VKEY_RETURN, EF_NONE);
   KeyEvent keyev4(event);
   EXPECT_EQ(13, keyev4.GetCharacter());
 #endif
 }
 
 TEST(EventTest, ClickCount) {
-  const gfx::Point origin(0, 0);
+  const gfx::PointF origin;
   MouseEvent mouseev(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(), 0, 0);
   for (int i = 1; i <=3 ; ++i) {
     mouseev.SetClickCount(i);
     EXPECT_EQ(i, mouseev.GetClickCount());
   }
 }
 
 TEST(EventTest, RepeatedClick) {
-  const gfx::Point origin(0, 0);
+  const gfx::PointF origin;
   MouseEvent mouse_ev1(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(), 0,
                        0);
   MouseEvent mouse_ev2(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(), 0,
                        0);
   LocatedEventTestApi test_ev1(&mouse_ev1);
   LocatedEventTestApi test_ev2(&mouse_ev2);
 
   base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
   base::TimeDelta soon = start + base::TimeDelta::FromMilliseconds(1);
   base::TimeDelta later = start + base::TimeDelta::FromMilliseconds(1000);
 
   // Same event.
-  test_ev1.set_location(gfx::Point(0, 0));
-  test_ev2.set_location(gfx::Point(1, 0));
+  test_ev1.set_location(gfx::PointF());
+  test_ev2.set_location(gfx::PointF(1.f, 0.f));
   test_ev1.set_time_stamp(start);
   test_ev2.set_time_stamp(start);
   EXPECT_FALSE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev2));
   MouseEvent mouse_ev3(mouse_ev1);
   EXPECT_FALSE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev3));
 
   // Close point.
-  test_ev1.set_location(gfx::Point(0, 0));
-  test_ev2.set_location(gfx::Point(1, 0));
+  test_ev1.set_location(gfx::PointF());
+  test_ev2.set_location(gfx::PointF(1.f, 0.f));
   test_ev1.set_time_stamp(start);
   test_ev2.set_time_stamp(soon);
   EXPECT_TRUE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev2));
 
   // Too far.
-  test_ev1.set_location(gfx::Point(0, 0));
-  test_ev2.set_location(gfx::Point(10, 0));
+  test_ev1.set_location(gfx::PointF());
+  test_ev2.set_location(gfx::PointF(10.f, 0.f));
   test_ev1.set_time_stamp(start);
   test_ev2.set_time_stamp(soon);
   EXPECT_FALSE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev2));
 
   // Too long a time between clicks.
-  test_ev1.set_location(gfx::Point(0, 0));
-  test_ev2.set_location(gfx::Point(0, 0));
+  test_ev1.set_location(gfx::PointF());
+  test_ev2.set_location(gfx::PointF());
   test_ev1.set_time_stamp(start);
   test_ev2.set_time_stamp(later);
   EXPECT_FALSE(MouseEvent::IsRepeatedClickEvent(mouse_ev1, mouse_ev2));
 }
 
 // Tests that an event only increases the click count and gets marked as a
 // double click if a release event was seen for the previous click. This
 // prevents the same PRESSED event from being processed twice:
 // http://crbug.com/389162
 TEST(EventTest, DoubleClickRequiresRelease) {
-  const gfx::Point origin1(0, 0);
-  const gfx::Point origin2(100, 0);
+  const gfx::PointF origin1;
+  const gfx::PointF origin2(100.f, 0.f);
   scoped_ptr<MouseEvent> ev;
   base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
   base::TimeDelta soon = start + base::TimeDelta::FromMilliseconds(1);
 
   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin1, origin1, EventTimeForNow(),
                           0, 0));
   ev->set_time_stamp(start);
   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin1, origin1, EventTimeForNow(),
                           0, 0));
@@ skipping 15 matching lines @@
   ev.reset(new MouseEvent(ET_MOUSE_RELEASED, origin2, origin2,
                           EventTimeForNow(), 0, 0));
   ev->set_time_stamp(soon);
   EXPECT_EQ(2, MouseEvent::GetRepeatCount(*ev));
   MouseEvent::ResetLastClickForTest();
 }
 
 // Tests that clicking right and then left clicking does not generate a double
 // click.
 TEST(EventTest, SingleClickRightLeft) {
-  const gfx::Point origin(0, 0);
+  const gfx::PointF origin;
   scoped_ptr<MouseEvent> ev;
   base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
   base::TimeDelta soon = start + base::TimeDelta::FromMilliseconds(1);
 
   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(),
                           ui::EF_RIGHT_MOUSE_BUTTON,
                           ui::EF_RIGHT_MOUSE_BUTTON));
   ev->set_time_stamp(start);
   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
   ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(),
@@ skipping 374 matching lines @@
   }
 #endif
 }
 #endif  // USE_X11 || OS_WIN
 
 TEST(EventTest, TouchEventRadiusDefaultsToOtherAxis) {
   const base::TimeDelta time = base::TimeDelta::FromMilliseconds(0);
   const float non_zero_length1 = 30;
   const float non_zero_length2 = 46;
 
-  TouchEvent event1(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
+  TouchEvent event1(ui::ET_TOUCH_PRESSED, gfx::PointF(), 0, 0, time,
                     non_zero_length1, 0, 0, 0);
   EXPECT_EQ(non_zero_length1, event1.pointer_details().radius_x());
   EXPECT_EQ(non_zero_length1, event1.pointer_details().radius_y());
 
-  TouchEvent event2(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
-                    0, non_zero_length2, 0, 0);
+  TouchEvent event2(ui::ET_TOUCH_PRESSED, gfx::PointF(), 0, 0, time, 0,
+                    non_zero_length2, 0, 0);
   EXPECT_EQ(non_zero_length2, event2.pointer_details().radius_x());
   EXPECT_EQ(non_zero_length2, event2.pointer_details().radius_y());
 }
 
 TEST(EventTest, TouchEventRotationAngleFixing) {
   const base::TimeDelta time = base::TimeDelta::FromMilliseconds(0);
   const float radius_x = 20;
   const float radius_y = 10;
 
   {
     const float angle_in_range = 0;
-    TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
-                      radius_x, radius_y, angle_in_range, 0);
+    TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::PointF(), 0, 0, time, radius_x,
+                     radius_y, angle_in_range, 0);
     EXPECT_FLOAT_EQ(angle_in_range, event.rotation_angle());
   }
 
   {
     const float angle_in_range = 179.9f;
-    TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
-                    radius_x, radius_y, angle_in_range, 0);
+    TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::PointF(), 0, 0, time, radius_x,
+                     radius_y, angle_in_range, 0);
     EXPECT_FLOAT_EQ(angle_in_range, event.rotation_angle());
   }
 
   {
     const float angle_negative = -0.1f;
-    TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
-                    radius_x, radius_y, angle_negative, 0);
+    TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::PointF(), 0, 0, time, radius_x,
+                     radius_y, angle_negative, 0);
     EXPECT_FLOAT_EQ(180 - 0.1f, event.rotation_angle());
   }
 
   {
     const float angle_negative = -200;
-    TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
-                    radius_x, radius_y, angle_negative, 0);
+    TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::PointF(), 0, 0, time, radius_x,
+                     radius_y, angle_negative, 0);
     EXPECT_FLOAT_EQ(360 - 200, event.rotation_angle());
   }
 
   {
     const float angle_too_big = 180;
-    TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
-                    radius_x, radius_y, angle_too_big, 0);
+    TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::PointF(), 0, 0, time, radius_x,
+                     radius_y, angle_too_big, 0);
     EXPECT_FLOAT_EQ(0, event.rotation_angle());
   }
 
   {
     const float angle_too_big = 400;
-    TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
-                    radius_x, radius_y, angle_too_big, 0);
+    TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::PointF(), 0, 0, time, radius_x,
+                     radius_y, angle_too_big, 0);
     EXPECT_FLOAT_EQ(400 - 360, event.rotation_angle());
   }
 }
 
 TEST(EventTest, PointerEventDetailsTouch) {
-  ui::TouchEvent touch_event_plain(ET_TOUCH_PRESSED, gfx::Point(0, 0), 0,
+  ui::TouchEvent touch_event_plain(ET_TOUCH_PRESSED, gfx::PointF(), 0,
                                    ui::EventTimeForNow());
 
   EXPECT_EQ(EventPointerType::POINTER_TYPE_TOUCH,
             touch_event_plain.pointer_details().pointer_type());
   EXPECT_EQ(0.0f, touch_event_plain.pointer_details().radius_x());
   EXPECT_EQ(0.0f, touch_event_plain.pointer_details().radius_y());
   EXPECT_EQ(0.0f, touch_event_plain.pointer_details().force());
   EXPECT_EQ(0.0f, touch_event_plain.pointer_details().tilt_x());
   EXPECT_EQ(0.0f, touch_event_plain.pointer_details().tilt_y());
 
-  ui::TouchEvent touch_event_with_details(ET_TOUCH_PRESSED, gfx::Point(0, 0), 0,
-                                          0, ui::EventTimeForNow(), 10.0f, 5.0f,
+  ui::TouchEvent touch_event_with_details(ET_TOUCH_PRESSED, gfx::PointF(), 0, 0,
+                                          ui::EventTimeForNow(), 10.0f, 5.0f,
                                           0.0f, 15.0f);
 
   EXPECT_EQ(EventPointerType::POINTER_TYPE_TOUCH,
             touch_event_with_details.pointer_details().pointer_type());
   EXPECT_EQ(10.0f, touch_event_with_details.pointer_details().radius_x());
   EXPECT_EQ(5.0f, touch_event_with_details.pointer_details().radius_y());
   EXPECT_EQ(15.0f, touch_event_with_details.pointer_details().force());
   EXPECT_EQ(0.0f, touch_event_with_details.pointer_details().tilt_x());
   EXPECT_EQ(0.0f, touch_event_with_details.pointer_details().tilt_y());
 
   ui::TouchEvent touch_event_copy(touch_event_with_details);
   EXPECT_EQ(EventPointerType::POINTER_TYPE_TOUCH,
             touch_event_copy.pointer_details().pointer_type());
   EXPECT_EQ(10.0f, touch_event_copy.pointer_details().radius_x());
   EXPECT_EQ(5.0f, touch_event_copy.pointer_details().radius_y());
   EXPECT_EQ(15.0f, touch_event_copy.pointer_details().force());
   EXPECT_EQ(0.0f, touch_event_copy.pointer_details().tilt_x());
   EXPECT_EQ(0.0f, touch_event_copy.pointer_details().tilt_y());
 }
 
 TEST(EventTest, PointerEventDetailsMouse) {
-  ui::MouseEvent mouse_event(ET_MOUSE_PRESSED, gfx::PointF(0, 0),
-                             gfx::PointF(0, 0), ui::EventTimeForNow(), 0, 0);
+  ui::MouseEvent mouse_event(ET_MOUSE_PRESSED, gfx::PointF(), gfx::PointF(),
+                             ui::EventTimeForNow(), 0, 0);
 
   EXPECT_EQ(EventPointerType::POINTER_TYPE_MOUSE,
             mouse_event.pointer_details().pointer_type());
   EXPECT_EQ(0.0f, mouse_event.pointer_details().radius_x());
   EXPECT_EQ(0.0f, mouse_event.pointer_details().radius_y());
   EXPECT_EQ(0.0f, mouse_event.pointer_details().force());
   EXPECT_EQ(0.0f, mouse_event.pointer_details().tilt_x());
   EXPECT_EQ(0.0f, mouse_event.pointer_details().tilt_y());
 
   ui::MouseEvent mouse_event_copy(mouse_event);
   EXPECT_EQ(EventPointerType::POINTER_TYPE_MOUSE,
             mouse_event_copy.pointer_details().pointer_type());
   EXPECT_EQ(0.0f, mouse_event_copy.pointer_details().radius_x());
   EXPECT_EQ(0.0f, mouse_event_copy.pointer_details().radius_y());
   EXPECT_EQ(0.0f, mouse_event_copy.pointer_details().force());
   EXPECT_EQ(0.0f, mouse_event_copy.pointer_details().tilt_x());
   EXPECT_EQ(0.0f, mouse_event_copy.pointer_details().tilt_y());
 }
 
 TEST(EventTest, PointerEventDetailsStylus) {
-  ui::MouseEvent stylus_event(ET_MOUSE_PRESSED, gfx::PointF(0, 0),
-                              gfx::PointF(0, 0), ui::EventTimeForNow(), 0, 0);
+  ui::MouseEvent stylus_event(ET_MOUSE_PRESSED, gfx::PointF(), gfx::PointF(),
+                              ui::EventTimeForNow(), 0, 0);
   ui::PointerDetails pointer_details(EventPointerType::POINTER_TYPE_PEN,
       /* radius_x */ 0.0f,
       /* radius_y */ 0.0f,
       /* force */ 21.0f,
       /* tilt_x */ 45.0f,
       /* tilt_y */ -45.0f);
 
   stylus_event.set_pointer_details(pointer_details);
   EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
             stylus_event.pointer_details().pointer_type());
   EXPECT_EQ(21.0f, stylus_event.pointer_details().force());
   EXPECT_EQ(45.0f, stylus_event.pointer_details().tilt_x());
   EXPECT_EQ(-45.0f, stylus_event.pointer_details().tilt_y());
   EXPECT_EQ(0.0f, stylus_event.pointer_details().radius_x());
   EXPECT_EQ(0.0f, stylus_event.pointer_details().radius_y());
 
   ui::MouseEvent stylus_event_copy(stylus_event);
   EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
             stylus_event_copy.pointer_details().pointer_type());
   EXPECT_EQ(21.0f, stylus_event_copy.pointer_details().force());
   EXPECT_EQ(45.0f, stylus_event_copy.pointer_details().tilt_x());
   EXPECT_EQ(-45.0f, stylus_event_copy.pointer_details().tilt_y());
   EXPECT_EQ(0.0f, stylus_event_copy.pointer_details().radius_x());
   EXPECT_EQ(0.0f, stylus_event_copy.pointer_details().radius_y());
 }
 
 }  // namespace ui