Keep the mouse cursor within desktop

ui/aura/root_window_host_linux.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/aura/root_window_host_linux.h"
 
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput2.h>
+#include <X11/extensions/Xfixes.h>
 #include <X11/extensions/Xrandr.h>
 #include <algorithm>
 
 #include "base/message_pump_x.h"
 #include "base/stl_util.h"
 #include "ui/aura/cursor.h"
 #include "ui/aura/dispatcher_linux.h"
 #include "ui/aura/env.h"
 #include "ui/aura/event.h"
 #include "ui/aura/monitor.h"
-#include "ui/aura/monitor_change_observer_x11.h"
 #include "ui/aura/monitor_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/touch/touch_factory.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/compositor/layer.h"
 
 using std::max;
 using std::min;
 
@@ skipping 244 matching lines @@
 }  // namespace
 
 RootWindowHostLinux::RootWindowHostLinux(const gfx::Rect& bounds)
     : root_window_(NULL),
       xdisplay_(base::MessagePumpX::GetDefaultXDisplay()),
       xwindow_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       current_cursor_(aura::kCursorNull),
       cursor_shown_(true),
       bounds_(bounds),
-      focus_when_shown_(false) {
+      focus_when_shown_(false),
+      pointer_barriers_(NULL) {
   XSetWindowAttributes swa;
   memset(&swa, 0, sizeof(swa));
   swa.background_pixmap = None;
   xwindow_ = XCreateWindow(
       xdisplay_, x_root_window_,
       bounds_.x(), bounds_.y(), bounds_.width(), bounds_.height(),
       0,               // border width
       CopyFromParent,  // depth
       InputOutput,
       CopyFromParent,  // visual
       CWBackPixmap,
       &swa);
   static_cast<DispatcherLinux*>(Env::GetInstance()->GetDispatcher())->
-      RootWindowHostCreated(xwindow_, x_root_window_, this);
+      WindowDispatcherCreated(xwindow_, this);
 
   long event_mask = ButtonPressMask | ButtonReleaseMask | FocusChangeMask |
                     KeyPressMask | KeyReleaseMask |
                     EnterWindowMask | LeaveWindowMask |
                     ExposureMask | VisibilityChangeMask |
                     StructureNotifyMask | PropertyChangeMask |
                     PointerMotionMask;
   XSelectInput(xdisplay_, xwindow_, event_mask);
   XFlush(xdisplay_);
 
   if (base::MessagePumpForUI::HasXInput2())
     ui::TouchFactory::GetInstance()->SetupXI2ForXWindow(xwindow_);
 
   // Initialize invisible cursor.
   char nodata[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
   XColor black;
   black.red = black.green = black.blue = 0;
   Pixmap blank = XCreateBitmapFromData(xdisplay_, xwindow_,
                                        nodata, 8, 8);
   invisible_cursor_ = XCreatePixmapCursor(xdisplay_, blank, blank,
                                           &black, &black, 0, 0);
   if (RootWindow::hide_host_cursor())
     XDefineCursor(xdisplay_, x_root_window_, invisible_cursor_);
 }
 
 RootWindowHostLinux::~RootWindowHostLinux() {
   static_cast<DispatcherLinux*>(Env::GetInstance()->GetDispatcher())->
-      RootWindowHostDestroying(xwindow_, x_root_window_);
+      WindowDispatcherDestroying(xwindow_);
+
+  UnConfineCursor();
+
   XDestroyWindow(xdisplay_, xwindow_);
 
   // Clears XCursorCache.
   ui::GetXCursor(ui::kCursorClearXCursorCache);
 
   XFreeCursor(xdisplay_, invisible_cursor_);
 }
 
 base::MessagePumpDispatcher::DispatchStatus RootWindowHostLinux::Dispatch(
     XEvent* xev) {
@@ skipping 23 matching lines @@
       handled = root_window_->DispatchMouseEvent(&mouseev);
       break;
     }
     case FocusOut:
       if (xev->xfocus.mode != NotifyGrab)
         root_window_->SetCapture(NULL);
       break;
     case ConfigureNotify: {
       DCHECK_EQ(xwindow_, xev->xconfigure.window);
       DCHECK_EQ(xwindow_, xev->xconfigure.event);
-
+      // Update barrier and mouse location when the root window has
+      // moved/resized.
+      if (pointer_barriers_.get()) {
+        UnConfineCursor();
+        gfx::Point p = root_window_->last_mouse_location();
+        XWarpPointer(xdisplay_, None,  xwindow_, 0, 0, 0, 0, p.x(), p.y());
+        ConfineCursorToRootWindow();
+      }
       // It's possible that the X window may be resized by some other means than
       // from within aura (e.g. the X window manager can change the size). Make
       // sure the root window size is maintained properly.
       gfx::Rect bounds(xev->xconfigure.x, xev->xconfigure.y,
                        xev->xconfigure.width, xev->xconfigure.height);
       bool size_changed = bounds_.size() != bounds.size();
       bounds_ = bounds;
       if (size_changed)
         root_window_->OnHostResized(bounds.size());
       handled = true;
@@ skipping 92 matching lines @@
           xev = &last_event;
         } else {
           break;
         }
       }
 
       MouseEvent mouseev(xev);
       handled = root_window_->DispatchMouseEvent(&mouseev);
       break;
     }
-    default: {
-      // TODO(oshima): We probably should change DispatcherLinux so
-      // that it can directly dispatch the event to montor change
-      // observer.
-      Env::GetInstance()->monitor_change_observer()->Dispatch(xev);
-    }
   }
   return handled ? base::MessagePumpDispatcher::EVENT_PROCESSED :
       base::MessagePumpDispatcher::EVENT_IGNORED;
 }
 
 void RootWindowHostLinux::SetRootWindow(RootWindow* root_window) {
   root_window_ = root_window;
 }
 
 gfx::AcceleratedWidget RootWindowHostLinux::GetAcceleratedWidget() {
@@ skipping 72 matching lines @@
                 &root_return,
                 &child_return,
                 &root_x_return, &root_y_return,
                 &win_x_return, &win_y_return,
                 &mask_return);
   return gfx::Point(max(0, min(bounds_.width(), win_x_return)),
                     max(0, min(bounds_.height(), win_y_return)));
 }
 
 bool RootWindowHostLinux::ConfineCursorToRootWindow() {
-  return XGrabPointer(xdisplay_,
-                      xwindow_,  // grab_window
-                      False,  // owner_events
-                      ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
-                      GrabModeAsync,
-                      GrabModeAsync,
-                      xwindow_,  // confine_to
-                      None,  // cursor
-                      CurrentTime) == GrabSuccess;
+#if XFIXES_MAJOR >= 5
+  DCHECK(!pointer_barriers_.get());
+  if (pointer_barriers_.get())
+    return false;
+  // Monitors are vertically laid out, so just create barriers at the top and
+  // the bottom.
+  pointer_barriers_.reset(new XID[2]);
+  pointer_barriers_[0] = XFixesCreatePointerBarrier(
+      xdisplay_, xwindow_,
+      0, 0, bounds_.width(), 0,  // barrier line
+      BarrierPositiveY,
+      0, NULL);  // defult device
+  pointer_barriers_[1] = XFixesCreatePointerBarrier(
+      xdisplay_, xwindow_,
+      0, bounds_.height(), bounds_.width(),  bounds_.height(),  // barrier line
+      BarrierNegativeY,
+      0, NULL);  // defult device
+#endif
+  return true;
 }
 
 void RootWindowHostLinux::UnConfineCursor() {
-  XUngrabPointer(xdisplay_, CurrentTime);
+#if XFIXES_MAJOR >= 5
+  if (pointer_barriers_.get()) {
+    XFixesDestroyPointerBarrier(xdisplay_, pointer_barriers_[0]);
+    XFixesDestroyPointerBarrier(xdisplay_, pointer_barriers_[1]);
+    pointer_barriers_.reset();
+  }
+#endif
 }
 
 void RootWindowHostLinux::MoveCursorTo(const gfx::Point& location) {
   XWarpPointer(xdisplay_, None, xwindow_, 0, 0, 0, 0, location.x(),
       location.y());
 }
 
 void RootWindowHostLinux::SetFocusWhenShown(bool focus_when_shown) {
   static const char* k_NET_WM_USER_TIME = "_NET_WM_USER_TIME";
   focus_when_shown_ = focus_when_shown;
@@ skipping 58 matching lines @@
   return new RootWindowHostLinux(bounds);
 }
 
 // static
 gfx::Size RootWindowHost::GetNativeScreenSize() {
   ::Display* xdisplay = base::MessagePumpX::GetDefaultXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 }  // namespace aura