events: x11: Use device path to detect internal keyboards

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 18 matching lines @@
 #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"
 
 namespace ui {
 
 namespace {
 
-// The name of the xinput device corresponding to the AT internal keyboard.
-const char kATKeyboardName[] = "AT Translated Set 2 keyboard";
-
-// The prefix of xinput devices corresponding to CrOS EC internal keyboards.
-const char kCrosEcKeyboardPrefix[] = "cros-ec";
-
 // 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"};
 
 const char* kCachedAtomList[] = {
   "Abs MT Position X",
   "Abs MT Position Y",
@@ skipping 92 matching lines @@
 // Returns true if |name| is the name of a known invalid keyboard device. Note,
 // this may return false negatives.
 bool IsKnownInvalidKeyboardDevice(const std::string& name) {
   for (const char* device_name : kKnownInvalidKeyboardDeviceNames) {
     if (name == device_name)
       return true;
   }
   return false;
 }
 
-// Returns true if |name| is the name of a known internal keyboard device. Note,
-// this may return false negatives.
-bool IsInternalKeyboard(const std::string& name) {
-  // TODO(rsadam@): Come up with a more generic way of identifying internal
-  // keyboards. See crbug.com/420728.
-  if (name == kATKeyboardName)
-    return true;
-  return name.compare(
-             0u, strlen(kCrosEcKeyboardPrefix), kCrosEcKeyboardPrefix) == 0;
-}
-
 // Returns true if |name| is the name of a known XTEST device. Note, this may
 // return false negatives.
 bool IsTestKeyboard(const std::string& name) {
   return name.find("XTEST") != std::string::npos;
 }
 
 base::FilePath GetDevicePath(XDisplay* dpy, const XIDeviceInfo& device) {
 #if !defined(OS_CHROMEOS)
   return base::FilePath();
 #else
@@ skipping 55 matching lines @@
     const KeyboardDeviceCallback& callback) {
   std::vector<KeyboardDevice> devices;
 
   for (const DeviceInfo& device_info : device_infos) {
     if (!device_info.enabled || device_info.use != XISlaveKeyboard)
       continue;  // Assume all keyboards are keyboard slaves
     std::string device_name(device_info.name);
     base::TrimWhitespaceASCII(device_name, base::TRIM_TRAILING, &device_name);
     if (IsTestKeyboard(device_name))
       continue;  // Skip test devices.
-    InputDeviceType type;
-    if (IsInternalKeyboard(device_name)) {
-      type = InputDeviceType::INPUT_DEVICE_INTERNAL;
-    } else if (IsKnownInvalidKeyboardDevice(device_name)) {
-      type = InputDeviceType::INPUT_DEVICE_UNKNOWN;
-    } else {
-      type = InputDeviceType::INPUT_DEVICE_EXTERNAL;
-    }
+    if (IsKnownInvalidKeyboardDevice(device_name))
+      continue;  // Skip invalid devices.
+    InputDeviceType type = GetInputDeviceTypeFromPath(device_info.path);
     devices.push_back(
         KeyboardDevice(device_info.id, type, device_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(
@@ skipping 111 matching lines @@
   base::WorkerPool::PostTask(FROM_HERE,
                              base::Bind(&HandleHotplugEventInWorker,
                                         device_infos,
                                         display_state,
                                         base::ThreadTaskRunnerHandle::Get(),
                                         callbacks),
                              true /* task_is_slow */);
 }
 
 }  // namespace ui