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",
@@ skipping 178 matching lines @@
   // Make sure the returned value is a string.
   if (actual_type == XA_STRING && actual_format == 8)
     path = reinterpret_cast<char*>(data);
 
   XFree(data);
   XCloseDevice(dpy, dev);
 
   return base::FilePath(path);
 }
 
+// Obtain the USB-style vendor and product identifiers for an InputDevice.
+// (On Linux, XI2 makes this available for all evdev devices.)
+void SetDeviceIdentification(InputDevice* input_device) {
+  Atom product_id_atom = XInternAtom(gfx::GetXDisplay(), XI_PROP_PRODUCT_ID, 1);
+  uint32_t* product_info;
+  Atom type;
+  int format_return;
+  unsigned long num_items_return;
+  unsigned long bytes_after_return;
+  if (XIGetProperty(gfx::GetXDisplay(), input_device->id, product_id_atom, 0, 2,
+                    0, XA_INTEGER, &type, &format_return, &num_items_return,
+                    &bytes_after_return,
+                    reinterpret_cast<unsigned char**>(&product_info)) == 0 &&
+      product_info) {
+    input_device->vendor_id = product_info[0];
+    input_device->product_id = product_info[0];
+  }
+}

[sadrul, 2015/04/09 01:07:43]

The X11 calls in this function are happening in the worker thread (i.e. in
non-UI thread), right? I believe we want to avoid doing that.

[kpschoedel, 2015/04/09 18:51:41]

Done.

+
 // Helper used to parse keyboard information. When it is done it uses
 // |reply_runner| and |callback| to update the state on the UI thread.
 void HandleKeyboardDevicesInWorker(
     const std::vector<DeviceInfo>& device_infos,
     scoped_refptr<base::TaskRunner> reply_runner,
     const KeyboardDeviceCallback& callback) {
   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);
+    SetDeviceIdentification(&keyboard);

[sadrul, 2015/04/09 01:07:43]

Note that we also want to collect the product/vendor ID for touchscreens. (see
//chrome/browser/metrics/chromeos_metrics_provider.cc:WriteExternalTouchscreensProto().
The code for this in TouchFactory should be removed, and use this new code
instead)

Is there a reason to not do this for all device types?

[kpschoedel, 2015/04/09 18:51:41]

Oh, joy.
Purely laz^H^H^H velocity in fixing the Command-key regression.

Done.

+    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 96 matching lines @@
   base::WorkerPool::PostTask(FROM_HERE,
                              base::Bind(&HandleHotplugEventInWorker,
                                         device_infos,
                                         display_state,
                                         base::ThreadTaskRunnerHandle::Get(),
                                         callbacks),
                              true /* task_is_slow */);
 }
 
 }  // namespace ui