Explicitly convert Point to PointF for event code

ui/aura/window_event_dispatcher.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/aura/window_event_dispatcher.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 135 matching lines @@
     event->ConvertLocationToTarget(window(), target);
     DispatchDetails details = DispatchEvent(target, event);
     if (details.dispatcher_destroyed)
       return;
   }
 }
 
 DispatchDetails WindowEventDispatcher::DispatchMouseExitAtPoint(
     Window* window,
     const gfx::Point& point) {
-  ui::MouseEvent event(ui::ET_MOUSE_EXITED, point, point, ui::EventTimeForNow(),
-                       ui::EF_NONE, ui::EF_NONE);
+  ui::MouseEvent event(ui::ET_MOUSE_EXITED, gfx::PointF(point),
+                       gfx::PointF(point), ui::EventTimeForNow(), ui::EF_NONE,
+                       ui::EF_NONE);
   return DispatchMouseEnterOrExit(window, event, ui::ET_MOUSE_EXITED);
 }
 
 void WindowEventDispatcher::ProcessedTouchEvent(uint32 unique_event_id,
                                                 Window* window,
                                                 ui::EventResult result) {
   scoped_ptr<ui::GestureRecognizer::Gestures> gestures(
       ui::GestureRecognizer::Get()->AckTouchEvent(unique_event_id, result,
                                                   window));
   DispatchDetails details = ProcessGestures(gestures.get());
@@ skipping 193 matching lines @@
                                           Window* new_capture) {
   // |mouse_moved_handler_| may have been set to a Window in a different root
   // (see below). Clear it here to ensure we don't end up referencing a stale
   // Window.
   if (mouse_moved_handler_ && !window()->Contains(mouse_moved_handler_))
     mouse_moved_handler_ = NULL;
 
   if (old_capture && old_capture->GetRootWindow() == window() &&
       old_capture->delegate()) {
     // Send a capture changed event with bogus location data.
-    ui::MouseEvent event(ui::ET_MOUSE_CAPTURE_CHANGED, gfx::Point(),
-                         gfx::Point(), ui::EventTimeForNow(), 0, 0);
+    ui::MouseEvent event(ui::ET_MOUSE_CAPTURE_CHANGED, gfx::PointF(),
+                         gfx::PointF(), ui::EventTimeForNow(), 0, 0);
 
     DispatchDetails details = DispatchEvent(old_capture, &event);
     if (details.dispatcher_destroyed)
       return;
 
     if (!details.target_destroyed)
       old_capture->delegate()->OnCaptureLost();
   }
 
   if (new_capture) {
@@ skipping 333 matching lines @@
   // DRAGGED event can be synthesized in the incorrect host. So avoid
   // synthesizing any events at all.
   if (Env::GetInstance()->mouse_button_flags())
     return details;
 
   gfx::Point root_mouse_location = GetLastMouseLocationInRoot();
   if (!window()->bounds().Contains(root_mouse_location))
     return details;
   gfx::Point host_mouse_location = root_mouse_location;
   host_->ConvertPointToHost(&host_mouse_location);
-  ui::MouseEvent event(ui::ET_MOUSE_MOVED, host_mouse_location,
-                       host_mouse_location, ui::EventTimeForNow(),
+  ui::MouseEvent event(ui::ET_MOUSE_MOVED, gfx::PointF(host_mouse_location),
+                       gfx::PointF(host_mouse_location), ui::EventTimeForNow(),
                        ui::EF_IS_SYNTHESIZED, 0);
   return OnEventFromSource(&event);
 }
 
 void WindowEventDispatcher::PreDispatchLocatedEvent(Window* target,
                                                     ui::LocatedEvent* event) {
   int flags = event->flags();
   if (IsNonClientLocation(target, event->location()))
     flags |= ui::EF_IS_NON_CLIENT;
   event->set_flags(flags);
@@ skipping 155 matching lines @@
   }
 
   // This flag is set depending on the gestures recognized in the call above,
   // and needs to propagate with the forwarded event.
   event->set_may_cause_scrolling(orig_event.may_cause_scrolling());
 
   PreDispatchLocatedEvent(target, event);
 }
 
 }  // namespace aura