Dispatch a synthetic mouse exit to the widget handling mouse events when a widget grabs capture

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;
   }
 }
 
-void WindowEventDispatcher::DispatchMouseExitAtPoint(const gfx::Point& point) {
+DispatchDetails WindowEventDispatcher::DispatchMouseExitAtPoint(
+    const gfx::Point& point) {
   ui::MouseEvent event(ui::ET_MOUSE_EXITED, point, point, ui::EF_NONE,
                        ui::EF_NONE);
-  DispatchDetails details =
-      DispatchMouseEnterOrExit(event, ui::ET_MOUSE_EXITED);
-  if (details.dispatcher_destroyed)
-    return;
+  return DispatchMouseEnterOrExit(event, ui::ET_MOUSE_EXITED);
 }
 
 void WindowEventDispatcher::ProcessedTouchEvent(ui::TouchEvent* event,
                                                 Window* window,
                                                 ui::EventResult result) {
   scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
   gestures.reset(ui::GestureRecognizer::Get()->
       ProcessTouchEventForGesture(*event, result, window));
   DispatchDetails details = ProcessGestures(gestures.get());
   if (details.dispatcher_destroyed)
@@ skipping 27 matching lines @@
 gfx::Point WindowEventDispatcher::GetLastMouseLocationInRoot() const {
   gfx::Point location = Env::GetInstance()->last_mouse_location();
   client::ScreenPositionClient* client =
       client::GetScreenPositionClient(window());
   if (client)
     client->ConvertPointFromScreen(window(), &location);
   return location;
 }
 
 void WindowEventDispatcher::OnHostLostMouseGrab() {
   mouse_pressed_handler_ = NULL;

[sadrul, 2014/06/26 12:59:35]

Is it necessary to make the same changes in here?

In fact, is it possible to remove OnHostLostMouseGrab()? Looks like it's called
only from DesktopWindowTreeHostX11::DispatchEvent(), and it may make sense to
just call into OnOtherRootGotCapture() instead from there.

[pkotwicz, 2014/06/26 14:45:17]

I need to investigate why OnHostLostMouseGrab() is its own function. I have a
slight suspicion that it has to do with the bad things we do with capture during
tab dragging

   mouse_moved_handler_ = NULL;
 }
 
 void WindowEventDispatcher::OnCursorMovedToRootLocation(
     const gfx::Point& root_location) {
   SetLastMouseLocation(window(), root_location);
   synthesize_mouse_move_ = false;
 }
 
 void WindowEventDispatcher::OnPostNotifiedWindowDestroying(Window* window) {
@@ skipping 17 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))
-    DispatchMouseExitAtPoint(last_mouse_location);
+      window->ContainsPointInRoot(last_mouse_location)) {
+    DispatchDetails details = DispatchMouseExitAtPoint(last_mouse_location);
+    if (details.dispatcher_destroyed)
+      return;
+  }
 }
 
 ui::EventDispatchDetails WindowEventDispatcher::DispatchMouseEnterOrExit(
     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());
   }
 
@@ skipping 123 matching lines @@
   } else {
     // Make sure mouse_moved_handler gets updated.
     DispatchDetails details = SynthesizeMouseMoveEvent();
     if (details.dispatcher_destroyed)
       return;
   }
   mouse_pressed_handler_ = NULL;
 }
 
 void WindowEventDispatcher::OnOtherRootGotCapture() {
+  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());
+    if (details.dispatcher_destroyed)
+      return;
+  }
+
   mouse_moved_handler_ = NULL;
   mouse_pressed_handler_ = NULL;
 }
 
 void WindowEventDispatcher::SetNativeCapture() {
   host_->SetCapture();
 }
 
 void WindowEventDispatcher::ReleaseNativeCapture() {
   host_->ReleaseCapture();
@@ skipping 443 matching lines @@
       break;
 
     default:
       NOTREACHED();
       break;
   }
   PreDispatchLocatedEvent(target, event);
 }
 
 }  // namespace aura