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 UpdateStateFromXEvent(const base::NativeEvent& native_event) {
+    ui::KeyboardCode keyboard_code = ui::KeyboardCodeFromNative(native_event);
+    unsigned int mask = StateFromKeyboardCode(keyboard_code);
     // 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;
-
-    switch (keyboard_code) {
-      case ui::VKEY_CONTROL: {
-        mask = ControlMask;
+    switch (native_event->type) {
+      case KeyPress:
+        state_ = native_event->xkey.state | mask;
         break;
-      }
-      case ui::VKEY_SHIFT: {
-        mask = ShiftMask;
+      case KeyRelease:
+        state_ = native_event->xkey.state & ~mask;
         break;
-      }
-      case ui::VKEY_MENU: {
-        mask = Mod1Mask;
-        break;
-      }
-      case ui::VKEY_CAPITAL: {
-        mask = LockMask;
+      case GenericEvent: {
+        XIDeviceEvent* xievent =
+            static_cast<XIDeviceEvent*>(native_event->xcookie.data);
+        switch (xievent->evtype) {
+          case XI_KeyPress:
+            state_ = xievent->mods.effective |= mask;
+            break;
+          case XI_KeyRelease:
+            state_ = xievent->mods.effective &= ~mask;
+            break;
+          default:
+            NOTREACHED();
+            break;
+        }
         break;
       }
       default:
+        NOTREACHED();
         break;
     }
-
-    if (native_event->type == 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:
   friend struct DefaultSingletonTraits<XModifierStateWatcher>;
 
   XModifierStateWatcher() : state_(0) { }
@@ skipping 83 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 152 matching lines @@
           if (GetFlingData(native_event, NULL, NULL, NULL, NULL, &is_cancel)) {
             return is_cancel ? ET_SCROLL_FLING_CANCEL : ET_SCROLL_FLING_START;
           } else if (DeviceDataManagerX11::GetInstance()->IsScrollEvent(
               native_event)) {
             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;
           }
+          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()->UpdateStateFromXEvent(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()->UpdateStateFromXEvent(
+              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 307 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