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

ash/drag_drop/drag_drop_controller_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 "ash/drag_drop/drag_drop_controller.h"
 
 #include "ash/drag_drop/drag_drop_tracker.h"
 #include "ash/drag_drop/drag_image_view.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
@@ skipping 243 matching lines @@
 
   views::View* contents_view = widget->GetContentsView();
   contents_view->AddChildView(view);
   view->SetBounds(contents_view->width(), 0, 100, 100);
   gfx::Rect contents_view_bounds = contents_view->bounds();
   contents_view_bounds.Union(view->bounds());
   contents_view->SetBoundsRect(contents_view_bounds);
   widget->SetBounds(contents_view_bounds);
 }
 
-void DispatchGesture(ui::EventType gesture_type, gfx::Point location) {
+void DispatchGesture(ui::EventType gesture_type, const gfx::PointF& location) {
   ui::GestureEventDetails event_details(gesture_type);
   event_details.set_oldest_touch_id(1);
   ui::GestureEvent gesture_event(
       location.x(), location.y(), 0, ui::EventTimeForNow(), event_details);
   ui::EventSource* event_source =
       Shell::GetPrimaryRootWindow()->GetHost()->GetEventSource();
   ui::EventSourceTestApi event_source_test(event_source);
   ui::EventDispatchDetails details =
       event_source_test.SendEventToProcessor(&gesture_event);
   CHECK(!details.dispatcher_destroyed);
@@ skipping 280 matching lines @@
 // TODO(win_aura) http://crbug.com/154081
 #if defined(OS_WIN)
 #define MAYBE_ViewRemovedWhileInDragDropTest DISABLED_ViewRemovedWhileInDragDropTest
 #else
 #define MAYBE_ViewRemovedWhileInDragDropTest ViewRemovedWhileInDragDropTest
 #endif
 TEST_F(DragDropControllerTest, MAYBE_ViewRemovedWhileInDragDropTest) {
   scoped_ptr<views::Widget> widget(CreateNewWidget());
   scoped_ptr<DragTestView> drag_view(new DragTestView);
   AddViewToWidgetAndResize(widget.get(), drag_view.get());
-  gfx::Point point = gfx::Rect(drag_view->bounds()).CenterPoint();
   ui::OSExchangeData data;
   data.SetString(base::UTF8ToUTF16("I am being dragged"));
 
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
   generator.MoveMouseToCenterOf(widget->GetNativeView());
   generator.PressLeftButton();
 
   int num_drags_1 = 17;
   for (int i = 0; i < num_drags_1; ++i) {
     // Because we are not doing a blocking drag and drop, the original
@@ skipping 136 matching lines @@
     // OSDragExchangeData object is lost as soon as we return from the drag
     // initiation in DragDropController::StartDragAndDrop(). Hence we set the
     // drag_data_ to a fake drag data object that we created.
     if (i > 0)
       UpdateDragData(&data);
     generator.MoveMouseBy(0, 1);
 
     // We send a unexpected mouse move event. Note that we cannot use
     // EventGenerator since it implicitly turns these into mouse drag events.
     // The DragDropController should simply ignore these events.
-    gfx::Point mouse_move_location = drag_view->bounds().CenterPoint();
+    auto mouse_move_location = gfx::PointF(drag_view->bounds().CenterPoint());
     ui::MouseEvent mouse_move(ui::ET_MOUSE_MOVED, mouse_move_location,
                               mouse_move_location, ui::EventTimeForNow(), 0, 0);
     ui::EventDispatchDetails details = Shell::GetPrimaryRootWindow()->
         GetHost()->event_processor()->OnEventFromSource(&mouse_move);
     ASSERT_FALSE(details.dispatcher_destroyed);
   }
 
   generator.ReleaseLeftButton();
 
   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
@@ skipping 125 matching lines @@
   gfx::Rect widget2_bounds = widget2->GetClientAreaBoundsInScreen();
   widget2->SetBounds(gfx::Rect(widget1_bounds.width(), 0,
       widget2_bounds.width(), widget2_bounds.height()));
 
   ui::OSExchangeData data;
   data.SetString(base::UTF8ToUTF16("I am being dragged"));
 
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      widget1->GetNativeView());
   generator.PressTouch();
-  gfx::Point point = gfx::Rect(drag_view1->bounds()).CenterPoint();
+  auto point = gfx::PointF(gfx::Rect(drag_view1->bounds()).CenterPoint());
   DispatchGesture(ui::ET_GESTURE_LONG_PRESS, point);
   // Because we are not doing a blocking drag and drop, the original
   // OSDragExchangeData object is lost as soon as we return from the drag
   // initiation in DragDropController::StartDragAndDrop(). Hence we set the
   // drag_data_ to a fake drag data object that we created.
   UpdateDragData(&data);
-  gfx::Point gesture_location = point;
+  gfx::PointF gesture_location = point;
   int num_drags = drag_view1->width();
   for (int i = 0; i < num_drags; ++i) {
-    gesture_location.Offset(1, 0);
+    gesture_location.Offset(1.f, 0.f);
     DispatchGesture(ui::ET_GESTURE_SCROLL_UPDATE, gesture_location);
 
     // Execute any scheduled draws to process deferred mouse events.
     RunAllPendingInMessageLoop();
   }
 
   DispatchGesture(ui::ET_GESTURE_SCROLL_END, gesture_location);
 
   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
   EXPECT_EQ(num_drags, drag_drop_controller_->num_drag_updates_);
@@ skipping 20 matching lines @@
 TEST_F(DragDropControllerTest, TouchDragDropCancelsOnLongTap) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableTouchDragDrop);
   scoped_ptr<views::Widget> widget(CreateNewWidget());
   DragTestView* drag_view = new DragTestView;
   AddViewToWidgetAndResize(widget.get(), drag_view);
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      widget->GetNativeView());
 
   generator.PressTouch();
-  gfx::Point point = gfx::Rect(drag_view->bounds()).CenterPoint();
+  auto point = gfx::PointF(gfx::Rect(drag_view->bounds()).CenterPoint());
   DispatchGesture(ui::ET_GESTURE_LONG_PRESS, point);
   DispatchGesture(ui::ET_GESTURE_LONG_TAP, point);
 
   EXPECT_TRUE(drag_drop_controller_->drag_start_received_);
   EXPECT_TRUE(drag_drop_controller_->drag_canceled_);
   EXPECT_EQ(0, drag_drop_controller_->num_drag_updates_);
   EXPECT_FALSE(drag_drop_controller_->drop_received_);
   EXPECT_EQ(base::UTF8ToUTF16("I am being dragged"),
             drag_drop_controller_->drag_string_);
   EXPECT_EQ(0, drag_view->num_drag_enters_);
   EXPECT_EQ(0, drag_view->num_drops_);
   EXPECT_EQ(0, drag_view->num_drag_exits_);
   EXPECT_TRUE(drag_view->drag_done_received_);
 }
 
 TEST_F(DragDropControllerTest, TouchDragDropLongTapGestureIsForwarded) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableTouchDragDrop);
   scoped_ptr<views::Widget> widget(CreateNewWidget());
   DragTestView* drag_view = new DragTestView;
   AddViewToWidgetAndResize(widget.get(), drag_view);
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      widget->GetNativeView());
 
   generator.PressTouch();
-  gfx::Point point = gfx::Rect(drag_view->bounds()).CenterPoint();
+  auto point = gfx::PointF(gfx::Rect(drag_view->bounds()).CenterPoint());
   DispatchGesture(ui::ET_GESTURE_LONG_PRESS, point);
 
   // Since we are not running inside a nested loop, the |drag_source_window_|
   // will get destroyed immediately. Hence we reassign it.
   EXPECT_EQ(NULL, GetDragSourceWindow());
   SetDragSourceWindow(widget->GetNativeView());
   EXPECT_FALSE(drag_view->long_tap_received_);
   DispatchGesture(ui::ET_GESTURE_LONG_TAP, point);
   CompleteCancelAnimation();
   EXPECT_TRUE(drag_view->long_tap_received_);
@@ skipping 42 matching lines @@
         window,
         gfx::Point(5, 5),
         ui::DragDropTypes::DRAG_MOVE,
         ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE);
 
     DragImageWindowObserver observer;
     ASSERT_TRUE(GetDragImageWindow());
     GetDragImageWindow()->AddObserver(&observer);
 
     {
-      ui::MouseEvent e(ui::ET_MOUSE_DRAGGED, gfx::Point(200, 0),
-                       gfx::Point(200, 0), ui::EventTimeForNow(), ui::EF_NONE,
-                       ui::EF_NONE);
+      ui::MouseEvent e(ui::ET_MOUSE_DRAGGED, gfx::PointF(200.f, 0.f),
+                       gfx::PointF(200.f, 0.f), ui::EventTimeForNow(),
+                       ui::EF_NONE, ui::EF_NONE);
       drag_drop_controller_->DragUpdate(window, e);
     }
     {
-      ui::MouseEvent e(ui::ET_MOUSE_DRAGGED, gfx::Point(600, 0),
-                       gfx::Point(600, 0), ui::EventTimeForNow(), ui::EF_NONE,
-                       ui::EF_NONE);
+      ui::MouseEvent e(ui::ET_MOUSE_DRAGGED, gfx::PointF(600.f, 0.f),
+                       gfx::PointF(600.f, 0.f), ui::EventTimeForNow(),
+                       ui::EF_NONE, ui::EF_NONE);
       drag_drop_controller_->DragUpdate(window, e);
     }
 
     drag_drop_controller_->DragCancel();
     CompleteCancelAnimation();
 
     EXPECT_EQ("5,5", observer.window_location_on_destroying().ToString());
   }
 
   {
     scoped_ptr<views::Widget> widget(CreateNewWidget());
     aura::Window* window = widget->GetNativeWindow();
     drag_drop_controller_->StartDragAndDrop(
         data,
         window->GetRootWindow(),
         window,
         gfx::Point(405, 405),
         ui::DragDropTypes::DRAG_MOVE,
         ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE);
     DragImageWindowObserver observer;
     ASSERT_TRUE(GetDragImageWindow());
     GetDragImageWindow()->AddObserver(&observer);
 
     {
-      ui::MouseEvent e(ui::ET_MOUSE_DRAGGED, gfx::Point(600, 0),
-                       gfx::Point(600, 0), ui::EventTimeForNow(), ui::EF_NONE,
-                       ui::EF_NONE);
+      ui::MouseEvent e(ui::ET_MOUSE_DRAGGED, gfx::PointF(600.f, 0.f),
+                       gfx::PointF(600.f, 0.f), ui::EventTimeForNow(),
+                       ui::EF_NONE, ui::EF_NONE);
       drag_drop_controller_->DragUpdate(window, e);
     }
     {
-      ui::MouseEvent e(ui::ET_MOUSE_DRAGGED, gfx::Point(200, 0),
-                       gfx::Point(200, 0), ui::EventTimeForNow(), ui::EF_NONE,
-                       ui::EF_NONE);
+      ui::MouseEvent e(ui::ET_MOUSE_DRAGGED, gfx::PointF(200.f, 0.f),
+                       gfx::PointF(200.f, 0.f), ui::EventTimeForNow(),
+                       ui::EF_NONE, ui::EF_NONE);
       drag_drop_controller_->DragUpdate(window, e);
     }
 
     drag_drop_controller_->DragCancel();
     CompleteCancelAnimation();
 
     EXPECT_EQ("405,405", observer.window_location_on_destroying().ToString());
   }
   for (aura::Window::Windows::iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     aura::client::SetDragDropClient(*iter, NULL);
   }
 }
 
 TEST_F(DragDropControllerTest, TouchDragDropCompletesOnFling) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableTouchDragDrop);
   ui::GestureConfiguration::GetInstance()
       ->set_max_touch_move_in_pixels_for_click(1);
   scoped_ptr<views::Widget> widget(CreateNewWidget());
   DragTestView* drag_view = new DragTestView;
   AddViewToWidgetAndResize(widget.get(), drag_view);
   ui::OSExchangeData data;
   data.SetString(base::UTF8ToUTF16("I am being dragged"));
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      widget->GetNativeView());
 
-  gfx::Point start = gfx::Rect(drag_view->bounds()).CenterPoint();
-  gfx::Point mid = start + gfx::Vector2d(drag_view->bounds().width() / 6, 0);
-  gfx::Point end = start + gfx::Vector2d(drag_view->bounds().width() / 3, 0);
+  auto start = gfx::PointF(gfx::Rect(drag_view->bounds()).CenterPoint());
+  gfx::PointF mid =
+      start + gfx::Vector2dF(drag_view->bounds().width() / 6.f, 0.f);
+  gfx::PointF end =
+      start + gfx::Vector2dF(drag_view->bounds().width() / 3.f, 0.f);
 
   base::TimeDelta timestamp = ui::EventTimeForNow();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, start, 0, timestamp);
   generator.Dispatch(&press);
 
   DispatchGesture(ui::ET_GESTURE_LONG_PRESS, start);
   UpdateDragData(&data);
   timestamp += base::TimeDelta::FromMilliseconds(10);
   ui::TouchEvent move1(ui::ET_TOUCH_MOVED, mid, 0, timestamp);
   generator.Dispatch(&move1);
@@ skipping 13 matching lines @@
             drag_drop_controller_->drag_string_);
   EXPECT_EQ(1, drag_view->num_drag_enters_);
   EXPECT_EQ(2, drag_view->num_drag_updates_);
   EXPECT_EQ(1, drag_view->num_drops_);
   EXPECT_EQ(0, drag_view->num_drag_exits_);
   EXPECT_TRUE(drag_view->drag_done_received_);
 }
 
 }  // namespace test
 }  // namespace ash