ui::LocatedEvent location() returns gfx::PointF

ash/wm/toplevel_window_event_handler.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/wm/toplevel_window_event_handler.h"
 
 #include "ash/shell.h"
 #include "ash/wm/resize_shadow_controller.h"
 #include "ash/wm/window_resizer.h"
 #include "ash/wm/window_state.h"
@@ skipping 58 matching lines @@
 
 gfx::Point ConvertPointToParent(aura::Window* window,
                                 const gfx::Point& point) {
   gfx::Point result(point);
   aura::Window::ConvertPointToTarget(window, window->parent(), &result);
   return result;
 }
 
 // Returns the window component containing |event|'s location.
 int GetWindowComponent(aura::Window* window, const ui::LocatedEvent& event) {
-  return window->delegate()->GetNonClientComponent(event.location());
+  return window->delegate()->GetNonClientComponent(
+      gfx::ToFlooredPoint(event.location()));
 }
 
 }  // namespace
 
 // ScopedWindowResizer ---------------------------------------------------------
 
 // Wraps a WindowResizer and installs an observer on its target window.  When
 // the window is destroyed ResizerWindowDestroyed() is invoked back on the
 // ToplevelWindowEventHandler to clean up.
 class ToplevelWindowEventHandler::ScopedWindowResizer
@@ skipping 193 matching lines @@
       // window jumping upon initiating a two finger drag. When a one finger
       // drag is converted to a two finger drag, a jump occurs because the
       // location of the ET_GESTURE_SCROLL_UPDATE event switches from the single
       // finger's position to the position in the middle of the two fingers.
       if (window_resizer_.get())
         return;
       int component = GetWindowComponent(target, *event);
       if (!CanStartOneFingerDrag(component))
         return;
       gfx::Point location_in_parent(
-          ConvertPointToParent(target, event->location()));
+          ConvertPointToParent(target, gfx::ToFlooredPoint(event->location())));
       AttemptToStartDrag(target, location_in_parent, component,
                          aura::client::WINDOW_MOVE_SOURCE_TOUCH);
       event->StopPropagation();
       return;
     }
     default:
       break;
   }
 
   if (!window_resizer_.get())
@@ skipping 162 matching lines @@
     return;
 
   // We also update the current window component here because for the
   // mouse-drag-release-press case, where the mouse is released and
   // pressed without mouse move event.
   int component = GetWindowComponent(target, *event);
   if ((event->flags() &
         (ui::EF_IS_DOUBLE_CLICK | ui::EF_IS_TRIPLE_CLICK)) == 0 &&
       WindowResizer::GetBoundsChangeForWindowComponent(component)) {
     gfx::Point location_in_parent(
-        ConvertPointToParent(target, event->location()));
+        ConvertPointToParent(target, gfx::ToFlooredPoint(event->location())));
     AttemptToStartDrag(target, location_in_parent, component,
                        aura::client::WINDOW_MOVE_SOURCE_MOUSE);
     // Set as handled so that other event handlers do no act upon the event
     // but still receive it so that they receive both parts of each pressed/
     // released pair.
     event->SetHandled();
   } else {
     CompleteDrag(DRAG_COMPLETE);
   }
 }
@@ skipping 27 matching lines @@
          event->type() == ui::ET_GESTURE_SCROLL_UPDATE);
 
   // Drag actions are performed pre-target handling to prevent spurious mouse
   // moves from the move/size operation from being sent to the target.
   if (event->phase() != ui::EP_PRETARGET)
     return;
 
   if (!window_resizer_)
     return;
   window_resizer_->resizer()->Drag(
-      ConvertPointToParent(target, event->location()), event->flags());
+      ConvertPointToParent(target, gfx::ToFlooredPoint(event->location())),
+      event->flags());
   event->StopPropagation();
 }
 
 void ToplevelWindowEventHandler::HandleMouseMoved(
     aura::Window* target,
     ui::LocatedEvent* event) {
   // Shadow effects are applied after target handling. Note that we don't
   // respect ER_HANDLED here right now since we have not had a reason to allow
   // the target to cancel shadow rendering.
   if (event->phase() != ui::EP_POSTTARGET || !target->delegate())
     return;
 
   // TODO(jamescook): Move the resize cursor update code into here from
   // CompoundEventFilter?
   ResizeShadowController* controller =
       Shell::GetInstance()->resize_shadow_controller();
   if (controller) {
     if (event->flags() & ui::EF_IS_NON_CLIENT) {
-      int component =
-          target->delegate()->GetNonClientComponent(event->location());
+      int component = target->delegate()->GetNonClientComponent(
+          gfx::ToFlooredPoint(event->location()));
       controller->ShowShadow(target, component);
     } else {
       controller->HideShadow(target);
     }
   }
 }
 
 void ToplevelWindowEventHandler::HandleMouseExited(
     aura::Window* target,
     ui::LocatedEvent* event) {
@@ skipping 51 matching lines @@
 
 void ToplevelWindowEventHandler::ResizerWindowDestroyed() {
   // We explicitly don't invoke RevertDrag() since that may do things to window.
   // Instead we destroy the resizer.
   window_resizer_.reset();
 
   CompleteDrag(DRAG_REVERT);
 }
 
 }  // namespace ash