Explicitly convert Point to PointF for event code

ui/events/test/event_generator.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.
 
 #include "ui/events/test/event_generator.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 156 matching lines @@
   auto location = gfx::PointF(GetLocationInCurrentRoot());
   ui::MouseEvent mouseev(ui::ET_MOUSEWHEEL, location, location,
                          ui::EventTimeForNow(), flags_, 0);
   ui::MouseWheelEvent wheelev(mouseev, delta_x, delta_y);
   Dispatch(&wheelev);
 }
 
 void EventGenerator::SendMouseExit() {
   gfx::Point exit_location(current_location_);
   delegate()->ConvertPointToTarget(current_target_, &exit_location);
-  ui::MouseEvent mouseev(ui::ET_MOUSE_EXITED, exit_location, exit_location,
-                         ui::EventTimeForNow(), flags_, 0);
+  ui::MouseEvent mouseev(ui::ET_MOUSE_EXITED, gfx::PointF(exit_location),
+                         gfx::PointF(exit_location), ui::EventTimeForNow(),
+                         flags_, 0);
   Dispatch(&mouseev);
 }
 
 void EventGenerator::MoveMouseToWithNative(const gfx::Point& point_in_host,
                                            const gfx::Point& point_for_native) {
 #if defined(USE_X11)
   ui::ScopedXI2Event xevent;
   xevent.InitMotionEvent(point_in_host, point_for_native, flags_);
   static_cast<XEvent*>(xevent)->xmotion.time = Now().InMicroseconds();
   ui::MouseEvent mouseev(xevent);
 #elif defined(USE_OZONE)
   // Ozone uses the location in native event as a system location.
   // Create a fake event with the point in host, which will be passed
   // to the non native event, then update the native event with the native
   // (root) one.
-  scoped_ptr<ui::MouseEvent> native_event(new ui::MouseEvent(
-      ui::ET_MOUSE_MOVED, point_in_host, point_in_host, Now(), flags_, 0));
+  scoped_ptr<ui::MouseEvent> native_event(
+      new ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::PointF(point_in_host),
+                         gfx::PointF(point_in_host), Now(), flags_, 0));
   ui::MouseEvent mouseev(native_event.get());
   native_event->set_location(point_for_native);
 #else
-  ui::MouseEvent mouseev(ui::ET_MOUSE_MOVED, point_in_host, point_for_native,
-                         Now(), flags_, 0);
+  ui::MouseEvent mouseev(ui::ET_MOUSE_MOVED, gfx::PointF(point_in_host),
+                         gfx::PointF(point_for_native), Now(), flags_, 0);
   LOG(FATAL)
       << "Generating a native motion event is not supported on this platform";
 #endif
   Dispatch(&mouseev);
 
   current_location_ = point_in_host;
   delegate()->ConvertPointFromHost(current_target_, &current_location_);
 }
 
 void EventGenerator::MoveMouseToInHost(const gfx::Point& point_in_host) {
   const ui::EventType event_type = (flags_ & ui::EF_LEFT_MOUSE_BUTTON) ?
       ui::ET_MOUSE_DRAGGED : ui::ET_MOUSE_MOVED;
-  ui::MouseEvent mouseev(event_type, point_in_host, point_in_host,
-                         ui::EventTimeForNow(), flags_, 0);
+  ui::MouseEvent mouseev(event_type, gfx::PointF(point_in_host),
+                         gfx::PointF(point_in_host), ui::EventTimeForNow(),
+                         flags_, 0);
   Dispatch(&mouseev);
 
   current_location_ = point_in_host;
   delegate()->ConvertPointFromHost(current_target_, &current_location_);
 }
 
 void EventGenerator::MoveMouseTo(const gfx::Point& point_in_screen,
                                  int count) {
   DCHECK_GT(count, 0);
   const ui::EventType event_type = (flags_ & ui::EF_LEFT_MOUSE_BUTTON) ?
       ui::ET_MOUSE_DRAGGED : ui::ET_MOUSE_MOVED;
 
   gfx::Vector2dF diff(point_in_screen - current_location_);
   for (float i = 1; i <= count; i++) {
     gfx::Vector2dF step(diff);
     step.Scale(i / count);
     gfx::Point move_point = current_location_ + gfx::ToRoundedVector2d(step);
     if (!grab_)
       UpdateCurrentDispatcher(move_point);
     delegate()->ConvertPointToTarget(current_target_, &move_point);
-    ui::MouseEvent mouseev(event_type, move_point, move_point,
-                           ui::EventTimeForNow(), flags_, 0);
+    ui::MouseEvent mouseev(event_type, gfx::PointF(move_point),
+                           gfx::PointF(move_point), ui::EventTimeForNow(),
+                           flags_, 0);
     Dispatch(&mouseev);
   }
   current_location_ = point_in_screen;
 }
 
 void EventGenerator::MoveMouseRelativeTo(const EventTarget* window,
                                          const gfx::Point& point_in_parent) {
   gfx::Point point(point_in_parent);
   delegate()->ConvertPointFromTarget(window, &point);
   MoveMouseTo(point);
@@ skipping 57 matching lines @@
 }
 
 void EventGenerator::GestureEdgeSwipe() {
   ui::GestureEvent gesture(
       0, 0, 0, Now(), ui::GestureEventDetails(ui::ET_GESTURE_WIN8_EDGE_SWIPE));
   Dispatch(&gesture);
 }
 
 void EventGenerator::GestureTapAt(const gfx::Point& location) {
   const int kTouchId = 2;
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
-                       location,
-                       kTouchId,
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(location), kTouchId,
                        Now());
   Dispatch(&press);
 
   ui::TouchEvent release(
-      ui::ET_TOUCH_RELEASED, location, kTouchId,
+      ui::ET_TOUCH_RELEASED, gfx::PointF(location), kTouchId,
       press.time_stamp() + base::TimeDelta::FromMilliseconds(50));
   Dispatch(&release);
 }
 
 void EventGenerator::GestureTapDownAndUp(const gfx::Point& location) {
   const int kTouchId = 3;
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
-                       location,
-                       kTouchId,
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(location), kTouchId,
                        Now());
   Dispatch(&press);
 
   ui::TouchEvent release(
-      ui::ET_TOUCH_RELEASED, location, kTouchId,
+      ui::ET_TOUCH_RELEASED, gfx::PointF(location), kTouchId,
       press.time_stamp() + base::TimeDelta::FromMilliseconds(1000));
   Dispatch(&release);
 }
 
 base::TimeDelta EventGenerator::CalculateScrollDurationForFlingVelocity(
     const gfx::Point& start,
     const gfx::Point& end,
     float velocity,
     int steps) {
   const float kGestureDistance = (start - end).Length();
   const float kFlingStepDelay = (kGestureDistance / velocity) / steps * 1000000;
   return base::TimeDelta::FromMicroseconds(kFlingStepDelay);
 }
 
 void EventGenerator::GestureScrollSequence(const gfx::Point& start,
                                            const gfx::Point& end,
                                            const base::TimeDelta& step_delay,
                                            int steps) {
   GestureScrollSequenceWithCallback(start, end, step_delay, steps,
                                     base::Bind(&DummyCallback));
 }
 
 void EventGenerator::GestureScrollSequenceWithCallback(
     const gfx::Point& start,
     const gfx::Point& end,
     const base::TimeDelta& step_delay,
     int steps,
     const ScrollStepCallback& callback) {
   const int kTouchId = 5;
+  gfx::PointF location(start);
   base::TimeDelta timestamp = Now();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, start, kTouchId, timestamp);
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, location, kTouchId, timestamp);
   Dispatch(&press);
 
   callback.Run(ui::ET_GESTURE_SCROLL_BEGIN, gfx::Vector2dF());
 
   float dx = static_cast<float>(end.x() - start.x()) / steps;
   float dy = static_cast<float>(end.y() - start.y()) / steps;
-  gfx::PointF location = start;
   for (int i = 0; i < steps; ++i) {
     location.Offset(dx, dy);
     timestamp += step_delay;
     ui::TouchEvent move(ui::ET_TOUCH_MOVED, location, kTouchId, timestamp);
     Dispatch(&move);
     callback.Run(ui::ET_GESTURE_SCROLL_UPDATE, gfx::Vector2dF(dx, dy));
   }
 
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, end, kTouchId, timestamp);
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(end), kTouchId,
+                         timestamp);
   Dispatch(&release);
 
   callback.Run(ui::ET_GESTURE_SCROLL_END, gfx::Vector2dF());
 }
 
 void EventGenerator::GestureMultiFingerScroll(int count,
                                               const gfx::Point start[],
                                               int event_separation_time_ms,
                                               int steps,
                                               int move_x,
@@ skipping 34 matching lines @@
   }
 
   int last_id = 0;
   for (int step = 0; step < steps; ++step) {
     base::TimeDelta move_time = press_time_first +
         base::TimeDelta::FromMilliseconds(event_separation_time_ms * step);
 
     while (last_id < count &&
            !pressed[last_id] &&
            move_time >= press_time[last_id]) {
-      ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
-                           points[last_id],
-                           last_id,
-                           press_time[last_id]);
+      ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(points[last_id]),
+                           last_id, press_time[last_id]);
       Dispatch(&press);
       pressed[last_id] = true;
       last_id++;
     }
 
     for (int i = 0; i < count; ++i) {
       points[i].Offset(delta_x, delta_y);
       if (i >= last_id)
         continue;
-      ui::TouchEvent move(ui::ET_TOUCH_MOVED, points[i], i, move_time);
+      ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(points[i]), i,
+                          move_time);
       Dispatch(&move);
     }
   }
 
   base::TimeDelta release_time = press_time_first +
       base::TimeDelta::FromMilliseconds(event_separation_time_ms * steps);
   for (int i = 0; i < last_id; ++i) {
-    ui::TouchEvent release(
-        ui::ET_TOUCH_RELEASED, points[i], i, release_time);
+    ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(points[i]), i,
+                           release_time);
     Dispatch(&release);
   }
 }
 
 void EventGenerator::ScrollSequence(const gfx::Point& start,
                                     const base::TimeDelta& step_delay,
                                     float x_offset,
                                     float y_offset,
                                     int steps,
                                     int num_fingers) {
   base::TimeDelta timestamp = Now();
-  ui::ScrollEvent fling_cancel(ui::ET_SCROLL_FLING_CANCEL,
-                               start,
-                               timestamp,
-                               0,
-                               0, 0,
-                               0, 0,
-                               num_fingers);
+  ui::ScrollEvent fling_cancel(ui::ET_SCROLL_FLING_CANCEL, gfx::PointF(start),
+                               timestamp, 0, 0, 0, 0, 0, num_fingers);
   Dispatch(&fling_cancel);
 
   float dx = x_offset / steps;
   float dy = y_offset / steps;
   for (int i = 0; i < steps; ++i) {
     timestamp += step_delay;
-    ui::ScrollEvent move(ui::ET_SCROLL,
-                         start,
-                         timestamp,
-                         0,
-                         dx, dy,
-                         dx, dy,
-                         num_fingers);
+    ui::ScrollEvent move(ui::ET_SCROLL, gfx::PointF(start), timestamp, 0, dx,
+                         dy, dx, dy, num_fingers);
     Dispatch(&move);
   }
 
-  ui::ScrollEvent fling_start(ui::ET_SCROLL_FLING_START,
-                              start,
-                              timestamp,
-                              0,
-                              x_offset, y_offset,
-                              x_offset, y_offset,
-                              num_fingers);
+  ui::ScrollEvent fling_start(ui::ET_SCROLL_FLING_START, gfx::PointF(start),
+                              timestamp, 0, x_offset, y_offset, x_offset,
+                              y_offset, num_fingers);
   Dispatch(&fling_start);
 }
 
 void EventGenerator::ScrollSequence(const gfx::Point& start,
                                     const base::TimeDelta& step_delay,
                                     const std::vector<gfx::PointF>& offsets,
                                     int num_fingers) {
   size_t steps = offsets.size();
   base::TimeDelta timestamp = Now();
-  ui::ScrollEvent fling_cancel(ui::ET_SCROLL_FLING_CANCEL,
-                               start,
-                               timestamp,
-                               0,
-                               0, 0,
-                               0, 0,
-                               num_fingers);
+  ui::ScrollEvent fling_cancel(ui::ET_SCROLL_FLING_CANCEL, gfx::PointF(start),
+                               timestamp, 0, 0, 0, 0, 0, num_fingers);
   Dispatch(&fling_cancel);
 
   for (size_t i = 0; i < steps; ++i) {
     timestamp += step_delay;
-    ui::ScrollEvent scroll(ui::ET_SCROLL,
-                           start,
-                           timestamp,
-                           0,
-                           offsets[i].x(), offsets[i].y(),
-                           offsets[i].x(), offsets[i].y(),
-                           num_fingers);
+    ui::ScrollEvent scroll(ui::ET_SCROLL, gfx::PointF(start), timestamp, 0,
+                           offsets[i].x(), offsets[i].y(), offsets[i].x(),
+                           offsets[i].y(), num_fingers);
     Dispatch(&scroll);
   }
 
-  ui::ScrollEvent fling_start(ui::ET_SCROLL_FLING_START,
-                              start,
-                              timestamp,
-                              0,
-                              offsets[steps - 1].x(), offsets[steps - 1].y(),
-                              offsets[steps - 1].x(), offsets[steps - 1].y(),
-                              num_fingers);
+  ui::ScrollEvent fling_start(ui::ET_SCROLL_FLING_START, gfx::PointF(start),
+                              timestamp, 0, offsets[steps - 1].x(),
+                              offsets[steps - 1].y(), offsets[steps - 1].x(),
+                              offsets[steps - 1].y(), num_fingers);
   Dispatch(&fling_start);
 }
 
 void EventGenerator::PressKey(ui::KeyboardCode key_code, int flags) {
   DispatchKeyEvent(true, key_code, flags);
 }
 
 void EventGenerator::ReleaseKey(ui::KeyboardCode key_code, int flags) {
   DispatchKeyEvent(false, key_code, flags);
 }
@@ skipping 57 matching lines @@
 
 void EventGenerator::UpdateCurrentDispatcher(const gfx::Point& point) {
   current_target_ = delegate()->GetTargetAt(point);
 }
 
 void EventGenerator::PressButton(int flag) {
   if (!(flags_ & flag)) {
     flags_ |= flag;
     grab_ = (flags_ & kAllButtonMask) != 0;
     gfx::Point location = GetLocationInCurrentRoot();
-    ui::MouseEvent mouseev(ui::ET_MOUSE_PRESSED, location, location,
-                           ui::EventTimeForNow(), flags_, flag);
+    ui::MouseEvent mouseev(ui::ET_MOUSE_PRESSED, gfx::PointF(location),
+                           gfx::PointF(location), ui::EventTimeForNow(), flags_,
+                           flag);
     Dispatch(&mouseev);
   }
 }
 
 void EventGenerator::ReleaseButton(int flag) {
   if (flags_ & flag) {
     gfx::Point location = GetLocationInCurrentRoot();
-    ui::MouseEvent mouseev(ui::ET_MOUSE_RELEASED, location, location,
-                           ui::EventTimeForNow(), flags_, flag);
+    ui::MouseEvent mouseev(ui::ET_MOUSE_RELEASED, gfx::PointF(location),
+                           gfx::PointF(location), ui::EventTimeForNow(), flags_,
+                           flag);
     Dispatch(&mouseev);
     flags_ ^= flag;
   }
   grab_ = (flags_ & kAllButtonMask) != 0;
 }
 
 gfx::Point EventGenerator::GetLocationInCurrentRoot() const {
   gfx::Point p(current_location_);
   delegate()->ConvertPointToTarget(current_target_, &p);
   return p;
@@ skipping 57 matching lines @@
   return default_delegate;
 }
 
 EventGeneratorDelegate* EventGenerator::delegate() {
   return const_cast<EventGeneratorDelegate*>(
       const_cast<const EventGenerator*>(this)->delegate());
 }
 
 }  // namespace test
 }  // namespace ui