aura-x11: Fix touch-calibration for multi-monitor setups.

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/Xfixes.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xrandr.h>
@@ skipping 33 matching lines @@
 namespace aura {
 
 namespace {
 
 // Standard Linux mouse buttons for going back and forward.
 const int kBackMouseButton = 8;
 const int kForwardMouseButton = 9;
 
 const int kAnimatedCursorFrameDelayMs = 25;
 
+// These are the same values that are used to calibrate touch events in
+// |CalibrateTouchCoordinates| (in ui/base/x/events_x.cc).
+// TODO(sad|skuhne): Remove the duplication of values (http://crbug.com/147605)
+const int kXRootWindowPaddingLeft = 40;
+const int kXRootWindowPaddingRight = 40;
+const int kXRootWindowPaddingBottom = 30;
+const int kXRootWindowPaddingTop = 0;
+
 const char kRootWindowHostLinuxKey[] = "__AURA_ROOT_WINDOW_HOST_LINUX__";
 
 const char* kAtomsToCache[] = {
   "WM_DELETE_WINDOW",
   "_NET_WM_PING",
   "_NET_WM_PID",
   "WM_S0",
   NULL
 };
 
@@ skipping 197 matching lines @@
       } else {
         // This isn't an event we want so free its cookie data.
         XFreeEventData(display, &next_event.xcookie);
       }
     }
     break;
   }
   return num_coalesed;
 }
 
+void SelectEventsForRootWindow() {
+  XIEventMask evmask;
+  unsigned char mask[XIMaskLen(XI_LASTEVENT)] = {};
+  memset(mask, 0, sizeof(mask));
+
+  XISetMask(mask, XI_HierarchyChanged);
+
+  XISetMask(mask, XI_KeyPress);
+  XISetMask(mask, XI_KeyRelease);
+
+#if defined(USE_XI2_MT)
+  XISetMask(mask, XI_TouchBegin);
+  XISetMask(mask, XI_TouchUpdate);
+  XISetMask(mask, XI_TouchEnd);
+#endif
+  XISetMask(mask, XI_ButtonPress);
+  XISetMask(mask, XI_ButtonRelease);
+  XISetMask(mask, XI_Motion);
+
+  evmask.deviceid = XIAllDevices;
+  evmask.mask_len = sizeof(mask);
+  evmask.mask = mask;
+
+  Display* display = ui::GetXDisplay();
+  ::Window root_window = ui::GetX11RootWindow();
+  XISelectEvents(display, root_window, &evmask, 1);
+
+  // Receive resize events for the root-window so |x_root_bounds_| can be
+  // updated.
+  XSelectInput(display, root_window, StructureNotifyMask);
+}
+
 // We emulate Windows' WM_KEYDOWN and WM_CHAR messages.  WM_CHAR events are only
 // generated for certain keys; see
 // http://msdn.microsoft.com/en-us/library/windows/desktop/ms646268.aspx.  Per
 // discussion on http://crbug.com/108480, char events should furthermore not be
 // generated for Tab, Escape, and Backspace.
 bool ShouldSendCharEventForKeyboardCode(ui::KeyboardCode keycode) {
   if ((keycode >= ui::VKEY_0 && keycode <= ui::VKEY_9) ||
       (keycode >= ui::VKEY_A && keycode <= ui::VKEY_Z) ||
       (keycode >= ui::VKEY_NUMPAD0 && keycode <= ui::VKEY_NUMPAD9)) {
     return true;
@@ skipping 243 matching lines @@
   xwindow_ = XCreateWindow(
       xdisplay_, x_root_window_,
       bounds.x(), bounds.y(), bounds.width(), bounds.height(),
       0,               // border width
       CopyFromParent,  // depth
       InputOutput,
       CopyFromParent,  // visual
       CWBackPixmap,
       &swa);
   base::MessagePumpAuraX11::Current()->AddDispatcherForWindow(this, xwindow_);
+  base::MessagePumpAuraX11::Current()->AddDispatcherForRootWindow(this);
 
   prop_.reset(new ui::ViewProp(xwindow_, kRootWindowHostLinuxKey, 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_);
 
+  SelectEventsForRootWindow();
+
+  // Get the initial size of the X root window.
+  XWindowAttributes attrs;
+  XGetWindowAttributes(xdisplay_, x_root_window_, &attrs);
+  x_root_bounds_.SetRect(attrs.x, attrs.y, attrs.width, attrs.height);
+
   // 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);
   XFreePixmap(xdisplay_, blank);
 
@@ skipping 27 matching lines @@
   // window to broadcast.
   // TODO(jhorwich) Remove this once Chrome supports window-based broadcasting.
   static int root_window_number = 0;
   std::string name = StringPrintf("aura_root_%d", root_window_number++);
   XStoreName(xdisplay_, xwindow_, name.c_str());
   XRRSelectInput(xdisplay_, x_root_window_,
                  RRScreenChangeNotifyMask | RROutputChangeNotifyMask);
 }
 
 RootWindowHostLinux::~RootWindowHostLinux() {
+  base::MessagePumpAuraX11::Current()->RemoveDispatcherForRootWindow(this);
   base::MessagePumpAuraX11::Current()->RemoveDispatcherForWindow(xwindow_);
 
   UnConfineCursor();
 
   XDestroyWindow(xdisplay_, xwindow_);
 
   // Clears XCursorCache.
   ui::GetXCursor(ui::kCursorClearXCursorCache);
 
   XFreeCursor(xdisplay_, invisible_cursor_);
@@ skipping 35 matching lines @@
     case ButtonRelease: {
       ui::MouseEvent mouseev(xev);
       delegate_->OnHostMouseEvent(&mouseev);
       break;
     }
     case FocusOut:
       if (xev->xfocus.mode != NotifyGrab)
         delegate_->OnHostLostCapture();
       break;
     case ConfigureNotify: {
-      DCHECK_EQ(xwindow_, xev->xconfigure.window);
-      DCHECK_EQ(xwindow_, xev->xconfigure.event);
-      // 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();
-      bool origin_changed = bounds_.origin() != bounds.origin();
-      bounds_ = bounds;
-      // Update barrier and mouse location when the root window has
-      // moved/resized.
-      if (pointer_barriers_.get() && (size_changed || origin_changed)) {
-        UnConfineCursor();
-        RootWindow* root = delegate_->AsRootWindow();
-        client::ScreenPositionClient* client =
+      if (xev->xconfigure.window == xwindow_) {
+        DCHECK_EQ(xwindow_, xev->xconfigure.event);
+        // 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();
+        bool origin_changed = bounds_.origin() != bounds.origin();
+        bounds_ = bounds;
+        // Update barrier and mouse location when the root window has
+        // moved/resized.
+        if (pointer_barriers_.get() && (size_changed || origin_changed)) {
+          UnConfineCursor();
+          RootWindow* root = delegate_->AsRootWindow();
+          client::ScreenPositionClient* client =
             client::GetScreenPositionClient(root);
-        if (client) {
-          gfx::Point p = gfx::Screen::GetCursorScreenPoint();
-          client->ConvertPointFromScreen(root, &p);
-          if (root->ContainsPoint(p)) {
-            root->ConvertPointToNativeScreen(&p);
-            XWarpPointer(
-                xdisplay_, None, x_root_window_, 0, 0, 0, 0, p.x(), p.y());
+          if (client) {
+            gfx::Point p = gfx::Screen::GetCursorScreenPoint();
+            client->ConvertPointFromScreen(root, &p);
+            if (root->ContainsPoint(p)) {
+              root->ConvertPointToNativeScreen(&p);
+              XWarpPointer(
+                  xdisplay_, None, x_root_window_, 0, 0, 0, 0, p.x(), p.y());
+            }
           }
+          ConfineCursorToRootWindow();
         }
-        ConfineCursorToRootWindow();
+        if (size_changed)
+          delegate_->OnHostResized(bounds.size());
+        if (origin_changed)
+          delegate_->OnHostMoved(bounds_.origin());
+      } else {
+        DCHECK_EQ(x_root_window_, xev->xconfigure.event);
+        DCHECK_EQ(x_root_window_, xev->xconfigure.window);
+        x_root_bounds_.SetRect(xev->xconfigure.x, xev->xconfigure.y,
+            xev->xconfigure.width, xev->xconfigure.height);
       }
-      if (size_changed)
-        delegate_->OnHostResized(bounds.size());
-      if (origin_changed)
-        delegate_->OnHostMoved(bounds_.origin());
       break;
     }
     case GenericEvent: {
       ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
       if (!factory->ShouldProcessXI2Event(xev))
         break;
 
       ui::EventType type = ui::EventTypeFromNative(xev);
       XEvent last_event;
       int num_coalesced = 0;
 
       switch (type) {
         case ui::ET_TOUCH_MOVED:
           num_coalesced = CoalescePendingMotionEvents(xev, &last_event);
           if (num_coalesced > 0)
             xev = &last_event;
           // fallthrough
         case ui::ET_TOUCH_PRESSED:
         case ui::ET_TOUCH_RELEASED: {
           ui::TouchEvent touchev(xev);
+          // X maps the touch-surface to the size of the X root-window. In
+          // multi-monitor setup, the X root-window size is a combination of
+          // both the monitor sizes. So it is necessary to remap the location of
+          // the event from the X root-window to the X host-window for the aura
+          // root-window.
+          touchev.CalibrateLocation(x_root_bounds_.size(), bounds_.size());
+          if (!bounds_.Contains(touchev.location())) {
+            // This might still be in the bezel region.
+            gfx::Rect expanded(bounds_);
+            expanded.Inset(-kXRootWindowPaddingLeft,
+                           -kXRootWindowPaddingTop,
+                           -kXRootWindowPaddingRight,
+                           -kXRootWindowPaddingBottom);
+            if (!expanded.Contains(touchev.location()))
+              break;
+          }
           delegate_->OnHostTouchEvent(&touchev);
           break;
         }
         case ui::ET_MOUSE_MOVED:
         case ui::ET_MOUSE_DRAGGED:
         case ui::ET_MOUSE_PRESSED:
         case ui::ET_MOUSE_RELEASED:
         case ui::ET_MOUSE_ENTERED:
         case ui::ET_MOUSE_EXITED: {
           if (type == ui::ET_MOUSE_MOVED || type == ui::ET_MOUSE_DRAGGED) {
@@ skipping 423 matching lines @@
       ui::ViewProp::GetValue(accelerated_widget, kRootWindowHostLinuxKey));
 }
 
 // static
 gfx::Size RootWindowHost::GetNativeScreenSize() {
   ::Display* xdisplay = base::MessagePumpAuraX11::GetDefaultXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 }  // namespace aura