Use XInput2 events for keyboard events.

ui/events/event.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.h"
 
 #if defined(USE_X11)
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 #endif
@@ skipping 129 matching lines @@
 
 Event::Event(EventType type, base::TimeDelta time_stamp, int flags)
     : type_(type),
       time_stamp_(time_stamp),
       flags_(flags),
       native_event_(base::NativeEvent()),
       delete_native_event_(false),
       cancelable_(true),
       target_(NULL),
       phase_(EP_PREDISPATCH),
-      result_(ER_UNHANDLED) {
+      result_(ER_UNHANDLED),
+      source_device_id_(ED_UNKNOWN_DEVICE) {
   if (type_ < ET_LAST)
     name_ = EventTypeName(type_);
 }
 
 Event::Event(const base::NativeEvent& native_event,
              EventType type,
              int flags)
     : type_(type),
       time_stamp_(EventTimeFromNative(native_event)),
       flags_(flags),
       native_event_(native_event),
       delete_native_event_(false),
       cancelable_(true),
       target_(NULL),
       phase_(EP_PREDISPATCH),
-      result_(ER_UNHANDLED) {
+      result_(ER_UNHANDLED),
+      source_device_id_(ED_UNKNOWN_DEVICE) {
   base::TimeDelta delta = EventTimeForNow() - time_stamp_;
   if (type_ < ET_LAST)
     name_ = EventTypeName(type_);
   UMA_HISTOGRAM_CUSTOM_COUNTS("Event.Latency.Browser",
                               delta.InMicroseconds(), 1, 1000000, 100);
   std::string name_for_event =
       base::StringPrintf("Event.Latency.Browser.%s", name_.c_str());
   base::HistogramBase* counter_for_type =
       base::Histogram::FactoryGet(
           name_for_event,
           1,
           1000000,
           100,
           base::HistogramBase::kUmaTargetedHistogramFlag);
   counter_for_type->Add(delta.InMicroseconds());
+
+#if defined(USE_X11)
+  if (native_event->type == GenericEvent) {
+    XIDeviceEvent* xiev =
+        static_cast<XIDeviceEvent*>(native_event->xcookie.data);
+    source_device_id_ = xiev->deviceid;
+  }
+#endif
 }
 
 Event::Event(const Event& copy)
     : type_(copy.type_),
       time_stamp_(copy.time_stamp_),
       latency_(copy.latency_),
       flags_(copy.flags_),
       native_event_(CopyNativeEvent(copy.native_event_)),
       delete_native_event_(true),
       cancelable_(true),
       target_(NULL),
       phase_(EP_PREDISPATCH),
-      result_(ER_UNHANDLED) {
+      result_(ER_UNHANDLED),
+      source_device_id_(copy.source_device_id_) {
   if (type_ < ET_LAST)
     name_ = EventTypeName(type_);
 }
 
 void Event::SetType(EventType type) {
   if (type_ < ET_LAST)
     name_ = std::string();
   type_ = type;
   if (type_ < ET_LAST)
     name_ = EventTypeName(type_);
@@ skipping 216 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // TouchEvent
 
 TouchEvent::TouchEvent(const base::NativeEvent& native_event)
     : LocatedEvent(native_event),
       touch_id_(GetTouchId(native_event)),
       radius_x_(GetTouchRadiusX(native_event)),
       radius_y_(GetTouchRadiusY(native_event)),
       rotation_angle_(GetTouchAngle(native_event)),
-      force_(GetTouchForce(native_event)),
-      source_device_id_(-1) {
+      force_(GetTouchForce(native_event)) {
   latency()->AddLatencyNumberWithTimestamp(
       INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT,
       0,
       0,
       base::TimeTicks::FromInternalValue(time_stamp().ToInternalValue()),
       1);
 
-#if defined(USE_X11)
-  XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(native_event->xcookie.data);
-  source_device_id_ = xiev->deviceid;
-#endif
-
   latency()->AddLatencyNumber(INPUT_EVENT_LATENCY_UI_COMPONENT, 0, 0);
 }
 
 TouchEvent::TouchEvent(EventType type,
                        const gfx::PointF& location,
                        int touch_id,
                        base::TimeDelta time_stamp)
     : LocatedEvent(type, location, location, time_stamp, 0),
       touch_id_(touch_id),
       radius_x_(0.0f),
       radius_y_(0.0f),
       rotation_angle_(0.0f),
-      force_(0.0f),
-      source_device_id_(-1) {
+      force_(0.0f) {
   latency()->AddLatencyNumber(INPUT_EVENT_LATENCY_UI_COMPONENT, 0, 0);
 }
 
 TouchEvent::TouchEvent(EventType type,
                        const gfx::PointF& location,
                        int flags,
                        int touch_id,
                        base::TimeDelta time_stamp,
                        float radius_x,
                        float radius_y,
                        float angle,
                        float force)
     : LocatedEvent(type, location, location, time_stamp, flags),
       touch_id_(touch_id),
       radius_x_(radius_x),
       radius_y_(radius_y),
       rotation_angle_(angle),
-      force_(force),
-      source_device_id_(-1) {
+      force_(force) {
   latency()->AddLatencyNumber(INPUT_EVENT_LATENCY_UI_COMPONENT, 0, 0);
 }
 
 TouchEvent::~TouchEvent() {
   // In ctor TouchEvent(native_event) we call GetTouchId() which in X11
   // platform setups the tracking_id to slot mapping. So in dtor here,
   // if this touch event is a release event, we clear the mapping accordingly.
   if (HasNativeEvent())
     ClearTouchIdIfReleased(native_event());
 }
@@ skipping 95 matching lines @@
     return character_;
 
 #if defined(OS_WIN)
   return (native_event().message == WM_CHAR) ? key_code_ :
       GetCharacterFromKeyCode(key_code_, flags());
 #elif defined(USE_X11)
   if (!native_event())
     return GetCharacterFromKeyCode(key_code_, flags());
 
   DCHECK(native_event()->type == KeyPress ||
-         native_event()->type == KeyRelease);
+         native_event()->type == KeyRelease ||
+         (native_event()->type == GenericEvent &&
+          (native_event()->xgeneric.evtype == XI_KeyPress ||
+           native_event()->xgeneric.evtype == XI_KeyRelease)));
 
   // When a control key is held, prefer ASCII characters to non ASCII
   // characters in order to use it for shortcut keys.  GetCharacterFromKeyCode
   // returns 'a' for VKEY_A even if the key is actually bound to 'à' in X11.
   // GetCharacterFromXEvent returns 'à' in that case.
   return IsControlDown() ?
       GetCharacterFromKeyCode(key_code_, flags()) :
       GetCharacterFromXEvent(native_event());
 #else
   if (native_event()) {
@@ skipping 151 matching lines @@
 int GestureEvent::GetLowestTouchId() const {
   if (touch_ids_bitfield_ == 0)
     return -1;
   int i = -1;
   // Find the index of the least significant 1 bit
   while (!(1 << ++i & touch_ids_bitfield_));
   return i;
 }
 
 }  // namespace ui