Fix the wrong relative coordinates from EventDispatch

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/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 132 matching lines @@
   Window* target = GetGestureTarget(event);
   if (target) {
     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::EF_NONE,
                        ui::EF_NONE);
-  return DispatchMouseEnterOrExit(event, ui::ET_MOUSE_EXITED);
+  return DispatchMouseEnterOrExit(window, event, ui::ET_MOUSE_EXITED);
 }
 
 void WindowEventDispatcher::ProcessedTouchEvent(ui::TouchEvent* event,
                                                 Window* window,
                                                 ui::EventResult result) {
   // Once we've fully migrated to the eager gesture detector, we won't need to
   // pass an event here.
   scoped_ptr<ui::GestureRecognizer::Gestures> gestures(
       ui::GestureRecognizer::Get()->AckAsyncTouchEvent(
           *event, result, window));
@@ skipping 68 matching lines @@
 
 void WindowEventDispatcher::DispatchMouseExitToHidingWindow(Window* window) {
   // The mouse capture is intentionally ignored. Think that a mouse enters
   // to a window, the window sets the capture, the mouse exits the window,
   // and then it releases the capture. In that case OnMouseExited won't
   // be called. So it is natural not to emit OnMouseExited even though
   // |window| is the capture window.
   gfx::Point last_mouse_location = GetLastMouseLocationInRoot();
   if (window->Contains(mouse_moved_handler_) &&
       window->ContainsPointInRoot(last_mouse_location)) {
-    DispatchDetails details = DispatchMouseExitAtPoint(last_mouse_location);
+    DispatchDetails details =
+        DispatchMouseExitAtPoint(window, last_mouse_location);
     if (details.dispatcher_destroyed)
       return;
   }
 }
 
 ui::EventDispatchDetails WindowEventDispatcher::DispatchMouseEnterOrExit(
+    Window* target,
     const ui::MouseEvent& event,
     ui::EventType type) {
   if (event.type() != ui::ET_MOUSE_CAPTURE_CHANGED &&
       !(event.flags() & ui::EF_IS_SYNTHESIZED)) {
     SetLastMouseLocation(window(), event.root_location());
   }
 
   if (!mouse_moved_handler_ || !mouse_moved_handler_->delegate() ||
       !window()->Contains(mouse_moved_handler_))
     return DispatchDetails();
 
   // |event| may be an event in the process of being dispatched to a target (in
   // which case its locations will be in the event's target's coordinate
   // system), or a synthetic event created in root-window (in which case, the
   // event's target will be NULL, and the event will be in the root-window's
   // coordinate system.
-  aura::Window* target = static_cast<Window*>(event.target());
   if (!target)
     target = window();
   ui::MouseEvent translated_event(event,
                                   target,
                                   mouse_moved_handler_,
                                   type,
                                   event.flags() | ui::EF_IS_SYNTHESIZED);
   return DispatchEvent(mouse_moved_handler_, &translated_event);
 }
 
@@ skipping 118 matching lines @@
   // OS to send us the mouse exit events (WM_MOUSELEAVE). Additionally on
   // desktop Windows, every top level window could potentially have its own
   // root window, in which case this function will get called whenever those
   // windows grab mouse capture. Sending mouse exit messages in these cases
   // causes subtle bugs like (crbug.com/394672).
 #if !defined(OS_WIN)
   if (mouse_moved_handler_) {
     // Dispatch a mouse exit to reset any state associated with hover. This is
     // important when going from no window having capture to a window having
     // capture because we do not dispatch ET_MOUSE_CAPTURE_CHANGED in this case.
-    DispatchDetails details = DispatchMouseExitAtPoint(
-        GetLastMouseLocationInRoot());
+    DispatchDetails details =
+        DispatchMouseExitAtPoint(nullptr, GetLastMouseLocationInRoot());
     if (details.dispatcher_destroyed)
       return;
   }
 #endif
 
   mouse_moved_handler_ = NULL;
   mouse_pressed_handler_ = NULL;
 }
 
 void WindowEventDispatcher::SetNativeCapture() {
@@ skipping 359 matching lines @@
     }
   }
 
   const int kMouseButtonFlagMask = ui::EF_LEFT_MOUSE_BUTTON |
                                    ui::EF_MIDDLE_MOUSE_BUTTON |
                                    ui::EF_RIGHT_MOUSE_BUTTON;
   switch (event->type()) {
     case ui::ET_MOUSE_EXITED:
       if (!target || target == window()) {
         DispatchDetails details =
-            DispatchMouseEnterOrExit(*event, ui::ET_MOUSE_EXITED);
+            DispatchMouseEnterOrExit(target, *event, ui::ET_MOUSE_EXITED);
         if (details.dispatcher_destroyed) {
           event->SetHandled();
           return;
         }
         mouse_moved_handler_ = NULL;
       }
       break;
     case ui::ET_MOUSE_MOVED:
       // Send an exit to the current |mouse_moved_handler_| and an enter to
       // |target|. Take care that both us and |target| aren't destroyed during
       // dispatch.
       if (target != mouse_moved_handler_) {
         aura::Window* old_mouse_moved_handler = mouse_moved_handler_;
         WindowTracker live_window;
         live_window.Add(target);
         DispatchDetails details =
-            DispatchMouseEnterOrExit(*event, ui::ET_MOUSE_EXITED);
+            DispatchMouseEnterOrExit(target, *event, ui::ET_MOUSE_EXITED);
         if (details.dispatcher_destroyed) {
           event->SetHandled();
           return;
         }
         // If the |mouse_moved_handler_| changes out from under us, assume a
         // nested message loop ran and we don't need to do anything.
         if (mouse_moved_handler_ != old_mouse_moved_handler) {
           event->SetHandled();
           return;
         }
         if (!live_window.Contains(target) || details.target_destroyed) {
           mouse_moved_handler_ = NULL;
           event->SetHandled();
           return;
         }
         live_window.Remove(target);
 
         mouse_moved_handler_ = target;
-        details = DispatchMouseEnterOrExit(*event, ui::ET_MOUSE_ENTERED);
+        details =
+            DispatchMouseEnterOrExit(target, *event, ui::ET_MOUSE_ENTERED);
         if (details.dispatcher_destroyed || details.target_destroyed) {
           event->SetHandled();
           return;
         }
       }
       break;
     case ui::ET_MOUSE_PRESSED:
       // Don't set the mouse pressed handler for non client mouse down events.
       // These are only sent by Windows and are not always followed with non
       // client mouse up events which causes subsequent mouse events to be
@@ skipping 57 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