aura-x11: Add support for xmodmap'ed pointer buttons.

ui/aura/root_window_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/root_window_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 21 matching lines @@
 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;
+  static int slave_button;
 
   // 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);
+    slave_button = ui::EventButtonFromNative(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_button, ui::EventButtonFromNative(xevent));
     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);
   }
 }
 
@@ skipping 381 matching lines @@
     }
     case MapNotify: {
       // If there's no window manager running, we need to assign the X input
       // focus to our host window.
       if (!IsWindowManagerPresent())
         XSetInputFocus(xdisplay_, xwindow_, RevertToNone, CurrentTime);
       handled = true;
       break;
     }
     case MappingNotify: {
-      if (xev->xmapping.request == MappingModifier ||
-          xev->xmapping.request == MappingKeyboard)
-        XRefreshKeyboardMapping(&xev->xmapping);
+      switch (xev->xmapping.request) {
+        case MappingModifier:
+        case MappingKeyboard:
+          XRefreshKeyboardMapping(&xev->xmapping);
+          break;
+        case MappingPointer:
+          ui::UpdateButtonMap();
+          break;
+        default:
+          NOTIMPLEMENTED() << " Unknown request: " << xev->xmapping.request;
+          break;
+      }
       break;
     }
     case MotionNotify: {
       // Discard all but the most recent motion event that targets the same
       // window with unchanged state.
       XEvent last_event;
       while (XPending(xev->xany.display)) {
         XEvent next_event;
         XPeekEvent(xev->xany.display, &next_event);
         if (next_event.type == MotionNotify &&
@@ skipping 132 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