Do not release capture when transferring capture between Chrome windows on Linux

ui/views/widget/desktop_aura/desktop_window_tree_host_x11.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 "ui/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
 
 #include <X11/extensions/shape.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xregion.h>
@@ skipping 31 matching lines @@
 #include "ui/views/ime/input_method.h"
 #include "ui/views/linux_ui/linux_ui.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/views_switches.h"
 #include "ui/views/widget/desktop_aura/desktop_drag_drop_client_aurax11.h"
 #include "ui/views/widget/desktop_aura/desktop_native_cursor_manager.h"
 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
 #include "ui/views/widget/desktop_aura/desktop_window_tree_host_observer_x11.h"
 #include "ui/views/widget/desktop_aura/x11_desktop_handler.h"
 #include "ui/views/widget/desktop_aura/x11_desktop_window_move_client.h"
-#include "ui/views/widget/desktop_aura/x11_scoped_capture.h"
 #include "ui/views/widget/desktop_aura/x11_window_event_filter.h"
 #include "ui/wm/core/compound_event_filter.h"
 #include "ui/wm/core/window_util.h"
 
 namespace views {
 
 DesktopWindowTreeHostX11* DesktopWindowTreeHostX11::g_current_capture =
     NULL;
 std::list<XID>* DesktopWindowTreeHostX11::open_windows_ = NULL;
 
@@ skipping 862 matching lines @@
     OnHostResized(bounds.size());
     ResetWindowRegion();
   }
 }
 
 gfx::Point DesktopWindowTreeHostX11::GetLocationOnNativeScreen() const {
   return bounds_.origin();
 }
 
 void DesktopWindowTreeHostX11::SetCapture() {
-  // This is vaguely based on the old NativeWidgetGtk implementation.
-  //
-  // X11's XPointerGrab() shouldn't be used for everything; it doesn't map
-  // cleanly to Windows' SetCapture(). GTK only provides a separate concept of
-  // a grab that wasn't the X11 pointer grab, but was instead a manual
-  // redirection of the event. (You need to drop into GDK if you want to
-  // perform a raw X11 grab).
+  // Grabbing the mouse is asynchronous. However, we synchronously start
+  // forwarding all mouse events received by Chrome to the
+  // aura::WindowEventDispatcher which has capture. This makes capture
+  // synchronous for all intents and purposes if either:
+  // - |g_current_capture|'s X window has capture.
+  // OR
+  // - The topmost window underneath the mouse is managed by Chrome.
+  if (g_current_capture)
+    g_current_capture->OnHostLostWindowCapture();
+  g_current_capture = this;
 
-  if (g_current_capture)
-    g_current_capture->OnCaptureReleased();
-
-  g_current_capture = this;
-  x11_capture_.reset(new X11ScopedCapture(xwindow_));
+  unsigned int event_mask = PointerMotionMask | ButtonReleaseMask |
+                            ButtonPressMask;
+  XGrabPointer(xdisplay_, xwindow_, True, event_mask, GrabModeAsync,
+               GrabModeAsync, None, None, CurrentTime);
 }
 
 void DesktopWindowTreeHostX11::ReleaseCapture() {
-  if (g_current_capture == this)
-    g_current_capture->OnCaptureReleased();
+  if (g_current_capture == this) {
+    // Release mouse grab asynchronously. A window managed by Chrome is likely
+    // the topmost window underneath the mouse so the capture release being
+    // asynchronous is likely inconsequential.
+    g_current_capture = NULL;
+    XUngrabPointer(xdisplay_, CurrentTime);
+
+    OnHostLostWindowCapture();
+  }
 }
 
 void DesktopWindowTreeHostX11::SetCursorNative(gfx::NativeCursor cursor) {
   XDefineCursor(xdisplay_, xwindow_, cursor.platform());
 }
 
 void DesktopWindowTreeHostX11::MoveCursorToNative(const gfx::Point& location) {
   XWarpPointer(xdisplay_, None, x_root_window_, 0, 0, 0, 0,
                bounds_.x() + location.x(), bounds_.y() + location.y());
 }
@@ skipping 408 matching lines @@
   return window_properties_.find(atom_cache_.GetAtom(property)) !=
       window_properties_.end();
 }
 
 void DesktopWindowTreeHostX11::SetUseNativeFrame(bool use_native_frame) {
   use_native_frame_ = use_native_frame;
   ui::SetUseOSWindowFrame(xwindow_, use_native_frame);
   ResetWindowRegion();
 }
 
-void DesktopWindowTreeHostX11::OnCaptureReleased() {
-  x11_capture_.reset();
-  g_current_capture = NULL;
-  OnHostLostWindowCapture();
-}
-
 void DesktopWindowTreeHostX11::DispatchMouseEvent(ui::MouseEvent* event) {
   // In Windows, the native events sent to chrome are separated into client
   // and non-client versions of events, which we record on our LocatedEvent
   // structures. On X11, we emulate the concept of non-client. Before we pass
   // this event to the cross platform event handling framework, we need to
   // make sure it is appropriately marked as non-client if it's in the non
   // client area, or otherwise, we can get into a state where the a window is
   // set as the |mouse_pressed_handler_| in window_event_dispatcher.cc
   // despite the mouse button being released.
   //
@@ skipping 508 matching lines @@
   if (linux_ui) {
     ui::NativeTheme* native_theme = linux_ui->GetNativeTheme(window);
     if (native_theme)
       return native_theme;
   }
 
   return ui::NativeTheme::instance();
 }
 
 }  // namespace views