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 52 matching lines @@
   "XdndFinished",
   "XdndLeave",
   "XdndPosition",
   "XdndProxy",  // Proxy windows?
   "XdndSelection",
   "XdndStatus",
   "XdndTypeList",
   NULL
 };
 
+// Returns |native_event|'s target.
+XID EventTargetFromNative(const base::NativeEvent& native_event) {
+  return (native_event->type == GenericEvent) ?
+      static_cast<XIDeviceEvent*>(native_event->xcookie.data)->event :
+      native_event->xany.window;
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopWindowTreeHostX11, public:
 
 DesktopWindowTreeHostX11::DesktopWindowTreeHostX11(
     internal::NativeWidgetDelegate* native_widget_delegate,
     DesktopNativeWidgetAura* desktop_native_widget_aura)
     : close_widget_factory_(this),
       xdisplay_(gfx::GetXDisplay()),
@@ skipping 762 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 392 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 (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_root_location(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.
-    event->ConvertLocationToTarget(window(), g_current_capture->window());
+    // Another DesktopWindowTreeHostX11 has capture. Translate the event's
+    // location and dispatch to the other DesktopWindowTreeHostX11.
+    gfx::Point location = event->location();
+    aura::Window::ConvertPointToTarget(window(),
+                                       g_current_capture->window(),
+                                       &location);
+    event->set_root_location(location);
+    event->set_location(location);

[sadrul, 2014/07/29 18:47:50]

ConvertLocationToTarget() should work correctly here. Does it not?

[pkotwicz, 2014/08/01 03:35:00]

I am splitting this change out to a different CL because it is no longer
necessary for the purpose of the CL.
ConvertLocationToTarget() does not work because it does not update the root
location. We do something similar in MenuMessageLoopAura::RepostEventToWindow()

[pkotwicz, 2014/08/01 04:32:14]

You are right ConvertLocationToTarget() does work properly. The event's root
location is set later in LocatedEvent::UpdateForRootTransform()

     g_current_capture->SendEventToProcessor(event);
   }
 }
 
 void DesktopWindowTreeHostX11::DispatchTouchEvent(ui::TouchEvent* event) {
+  DCHECK_EQ(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_);
+  return EventTargetFromNative(event) == xwindow_ ||
+      (capture_window_ && capture_window_->CanDispatchEventToOwner(event));
 }
 
 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();

[sadrul, 2014/07/29 18:47:50]

Should NotifyGrab really trigger ReleaseCapture()?

[pkotwicz, 2014/08/01 03:35:00]

I am going to differ releasing capture as a result of LeaveNotify for now.
After doing some reading, receiving LeaveNotify with any mode can signify a loss
of capture. A LeaveNotify event with NotifyGrab/NotifyUngrab is not sent if the
window loses capture but the window is the topmost window underneath the mouse.

+      } else {
+        ui::MouseEvent mouse_event(xev);
+        DispatchMouseEvent(&mouse_event);
+      }
       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: {
       ui::KeyEvent keydown_event(xev);
@@ skipping 260 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