linux-aura: Fix some dragging behaviour.

ui/views/widget/desktop_aura/desktop_root_window_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_root_window_host_x11.h"
 
 #include <X11/extensions/shape.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xregion.h>
@@ skipping 29 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/widget/desktop_aura/desktop_dispatcher_client.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_root_window_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"
 
 namespace views {
 
 DesktopRootWindowHostX11* DesktopRootWindowHostX11::g_current_capture =
     NULL;
 std::list<XID>* DesktopRootWindowHostX11::open_windows_ = NULL;
 
 DEFINE_WINDOW_PROPERTY_KEY(
     aura::Window*, kViewsWindowForRootWindow, NULL);
@@ skipping 225 matching lines @@
         FROM_HERE,
         base::Bind(&DesktopRootWindowHostX11::CloseNow,
                    close_widget_factory_.GetWeakPtr()));
   }
 }
 
 void DesktopRootWindowHostX11::CloseNow() {
   if (xwindow_ == None)
     return;
 
+  x11_capture_.reset();
   native_widget_delegate_->OnNativeWidgetDestroying();
 
   // If we have children, close them. Use a copy for iteration because they'll
   // remove themselves.
   std::set<DesktopRootWindowHostX11*> window_children_copy = window_children_;
   for (std::set<DesktopRootWindowHostX11*>::iterator it =
            window_children_copy.begin(); it != window_children_copy.end();
        ++it) {
     (*it)->CloseNow();
   }
@@ skipping 154 matching lines @@
   delete native_region;
 }
 
 void DesktopRootWindowHostX11::Activate() {
   X11DesktopHandler::get()->ActivateWindow(xwindow_);
   native_widget_delegate_->AsWidget()->SetInitialFocus();
 }
 
 void DesktopRootWindowHostX11::Deactivate() {
   // Deactivating a window means activating nothing.
+  x11_capture_.reset();
   X11DesktopHandler::get()->ActivateWindow(None);
 }
 
 bool DesktopRootWindowHostX11::IsActive() const {
   return X11DesktopHandler::get()->IsActiveWindow(xwindow_);
 }
 
 void DesktopRootWindowHostX11::Maximize() {
   // When we're the process requesting the maximizing, we can accurately keep
   // track of our restored bounds instead of relying on the heuristics that are
   // in the PropertyNotify and ConfigureNotify handlers.
   restored_bounds_ = bounds_;
 
   SetWMSpecState(true,
                  atom_cache_.GetAtom("_NET_WM_STATE_MAXIMIZED_VERT"),
                  atom_cache_.GetAtom("_NET_WM_STATE_MAXIMIZED_HORZ"));
 }
 
 void DesktopRootWindowHostX11::Minimize() {
+  x11_capture_.reset();
   XIconifyWindow(xdisplay_, xwindow_, 0);
 }
 
 void DesktopRootWindowHostX11::Restore() {
   SetWMSpecState(false,
                  atom_cache_.GetAtom("_NET_WM_STATE_MAXIMIZED_VERT"),
                  atom_cache_.GetAtom("_NET_WM_STATE_MAXIMIZED_HORZ"));
 }
 
 bool DesktopRootWindowHostX11::IsMaximized() const {
@@ skipping 189 matching lines @@
   }
 
   XSetWMNormalHints(xdisplay_, xwindow_, &hints);
 }
 
 void DesktopRootWindowHostX11::OnNativeWidgetFocus() {
   native_widget_delegate_->AsWidget()->GetInputMethod()->OnFocus();
 }
 
 void DesktopRootWindowHostX11::OnNativeWidgetBlur() {
-  if (xwindow_)
+  if (xwindow_) {
+    x11_capture_.reset();
     native_widget_delegate_->AsWidget()->GetInputMethod()->OnBlur();
+  }
 }
 
 bool DesktopRootWindowHostX11::IsAnimatingClosed() const {
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopRootWindowHostX11, aura::RootWindowHost implementation:
 
 aura::RootWindow* DesktopRootWindowHostX11::GetRootWindow() {
@@ skipping 97 matching lines @@
   // 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).
 
   if (g_current_capture)
     g_current_capture->OnCaptureReleased();
 
   g_current_capture = this;
-
-  // TODO(erg): In addition to the above, NativeWidgetGtk performs a full X
-  // pointer grab when our NativeWidget is of type Menu. However, things work
-  // without it. Clicking inside a chrome window causes a release capture, and
-  // clicking outside causes an activation change. Since previous attempts at
-  // using XPointerGrab() to implement this have locked my X server, I'm going
-  // to skip this for now.
+  x11_capture_.reset(new X11ScopedCapture(xwindow_));
 }
 
 void DesktopRootWindowHostX11::ReleaseCapture() {
-  if (g_current_capture)
+  if (g_current_capture == this)
     g_current_capture->OnCaptureReleased();
 }
 
 void DesktopRootWindowHostX11::SetCursor(gfx::NativeCursor cursor) {
   XDefineCursor(xdisplay_, xwindow_, cursor.platform());
 }
 
 bool DesktopRootWindowHostX11::QueryMouseLocation(
     gfx::Point* location_return) {
   aura::client::CursorClient* cursor_client =
@@ skipping 258 matching lines @@
              SubstructureRedirectMask | SubstructureNotifyMask,
              &xclient);
 }
 
 bool DesktopRootWindowHostX11::HasWMSpecProperty(const char* property) const {
   return window_properties_.find(atom_cache_.GetAtom(property)) !=
       window_properties_.end();
 }
 
 void DesktopRootWindowHostX11::OnCaptureReleased() {
+  x11_capture_.reset();
   g_current_capture = NULL;
   delegate_->OnHostLostWindowCapture();
   native_widget_delegate_->OnMouseCaptureLost();
 }
 
 void DesktopRootWindowHostX11::DispatchMouseEvent(ui::MouseEvent* event) {
   if (!g_current_capture || g_current_capture == this) {
     delegate_->OnHostMouseEvent(event);
   } else {
     // Another DesktopRootWindowHostX11 has installed itself as
@@ skipping 420 matching lines @@
   if (linux_ui) {
     ui::NativeTheme* native_theme = linux_ui->GetNativeTheme();
     if (native_theme)
       return native_theme;
   }
 
   return ui::NativeTheme::instance();
 }
 
 }  // namespace views