Remove KeyboardDevice class.

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 <stdint.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
@@ skipping 11 matching lines @@
 #include "base/process/launch.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "base/threading/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 {
@@ skipping 20 matching lines @@
 };
 
 enum DeviceType {
   DEVICE_TYPE_KEYBOARD,
   DEVICE_TYPE_MOUSE,
   DEVICE_TYPE_TOUCHPAD,
   DEVICE_TYPE_TOUCHSCREEN,
   DEVICE_TYPE_OTHER
 };
 
-typedef base::Callback<void(const std::vector<KeyboardDevice>&)>
+typedef base::Callback<void(const std::vector<InputDevice>&)>
     KeyboardDeviceCallback;
 
 typedef base::Callback<void(const std::vector<TouchscreenDevice>&)>
     TouchscreenDeviceCallback;
 
 typedef base::Callback<void(const std::vector<InputDevice>&)>
     InputDeviceCallback;
 
 // Used for updating the state on the UI thread once device information is
 // parsed on helper threads.
@@ skipping 161 matching lines @@
 
   return base::FilePath(path);
 }
 
 // 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;
+  std::vector<InputDevice> 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);
-    KeyboardDevice keyboard(device_info.id, type, device_info.name);
+    InputDevice 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,
@@ skipping 101 matching lines @@
   HandleMouseDevicesInWorker(devices, reply_runner, callbacks.mouse_callback);
   HandleTouchpadDevicesInWorker(devices, reply_runner,
                                 callbacks.touchpad_callback);
   reply_runner->PostTask(FROM_HERE, callbacks.hotplug_finished_callback);
 }
 
 DeviceHotplugEventObserver* GetHotplugEventObserver() {
   return DeviceDataManager::GetInstance();
 }
 
-void OnKeyboardDevices(const std::vector<KeyboardDevice>& devices) {
+void OnKeyboardDevices(const std::vector<InputDevice>& devices) {
   GetHotplugEventObserver()->OnKeyboardDevicesUpdated(devices);
 }
 
 void OnTouchscreenDevices(const std::vector<TouchscreenDevice>& devices) {
   GetHotplugEventObserver()->OnTouchscreenDevicesUpdated(devices);
 }
 
 void OnMouseDevices(const std::vector<InputDevice>& devices) {
   GetHotplugEventObserver()->OnMouseDevicesUpdated(devices);
 }
@@ skipping 96 matching lines @@
   // 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 */);
 }
 
 }  // namespace ui