Use XInput2 events for keyboard events.

ui/events/x/events_x.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/events/event_constants.h"
 
 #include <cmath>
 #include <string.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
+#include <X11/XKBlib.h>
 
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #include "ui/events/x/device_data_manager_x11.h"
 #include "ui/events/x/device_list_cache_x.h"
 #include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/point.h"
@@ skipping 12 matching lines @@
 
 // A class to track current modifier state on master device. Only track ctrl,
 // alt, shift and caps lock keys currently. The tracked state can then be used
 // by floating device.
 class XModifierStateWatcher{
  public:
   static XModifierStateWatcher* GetInstance() {
     return Singleton<XModifierStateWatcher>::get();
   }
 
-  void UpdateStateFromEvent(const base::NativeEvent& native_event) {
+  int StateFromKeyboardCode(ui::KeyboardCode keyboard_code) {
+    switch (keyboard_code) {
+      case ui::VKEY_CONTROL:
+        return ControlMask;
+      case ui::VKEY_SHIFT:
+        return ShiftMask;
+      case ui::VKEY_MENU:
+        return Mod1Mask;
+      case ui::VKEY_CAPITAL:
+        return LockMask;
+      default:
+        return 0;
+    }
+  }
+
+  void UpdateStateFromXKeyEvent(const base::NativeEvent& native_event) {
+    DCHECK((native_event->type == KeyPress) ||
+           (native_event->type == KeyRelease));

[sadrul, 2014/06/26 12:34:20]

I suspect this will need to change once you make the changes in
window-tree-host-x11.

[kpschoedel, 2014/06/26 17:24:10]

XI2 handling uses UpdateStateFromXGenericEvent; this one is specifically for
|XKeyEvent|.

     // Floating device can't access the modifer state from master device.
     // We need to track the states of modifier keys in a singleton for
     // floating devices such as touch screen. Issue 106426 is one example
     // of why we need the modifier states for floating device.
     state_ = native_event->xkey.state;
     // master_state is the state before key press. We need to track the
     // state after key press for floating device. Currently only ctrl,
     // shift, alt and caps lock keys are tracked.
     ui::KeyboardCode keyboard_code = ui::KeyboardCodeFromNative(native_event);
-    unsigned int mask = 0;
+    unsigned int mask = StateFromKeyboardCode(keyboard_code);
+    if (native_event->type == KeyPress)
+      state_ |= mask;
+    else
+      state_ &= ~mask;
+  }
 
-    switch (keyboard_code) {
-      case ui::VKEY_CONTROL: {
-        mask = ControlMask;
-        break;
-      }
-      case ui::VKEY_SHIFT: {
-        mask = ShiftMask;
-        break;
-      }
-      case ui::VKEY_MENU: {
-        mask = Mod1Mask;
-        break;
-      }
-      case ui::VKEY_CAPITAL: {
-        mask = LockMask;
-        break;
-      }
-      default:
-        break;
-    }
-
-    if (native_event->type == KeyPress)
+  void UpdateStateFromXGenericEvent(const base::NativeEvent& native_event) {
+    DCHECK(native_event->type == GenericEvent);
+    XIDeviceEvent* xievent =
+        static_cast<XIDeviceEvent*>(native_event->xcookie.data);
+    DCHECK((xievent->evtype == XI_KeyPress) ||
+           (xievent->evtype == XI_KeyRelease));
+    // Floating device can't access the modifer state from master device.
+    // We need to track the states of modifier keys in a singleton for
+    // floating devices such as touch screen. Issue 106426 is one example
+    // of why we need the modifier states for floating device.
+    state_ = xievent->mods.effective;
+    // master_state is the state before key press. We need to track the
+    // state after key press for floating device. Currently only ctrl,
+    // shift, alt and caps lock keys are tracked.
+    ui::KeyboardCode keyboard_code = ui::KeyboardCodeFromNative(native_event);
+    unsigned int mask = StateFromKeyboardCode(keyboard_code);
+    if (native_event->type == XI_KeyPress)
       state_ |= mask;
     else
       state_ &= ~mask;
   }
 
   // Returns the current modifer state in master device. It only contains the
   // state of ctrl, shift, alt and caps lock keys.
   unsigned int state() { return state_; }
 
  private:
@@ skipping 86 matching lines @@
       fabricated_by_xim ? ui::EF_IME_FABRICATED_KEY : 0;
 #endif
 
   return GetEventFlagsFromXState(xevent->xkey.state) |
       (IsKeypadKey(XLookupKeysym(&xevent->xkey, 0)) ? ui::EF_NUMPAD_KEY : 0) |
       (IsFunctionKey(XLookupKeysym(&xevent->xkey, 0)) ?
           ui::EF_FUNCTION_KEY : 0) |
       ime_fabricated_flag;
 }
 
+int GetEventFlagsFromXGenericEvent(XEvent* xevent) {
+  DCHECK(xevent->type == GenericEvent);
+  XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xevent->xcookie.data);
+  DCHECK((xievent->evtype == XI_KeyPress) ||
+         (xievent->evtype == XI_KeyRelease));
+  return GetEventFlagsFromXState(xievent->mods.effective) |
+         (IsKeypadKey(
+              XkbKeycodeToKeysym(xievent->display, xievent->detail, 0, 0))
+              ? ui::EF_NUMPAD_KEY
+              : 0);
+}
+
 // Get the event flag for the button in XButtonEvent. During a ButtonPress
 // event, |state| in XButtonEvent does not include the button that has just been
 // pressed. Instead |state| contains flags for the buttons (if any) that had
 // already been pressed before the current button, and |button| stores the most
 // current pressed button. So, if you press down left mouse button, and while
 // pressing it down, press down the right mouse button, then for the latter
 // event, |state| would have Button1Mask set but not Button3Mask, and |button|
 // would be 3.
 int GetEventFlagsForButton(int button) {
   switch (button) {
@@ skipping 147 matching lines @@
             return IsTouchpadEvent(native_event) ? ET_SCROLL : ET_MOUSEWHEEL;
           } else if (DeviceDataManagerX11::GetInstance()->IsCMTMetricsEvent(
               native_event)) {
             return ET_UMA_DATA;
           } else if (GetButtonMaskForX2Event(xievent)) {
             return ET_MOUSE_DRAGGED;
           } else {
             return ET_MOUSE_MOVED;
           }
         }
+        case XI_KeyPress:
+          return ET_KEY_PRESSED;
+        case XI_KeyRelease:
+          return ET_KEY_RELEASED;
       }
     }
     default:
       break;
   }
   return ET_UNKNOWN;
 }
 
 int EventFlagsFromNative(const base::NativeEvent& native_event) {
   switch (native_event->type) {
     case KeyPress:
     case KeyRelease: {
-      XModifierStateWatcher::GetInstance()->UpdateStateFromEvent(native_event);
+      XModifierStateWatcher::GetInstance()->UpdateStateFromXKeyEvent(
+          native_event);
       return GetEventFlagsFromXKeyEvent(native_event);
     }
     case ButtonPress:
     case ButtonRelease: {
       int flags = GetEventFlagsFromXState(native_event->xbutton.state);
       const EventType type = EventTypeFromNative(native_event);
       if (type == ET_MOUSE_PRESSED || type == ET_MOUSE_RELEASED)
         flags |= GetEventFlagsForButton(native_event->xbutton.button);
       return flags;
     }
@@ skipping 15 matching lines @@
                  GetEventFlagsFromXState(xievent->mods.effective) |
                  GetEventFlagsFromXState(
                      XModifierStateWatcher::GetInstance()->state());
           break;
 #endif
         case XI_ButtonPress:
         case XI_ButtonRelease: {
           const bool touch =
               TouchFactory::GetInstance()->IsTouchDevice(xievent->sourceid);
           int flags = GetButtonMaskForX2Event(xievent) |
-              GetEventFlagsFromXState(xievent->mods.effective);
+                      GetEventFlagsFromXState(xievent->mods.effective);
           if (touch) {
             flags |= GetEventFlagsFromXState(
                 XModifierStateWatcher::GetInstance()->state());
           }
 
           const EventType type = EventTypeFromNative(native_event);
           int button = EventButtonFromNative(native_event);
           if ((type == ET_MOUSE_PRESSED || type == ET_MOUSE_RELEASED) && !touch)
             flags |= GetEventFlagsForButton(button);
           return flags;
         }
         case XI_Motion:
-           return GetButtonMaskForX2Event(xievent) |
-                  GetEventFlagsFromXState(xievent->mods.effective);
+          return GetButtonMaskForX2Event(xievent) |
+                 GetEventFlagsFromXState(xievent->mods.effective);
+        case XI_KeyPress:
+        case XI_KeyRelease: {
+          XModifierStateWatcher::GetInstance()->UpdateStateFromXGenericEvent(
+              native_event);
+          return GetEventFlagsFromXGenericEvent(native_event);
+        }
       }
     }
   }
   return 0;
 }
 
 base::TimeDelta EventTimeFromNative(const base::NativeEvent& native_event) {
   switch(native_event->type) {
     case KeyPress:
     case KeyRelease:
@@ skipping 158 matching lines @@
     case 6:
       return gfx::Vector2d(kWheelScrollAmount, 0);
     case 7:
       return gfx::Vector2d(-kWheelScrollAmount, 0);
     default:
       return gfx::Vector2d();
   }
 }
 
 base::NativeEvent CopyNativeEvent(const base::NativeEvent& event) {
-  if (!event || event->type == GenericEvent)
+  if (!event)
     return NULL;
   XEvent* copy = new XEvent;
   *copy = *event;
+  if (event->type == GenericEvent) {
+    XIDeviceEvent* xievent_copy = new XIDeviceEvent;
+    *xievent_copy = *static_cast<XIDeviceEvent*>(event->xcookie.data);
+    copy->xcookie.data = xievent_copy;
+  }
   return copy;
 }
 
 void ReleaseCopiedNativeEvent(const base::NativeEvent& event) {
+  if (event && event->type == GenericEvent)
+    delete static_cast<XIDeviceEvent*>(event->xcookie.data);
   delete event;
 }
 
 void ClearTouchIdIfReleased(const base::NativeEvent& xev) {
   ui::EventType type = ui::EventTypeFromNative(xev);
   if (type == ui::ET_TOUCH_CANCELLED ||
       type == ui::ET_TOUCH_RELEASED) {
     ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
     ui::DeviceDataManagerX11* manager = ui::DeviceDataManagerX11::GetInstance();
     double tracking_id;
@@ skipping 121 matching lines @@
   DeviceDataManagerX11::GetInstance()->GetGestureTimes(
       native_event, start_time, end_time);
   return true;
 }
 
 bool IsTouchpadEvent(const base::NativeEvent& event) {
   return DeviceDataManagerX11::GetInstance()->IsTouchpadXInputEvent(event);
 }
 
 }  // namespace ui