Adds special support to the device manager for keyboards devices.

ui/events/x/hotplug_event_handler_x11.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/x/hotplug_event_handler_x11.h"
 
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 
 #include <cmath>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/logging.h"
 #include "base/process/launch.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "ui/events/device_hotplug_event_observer.h"
+#include "ui/events/keyboard_device.h"
 #include "ui/events/touchscreen_device.h"
 #include "ui/gfx/x/x11_types.h"
 
 namespace ui {
 
 namespace {
 
+// The name of the xinput device corresponding to the internal keyboard.
+const char kInternalKeyboardName[] = "AT Translated Set 2 keyboard";
+
+// The name of the xinput device corresponding to the test keyboard.
+const char kTestKeyboardName[] = "Virtual core XTEST keyboard";
+
+// Filters out devices like the power button which are also SlaveKeyboards but
+// not true keyboards.
+bool IsKeyboard(std::string name) {

[dnicoara, 2014/10/02 13:58:20]

Not sure if this would cover all keyboard devices.

[rsadam, 2014/10/02 14:59:31]

Added an UNKNOWN Enum, and marked these devices as that. This way we won't miss
any devices, and we correctly label the ones that are.

[flackr, 2014/10/02 15:41:10]

Agreed. I think false negatives are okay for how we're planning on using this,
since it will just mean we won't dismiss the keyboard when it's plugged in,
which is the current behavior for any keyboard. You should document that
explicitly though, that this can return false negatives.

+  std::transform(name.begin(), name.end(), name.begin(), ::tolower);
+  return name.find("keyboard") != std::string::npos;
+}
+
 // We consider the touchscreen to be internal if it is an I2c device.
 // With the device id, we can query X to get the device's dev input
 // node eventXXX. Then we search all the dev input nodes registered
 // by I2C devices to see if we can find eventXXX.
 bool IsTouchscreenInternal(XDisplay* dpy, int device_id) {
   using base::FileEnumerator;
   using base::FilePath;
 
 #if !defined(CHROMEOS)
   return false;
@@ skipping 70 matching lines @@
     : delegate_(delegate) {
 }
 
 HotplugEventHandlerX11::~HotplugEventHandlerX11() {
 }
 
 void HotplugEventHandlerX11::OnHotplugEvent() {
   const XIDeviceList& device_list =
       DeviceListCacheX::GetInstance()->GetXI2DeviceList(gfx::GetXDisplay());
   HandleTouchscreenDevices(device_list);
+  HandleKeyboardDevices(device_list);
+  delegate_->OnInputDeviceConfigurationChanged();
+}
+
+void HotplugEventHandlerX11::HandleKeyboardDevices(
+    const XIDeviceList& x11_devices) {
+  std::vector<KeyboardDevice> devices;
+
+  for (int i = 0; i < x11_devices.count; i++) {
+    if (!x11_devices[i].enabled || x11_devices[i].use != XISlaveKeyboard)
+      continue;  // Assume all keyboards are keyboard slaves
+    std::string device_name(x11_devices[i].name);
+    base::TrimWhitespaceASCII(device_name, base::TRIM_TRAILING,
+        &device_name);
+    if (!IsKeyboard(device_name))
+      continue;
+    KeyboardDeviceType type = KeyboardDeviceType::EXTERNAL;
+    if (device_name == kInternalKeyboardName) {
+        type = KeyboardDeviceType::INTERNAL;
+    } else if (device_name == kTestKeyboardName) {

[dnicoara, 2014/10/02 13:58:20]

Is there anything special about test devices?

[rsadam, 2014/10/02 14:59:31]

Each Master device has a XTEST device associated to it, which isn't an actual
keyboard. We want to distinguish these from physical devices.

[flackr, 2014/10/02 15:41:10]

This device shouldn't be considered a user accessible keyboard, and so we should
still display the virtual keyboard.

+        type = KeyboardDeviceType::TEST;
+    }
+    devices.push_back(KeyboardDevice(x11_devices[i].deviceid, type));
+  }
+  delegate_->OnKeyboardDevicesUpdated(devices);
 }
 
 void HotplugEventHandlerX11::HandleTouchscreenDevices(
     const XIDeviceList& x11_devices) {
   std::vector<TouchscreenDevice> devices;
   Display* display = gfx::GetXDisplay();
   Atom valuator_x = XInternAtom(display, "Abs MT Position X", False);
   Atom valuator_y = XInternAtom(display, "Abs MT Position Y", False);
   if (valuator_x == None || valuator_y == None)
     return;
@@ skipping 44 matching lines @@
           IsTouchscreenInternal(display, x11_devices[i].deviceid);
       devices.push_back(TouchscreenDevice(
           x11_devices[i].deviceid, gfx::Size(width, height), is_internal));
     }
   }
 
   delegate_->OnTouchscreenDevicesUpdated(devices);
 }
 
 }  // namespace ui