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 65 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 102 matching lines @@
   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(), 0, 0);
 
     DispatchDetails details = DispatchEvent(old_capture, &event);
-    if (details.dispatcher_destroyed)
+    if (details.dispatcher_destroyed || details.target_destroyed)
       return;
 
     old_capture->delegate()->OnCaptureLost();
+
+    if (!new_capture) {
+      // Make sure |mouse_moved_handler_| gets updated.
+      DispatchDetails details = SynthesizeMouseMoveEvent();
+      if (details.dispatcher_destroyed)
+        return;
+    }
+  } else if (mouse_moved_handler_ &&
+             mouse_moved_handler_ != new_capture) {

[sadrul, 2014/06/24 18:33:09]

Should you check for a non-null |new_capture| here?

+    // 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;
   }
 
   if (new_capture) {
-    // Make all subsequent mouse events go to the capture window. We shouldn't
-    // need to send an event here as OnCaptureLost() should take care of that.
+    // Make all subsequent mouse events go to the capture window.
     if (mouse_moved_handler_ || Env::GetInstance()->IsMouseButtonDown())
       mouse_moved_handler_ = new_capture;
-  } 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