Ozone support for device special cases in keyboard event rewriting.

ui/events/platform/x11/x11_hotplug_event_handler.cc

 // Copyright 2014 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/platform/x11/x11_hotplug_event_handler.h"
 
 #include <X11/Xatom.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 
@@ skipping 14 matching lines @@
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "ui/events/devices/device_data_manager.h"
 #include "ui/events/devices/device_hotplug_event_observer.h"
 #include "ui/events/devices/device_util_linux.h"
 #include "ui/events/devices/input_device.h"
 #include "ui/events/devices/keyboard_device.h"
 #include "ui/events/devices/touchscreen_device.h"
 #include "ui/gfx/x/x11_types.h"
 
+#ifndef XI_PROP_PRODUCT_ID
+#define XI_PROP_PRODUCT_ID "Device Product ID"
+#endif
+
 namespace ui {
 
 namespace {
 
 // Names of all known internal devices that should not be considered as
 // keyboards.
 // TODO(rsadam@): Identify these devices using udev rules. (Crbug.com/420728.)
 const char* kKnownInvalidKeyboardDeviceNames[] = {"Power Button",
                                                   "Sleep Button",
                                                   "Video Bus",
                                                   "gpio-keys.12",
                                                   "ROCKCHIP-I2S Headset Jack"};
 
 const char* kCachedAtomList[] = {
   "Abs MT Position X",
   "Abs MT Position Y",
   XI_KEYBOARD,
   XI_MOUSE,
   XI_TOUCHPAD,
   XI_TOUCHSCREEN,
+  XI_PROP_PRODUCT_ID,
   NULL,
 };
 
 enum DeviceType {
   DEVICE_TYPE_KEYBOARD,
   DEVICE_TYPE_MOUSE,
   DEVICE_TYPE_TOUCHPAD,
   DEVICE_TYPE_TOUCHSCREEN,
   DEVICE_TYPE_OTHER
 };
@@ skipping 41 matching lines @@
   explicit TouchClassInfo(const XITouchClassInfo& info)
       : mode(info.mode), num_touches(info.num_touches) {}
 
   int mode;
   int num_touches;
 };
 
 struct DeviceInfo {
   DeviceInfo(const XIDeviceInfo& device,
              DeviceType type,
-             const base::FilePath& path)
+             const base::FilePath& path,
+             uint16_t vendor,
+             uint16_t product)
       : id(device.deviceid),
         name(device.name),
+        vendor_id(vendor),
+        product_id(product),
         use(device.use),
         type(type),
         path(path) {
     for (int i = 0; i < device.num_classes; ++i) {
       switch (device.classes[i]->type) {
         case XIValuatorClass:
           valuator_class_infos.push_back(ValuatorClassInfo(
               *reinterpret_cast<XIValuatorClassInfo*>(device.classes[i])));
           break;
         case XITouchClass:
           // A device can have at most one XITouchClassInfo. Ref:
           // http://manpages.ubuntu.com/manpages/saucy/man3/XIQueryDevice.3.html
           DCHECK(!touch_class_info.mode);
           touch_class_info = TouchClassInfo(
               *reinterpret_cast<XITouchClassInfo*>(device.classes[i]));
           break;
         default:
           break;
       }
     }
   }
 
   // Unique device identifier.
   int id;
 
   // Internal device name.
   std::string name;
 
+  // USB-style device identifiers.
+  uint16_t vendor_id;
+  uint16_t product_id;
+
   // Device type (ie: XIMasterPointer)
   int use;
 
   // Specifies the type of the device.
   DeviceType type;
 
   // Path to the actual device (ie: /dev/input/eventXX)
   base::FilePath path;
 
   std::vector<ValuatorClassInfo> valuator_class_infos;
@@ skipping 82 matching lines @@
   std::vector<KeyboardDevice> devices;
 
   for (const DeviceInfo& device_info : device_infos) {
     if (device_info.type != DEVICE_TYPE_KEYBOARD)
       continue;
     if (device_info.use != XISlaveKeyboard)
       continue;  // Assume all keyboards are keyboard slaves
     if (IsKnownInvalidKeyboardDevice(device_info.name))
       continue;  // Skip invalid devices.
     InputDeviceType type = GetInputDeviceTypeFromPath(device_info.path);
-    devices.push_back(KeyboardDevice(device_info.id, type));
+    KeyboardDevice keyboard(device_info.id, type, device_info.name);
+    devices.push_back(keyboard);
   }
 
   reply_runner->PostTask(FROM_HERE, base::Bind(callback, devices));
 }
 
 // Helper used to parse mouse information. When it is done it uses
 // |reply_runner| and |callback| to update the state on the UI thread.
 void HandleMouseDevicesInWorker(const std::vector<DeviceInfo>& device_infos,
                                 scoped_refptr<base::TaskRunner> reply_runner,
                                 const InputDeviceCallback& callback) {
   std::vector<InputDevice> devices;
   for (const DeviceInfo& device_info : device_infos) {
     if (device_info.type != DEVICE_TYPE_MOUSE ||
         device_info.use != XISlavePointer) {
       continue;
     }
 
     InputDeviceType type = GetInputDeviceTypeFromPath(device_info.path);
-    devices.push_back(InputDevice(device_info.id, type));
+    devices.push_back(InputDevice(device_info.id, type, device_info.name));
   }
 
   reply_runner->PostTask(FROM_HERE, base::Bind(callback, devices));
 }
 
 // Helper used to parse touchpad information. When it is done it uses
 // |reply_runner| and |callback| to update the state on the UI thread.
 void HandleTouchpadDevicesInWorker(const std::vector<DeviceInfo>& device_infos,
                                    scoped_refptr<base::TaskRunner> reply_runner,
                                    const InputDeviceCallback& callback) {
   std::vector<InputDevice> devices;
   for (const DeviceInfo& device_info : device_infos) {
     if (device_info.type != DEVICE_TYPE_TOUCHPAD ||
         device_info.use != XISlavePointer) {
       continue;
     }
 
     InputDeviceType type = GetInputDeviceTypeFromPath(device_info.path);
-    devices.push_back(InputDevice(device_info.id, type));
+    devices.push_back(InputDevice(device_info.id, type, device_info.name));
   }
 
   reply_runner->PostTask(FROM_HERE, base::Bind(callback, devices));
 }
 
 // Helper used to parse touchscreen information. When it is done it uses
 // |reply_runner| and |callback| to update the state on the UI thread.
 void HandleTouchscreenDevicesInWorker(
     const std::vector<DeviceInfo>& device_infos,
     const DisplayState& display_state,
@@ skipping 32 matching lines @@
           max_y = valuator.max;
         }
       }
     }
 
     // Touchscreens should have absolute X and Y axes.
     if (max_x > 0.0 && max_y > 0.0) {
       InputDeviceType type = GetInputDeviceTypeFromPath(device_info.path);
       // |max_x| and |max_y| are inclusive values, so we need to add 1 to get
       // the size.
-      devices.push_back(TouchscreenDevice(
-          device_info.id, type, gfx::Size(max_x + 1, max_y + 1),
-          device_info.touch_class_info.num_touches));
+      devices.push_back(
+          TouchscreenDevice(device_info.id, type, device_info.name,
+                            gfx::Size(max_x + 1, max_y + 1),
+                            device_info.touch_class_info.num_touches));
     }
   }
 
   reply_runner->PostTask(FROM_HERE, base::Bind(callback, devices));
 }
 
 // Called on a worker thread to parse the device information.
 void HandleHotplugEventInWorker(
     const std::vector<DeviceInfo>& devices,
     const DisplayState& display_state,
@@ skipping 68 matching lines @@
   std::vector<DeviceInfo> device_infos;
   for (int i = 0; i < device_list_xi2.count; ++i) {
     const XIDeviceInfo& device = device_list_xi2[i];
     if (!device.enabled || IsTestDevice(device.name))
       continue;
 
     DeviceType device_type =
         (device.deviceid >= 0 && device.deviceid < kMaxDeviceNum)
             ? device_types[device.deviceid]
             : DEVICE_TYPE_OTHER;
-    device_infos.push_back(
-        DeviceInfo(device, device_type, GetDevicePath(display, device)));
+
+    // Obtain the USB-style vendor and product identifiers.
+    // (On Linux, XI2 makes this available for all evdev devices.
+    uint32_t* product_info;
+    Atom type;
+    int format_return;
+    unsigned long num_items_return;
+    unsigned long bytes_after_return;
+    uint16_t vendor = 0;
+    uint16_t product = 0;
+    if (XIGetProperty(gfx::GetXDisplay(), device.deviceid,
+                      atom_cache_.GetAtom(XI_PROP_PRODUCT_ID), 0, 2, 0,
+                      XA_INTEGER, &type, &format_return, &num_items_return,
+                      &bytes_after_return,
+                      reinterpret_cast<unsigned char**>(&product_info)) == 0 &&
+        product_info) {
+      if (num_items_return == 2) {
+        vendor = product_info[0];
+        product = product_info[1];
+      }
+      XFree(product_info);
+    }
+
+    device_infos.push_back(DeviceInfo(
+        device, device_type, GetDevicePath(display, device), vendor, product));
   }
 
   // X11 is not thread safe, so first get all the required state.
   DisplayState display_state;
   display_state.mt_position_x = atom_cache_.GetAtom("Abs MT Position X");
   display_state.mt_position_y = atom_cache_.GetAtom("Abs MT Position Y");
 
   UiCallbacks callbacks;
   callbacks.keyboard_callback = base::Bind(&OnKeyboardDevices);
   callbacks.touchscreen_callback = base::Bind(&OnTouchscreenDevices);
   callbacks.mouse_callback = base::Bind(&OnMouseDevices);
   callbacks.touchpad_callback = base::Bind(&OnTouchpadDevices);
 
   // Parsing the device information may block, so delegate the operation to a
   // worker thread. Once the device information is extracted the parsed devices
   // will be returned via the callbacks.
-  base::WorkerPool::PostTask(FROM_HERE,
-                             base::Bind(&HandleHotplugEventInWorker,
-                                        device_infos,
-                                        display_state,
-                                        base::ThreadTaskRunnerHandle::Get(),
-                                        callbacks),
-                             true /* task_is_slow */);
+  base::WorkerPool::PostTask(
+      FROM_HERE,
+      base::Bind(&HandleHotplugEventInWorker, device_infos, display_state,
+                 base::ThreadTaskRunnerHandle::Get(), callbacks),
+      true /* task_is_slow */);
 }
 
 }  // namespace ui