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>
 #include <X11/Xutil.h>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/focus_client.h"
+#include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/dragdrop/os_exchange_data_provider_aurax11.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/events/platform/x11/x11_event_source.h"
 #include "ui/events/x/device_data_manager_x11.h"
 #include "ui/events/x/device_list_cache_x.h"
 #include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_rep.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/path_x11.h"
 #include "ui/gfx/screen.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/corewm/tooltip_aura.h"
 #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_capture_window.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 832 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).
+  DesktopWindowTreeHostX11* old_capture = g_current_capture;
+  g_current_capture = this;
+  if (old_capture) {
+    // Take ownership of |old_capture|'s capture window which already has a
+    // mouse grab. Because there is no X11 mouse grab or mouse ungrab, the
+    // capture change is sychronous.
+    capture_window_ = old_capture->ReleaseCaptureWindow().Pass();
 
-  if (g_current_capture)
-    g_current_capture->OnCaptureReleased();
+    old_capture->OnHostLostWindowCapture();
+  }
 
-  g_current_capture = this;
-  x11_capture_.reset(new X11ScopedCapture(xwindow_));
+  if (!capture_window_) {
+    // Create an X11CaptureWindow to asynchronously grab the mouse. As
+    // |xwindow_| is likely the topmost window underneath the mouse, we will
+    // likely not miss any mouse events.
+    capture_window_.reset(new X11CaptureWindow);
+  }
 }
 
 void DesktopWindowTreeHostX11::ReleaseCapture() {
-  if (g_current_capture == this)
-    g_current_capture->OnCaptureReleased();
+  if (g_current_capture == this) {
+    // Release mouse grab asynchronously. |xwindow_| is likely the topmost
+    // window underneath the mouse so the capture release being asynchronous is
+    // likely inconsequential.
+    g_current_capture = NULL;
+    capture_window_.reset();
+
+    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 361 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();
+scoped_ptr<X11CaptureWindow> DesktopWindowTreeHostX11::ReleaseCaptureWindow() {
+  return capture_window_.Pass();
 }
 
 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
@@ skipping 13 matching lines @@
     if (hit_test_code != HTCLIENT && hit_test_code != HTNOWHERE)
       flags |= ui::EF_IS_NON_CLIENT;
     event->set_flags(flags);
   }
 
   // While we unset the urgency hint when we gain focus, we also must remove it
   // on mouse clicks because we can call FlashFrame() on an active window.
   if (event->IsAnyButton() || event->IsMouseWheelEvent())
     FlashFrame(false);
 
+  if (ui::EventTargetFromNative(event->native_event()) != xwindow_) {
+    // The event was targeted at |capture_window_|'s X window.
+    gfx::Point location =
+        ui::EventSystemLocationFromNative(event->native_event());
+    aura::client::GetScreenPositionClient(window())->ConvertPointFromScreen(
+        window(), &location);
+    event->set_location(location);
+  }
+
   if (!g_current_capture || g_current_capture == this) {
     SendEventToProcessor(event);
   } else {
-    // Another DesktopWindowTreeHostX11 has installed itself as
-    // capture. Translate the event's location and dispatch to the other.
+    // Another DesktopWindowTreeHostX11 has capture. Translate the event's
+    // location and dispatch to the other DesktopWindowTreeHostX11.
     event->ConvertLocationToTarget(window(), g_current_capture->window());
     g_current_capture->SendEventToProcessor(event);
   }
 }
 
 void DesktopWindowTreeHostX11::DispatchTouchEvent(ui::TouchEvent* event) {
+  DCHECK_EQ(ui::EventTargetFromNative(event->native_event()), xwindow_);
   if (g_current_capture && g_current_capture != this &&
       event->type() == ui::ET_TOUCH_PRESSED) {
     event->ConvertLocationToTarget(window(), g_current_capture->window());
     g_current_capture->SendEventToProcessor(event);
   } else {
     SendEventToProcessor(event);
   }
 }
 
 void DesktopWindowTreeHostX11::ResetWindowRegion() {
@@ skipping 158 matching lines @@
     non_client_view->InvalidateLayout();
   }
   widget->GetRootView()->Layout();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowTreeHostX11, ui::PlatformEventDispatcher implementation:
 
 bool DesktopWindowTreeHostX11::CanDispatchEvent(
     const ui::PlatformEvent& event) {
-  return event->xany.window == xwindow_ ||
-         (event->type == GenericEvent &&
-          static_cast<XIDeviceEvent*>(event->xcookie.data)->event == xwindow_);
+  XID target = ui::EventTargetFromNative(event);
+  return target == xwindow_ ||
+      (capture_window_ && target == capture_window_->xwindow());
 }
 
 uint32_t DesktopWindowTreeHostX11::DispatchEvent(
     const ui::PlatformEvent& event) {
   XEvent* xev = event;
 
   TRACE_EVENT1("views", "DesktopWindowTreeHostX11::Dispatch",
                "event->type", event->type);
 
   UpdateWMUserTime(event);
 
   // May want to factor CheckXEventForConsistency(xev); into a common location
   // since it is called here.
   switch (xev->type) {
     case EnterNotify:
     case LeaveNotify: {
       // Ignore EventNotify and LeaveNotify events from children of |xwindow_|.
       // NativeViewGLSurfaceGLX adds a child to |xwindow_|.
       // TODO(pkotwicz|tdanderson): Figure out whether the suppression is
       // necessary. crbug.com/385716
       if (xev->xcrossing.detail == NotifyInferior)
         break;
 
       ui::MouseEvent mouse_event(xev);
       DispatchMouseEvent(&mouse_event);
+
+      if (xev->xcrossing.mode == NotifyGrab ||
+          xev->xcrossing.mode == NotifyUngrab) {
+        ReleaseCapture();
+      }
       break;
     }
     case Expose: {
       gfx::Rect damage_rect(xev->xexpose.x, xev->xexpose.y,
                             xev->xexpose.width, xev->xexpose.height);
       compositor()->ScheduleRedrawRect(damage_rect);
       break;
     }
     case KeyPress:
     case KeyRelease: {
@@ skipping 239 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