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 131 matching lines @@
     return;
   Window* target = GetGestureTarget(event);
   if (target) {
     event->ConvertLocationToTarget(window(), target);
     DispatchDetails details = DispatchEvent(target, event);
     if (details.dispatcher_destroyed)
       return;
   }
 }
 
-DispatchDetails WindowEventDispatcher::DispatchMouseExitAtPoint(
+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 (event.target())

[sky, 2014/12/18 20:29:29]

Why do we need both the supplied target and event.target()? 
WindowEventDispatcher::DispatchMouseExitAtPoint is creating an event, can't it
set the window on the target?

[Miyoung Shin, 2014/12/19 14:39:42]

You're right.
I think I can use only target to consider both of DispatchMouseExitAtPoint and
PreDispatchMouseEvent. I will change.

[sky, 2015/01/05 17:23:02]

You didn't quite end up with what I was suggesting. I'm wondering if when
WindowEventDispatcher::DispatchMouseExitAtPoint creates the MouseEvent it can
set the target on the MouseEvent. I believe this would mean you don't need to
supply an additional target.

[Miyoung Shin, 2015/01/06 13:20:44]

Sorry, I don't understand your point yet and why you mentioned
DispatchMouseExitAtPoint.
I can set the target on the MouseEvent in 
WindowEventDispatcher::DispatchMouseExitAtPoint.
But I have no idea how to set the target in
WindowEventDispatcher::PreDispatchMouseEvent that has originally the issue
without supplying an additional target.
Do you mean I should add setTarget method in Event class for
PreDispatchMouseEvent?
If I'm wrong, please correct me.

+    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(
+    DispatchDetails details = DispatchMouseExitAtPoint(NULL,

[sky, 2014/12/18 20:29:29]

nullptr

[Miyoung Shin, 2014/12/19 14:39:42]

ok

         GetLastMouseLocationInRoot());
     if (details.dispatcher_destroyed)
       return;
   }
 #endif
 
   mouse_moved_handler_ = NULL;
   mouse_pressed_handler_ = NULL;
 }
 
@@ skipping 360 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 53 matching lines @@
     // The event is invalid - ignore it.
     event->StopPropagation();
     event->DisableSynchronousHandling();
     return;
   }
 
   PreDispatchLocatedEvent(target, event);
 }
 
 }  // namespace aura