aura: Turn XInput2 back on.

ui/aura/desktop_host_linux.cc

 // Copyright (c) 2011 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/desktop_host.h"
 
 #include <X11/cursorfont.h>
 #include <X11/Xlib.h>
 
 // Get rid of a macro from Xlib.h that conflicts with Aura's RootWindow class.
@@ skipping 15 matching lines @@
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 
 using std::max;
 using std::min;
 
 namespace aura {
 
 namespace {
 
+// The events reported for slave devices can have incorrect information for some
+// fields. This utility function is used to check for such inconsistencies.
+void CheckXEventForConsistency(XEvent* xevent) {
+  static bool expect_master_event = false;
+  static XIDeviceEvent slave_event;
+  static gfx::Point slave_location;
+
+  // Note: If an event comes from a slave pointer device, then it will be
+  // followed by the same event, but reported from its master pointer device.
+  // However, if the event comes from a floating slave device (e.g. a
+  // touchscreen), then it will not be followed by a duplicate event, since the
+  // floating slave isn't attached to a master.
+
+  bool was_expecting_master_event = expect_master_event;
+  expect_master_event = false;
+
+  if (!xevent || xevent->type != GenericEvent)
+    return;
+
+  XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xevent->xcookie.data);
+  if (xievent->evtype != XI_Motion &&
+      xievent->evtype != XI_ButtonPress &&
+      xievent->evtype != XI_ButtonRelease) {
+    return;
+  }
+
+  if (xievent->sourceid == xievent->deviceid) {
+    slave_event = *xievent;
+    slave_location = ui::EventLocationFromNative(xevent);
+    expect_master_event = true;
+  } else if (was_expecting_master_event) {
+    CHECK_EQ(slave_location.x(), ui::EventLocationFromNative(xevent).x());
+    CHECK_EQ(slave_location.y(), ui::EventLocationFromNative(xevent).y());
+
+    CHECK_EQ(slave_event.type, xievent->type);
+    CHECK_EQ(slave_event.evtype, xievent->evtype);
+    CHECK_EQ(slave_event.detail, xievent->detail);
+    CHECK_EQ(slave_event.flags, xievent->flags);
+    CHECK_EQ(slave_event.buttons.mask_len, xievent->buttons.mask_len);
+    CHECK_EQ(slave_event.valuators.mask_len, xievent->valuators.mask_len);
+    CHECK_EQ(slave_event.mods.base, xievent->mods.base);
+    CHECK_EQ(slave_event.mods.latched, xievent->mods.latched);
+    CHECK_EQ(slave_event.mods.locked, xievent->mods.locked);
+    CHECK_EQ(slave_event.mods.effective, xievent->mods.effective);
+  }
+}
+
 // Returns X font cursor shape from an Aura cursor.
 int CursorShapeFromNative(gfx::NativeCursor native_cursor) {
   switch (native_cursor) {
     case aura::kCursorNull:
       return XC_left_ptr;
     case aura::kCursorPointer:
       return XC_left_ptr;
     case aura::kCursorCross:
       return XC_crosshair;
     case aura::kCursorHand:
@@ skipping 88 matching lines @@
 
     // If we can't get the cookie, abort the check.
     if (!XGetEventData(next_event.xgeneric.display, &next_event.xcookie))
       return num_coalesed;
 
     // If this isn't from a valid device, throw the event away, as
     // that's what the message pump would do. Device events come in pairs
     // with one from the master and one from the slave so there will
     // always be at least one pending.
     if (!ui::TouchFactory::GetInstance()->ShouldProcessXI2Event(&next_event)) {
+      CheckXEventForConsistency(&next_event);
       XFreeEventData(display, &next_event.xcookie);
       XNextEvent(display, &next_event);
       continue;
     }
 
     if (next_event.type == GenericEvent &&
         next_event.xgeneric.evtype == XI_Motion) {
       XIDeviceEvent* next_xievent =
           static_cast<XIDeviceEvent*>(next_event.xcookie.data);
       // Confirm that the motion event is targeted at the same window
       // and that no buttons or modifiers have changed.
       if (xievent->event == next_xievent->event &&
           xievent->child == next_xievent->child &&
           xievent->buttons.mask_len == next_xievent->buttons.mask_len &&
           (memcmp(xievent->buttons.mask,
                   next_xievent->buttons.mask,
                   xievent->buttons.mask_len) == 0) &&
           xievent->mods.base == next_xievent->mods.base &&
           xievent->mods.latched == next_xievent->mods.latched &&
           xievent->mods.locked == next_xievent->mods.locked &&
           xievent->mods.effective == next_xievent->mods.effective) {
         XFreeEventData(display, &next_event.xcookie);
         // Free the previous cookie.
         if (num_coalesed > 0)
           XFreeEventData(display, &last_event->xcookie);
         // Get the event and its cookie data.
         XNextEvent(display, last_event);
         XGetEventData(display, &last_event->xcookie);
+        CheckXEventForConsistency(last_event);
         ++num_coalesed;
         continue;
       } else {
         // This isn't an event we want so free its cookie data.
         XFreeEventData(display, &next_event.xcookie);
       }
     }
     break;
   }
   return num_coalesed;
@@ skipping 91 matching lines @@
       root_window_(DefaultRootWindow(xdisplay_)),
       current_cursor_(aura::kCursorNull),
       bounds_(bounds) {
   xwindow_ = XCreateSimpleWindow(xdisplay_, root_window_,
                                  bounds.x(), bounds.y(),
                                  bounds.width(), bounds.height(),
                                  0, 0, 0);
 
   long event_mask = ButtonPressMask | ButtonReleaseMask |
                     KeyPressMask | KeyReleaseMask |
+                    EnterWindowMask | LeaveWindowMask |
                     ExposureMask | VisibilityChangeMask |
                     StructureNotifyMask | PropertyChangeMask |
                     PointerMotionMask;
   XSelectInput(xdisplay_, xwindow_, event_mask);
   XSelectInput(xdisplay_, root_window_, StructureNotifyMask);
   XFlush(xdisplay_);
 
-  // TODO(sadrul): reenable once 103981 is fixed.
-#if defined(TOUCH_UI)
   if (base::MessagePumpForUI::HasXInput2())
     ui::TouchFactory::GetInstance()->SetupXI2ForXWindow(xwindow_);
-#endif
 }
 
 DesktopHostLinux::~DesktopHostLinux() {
   XDestroyWindow(xdisplay_, xwindow_);
 
   // Clears XCursorCache.
   ui::GetXCursor(ui::kCursorClearXCursorCache);
 }
 
 base::MessagePumpDispatcher::DispatchStatus DesktopHostLinux::Dispatch(
     XEvent* xev) {
   DLOG(WARNING) << "DispatchEvent:" << xev->type;
 
   bool handled = false;
+
+  CheckXEventForConsistency(xev);
+
   switch (xev->type) {
     case Expose:
       desktop_->Draw();
       handled = true;
       break;
     case KeyPress: {
       KeyEvent keydown_event(xev, false);
       handled = desktop_->DispatchKeyEvent(&keydown_event);
       if (ShouldSendCharEventForKeyboardCode(keydown_event.key_code())) {
         KeyEvent char_event(xev, true);
@@ skipping 229 matching lines @@
   return new DesktopHostLinux(bounds);
 }
 
 // static
 gfx::Size DesktopHost::GetNativeScreenSize() {
   ::Display* xdisplay = base::MessagePumpX::GetDefaultXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 }  // namespace aura