Remove KeyboardDevice class.

ui/events/devices/x11/device_data_manager_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/devices/x11/device_data_manager_x11.h"
 
 #include <stddef.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/singleton.h"
 #include "base/sys_info.h"
 #include "build/build_config.h"
 #include "ui/display/display.h"
-#include "ui/events/devices/keyboard_device.h"
 #include "ui/events/devices/x11/device_list_cache_x11.h"
 #include "ui/events/devices/x11/touch_factory_x11.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_switches.h"
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/x/x11_types.h"
 
 // XIScrollClass was introduced in XI 2.1 so we need to define it here
 // for backward-compatibility with older versions of XInput.
@@ skipping 778 matching lines @@
 void DeviceDataManagerX11::SetDisabledKeyboardAllowedKeys(
     std::unique_ptr<std::set<KeyboardCode>> excepted_keys) {
   DCHECK(!excepted_keys.get() ||
          !blocked_keyboard_allowed_keys_.get());
   blocked_keyboard_allowed_keys_ = std::move(excepted_keys);
 }
 
 void DeviceDataManagerX11::DisableDevice(int deviceid) {
   blocked_devices_.set(deviceid, true);
   // TODO(rsadam@): Support blocking touchscreen devices.
-  std::vector<KeyboardDevice> keyboards = keyboard_devices();
-  std::vector<KeyboardDevice>::iterator it =
+  std::vector<InputDevice> keyboards = keyboard_devices();
+  std::vector<InputDevice>::iterator it =
       FindDeviceWithId(keyboards.begin(), keyboards.end(), deviceid);
   if (it != std::end(keyboards)) {
-    blocked_keyboards_.insert(
-        std::pair<int, KeyboardDevice>(deviceid, *it));
+    blocked_keyboard_devices_.insert(
+        std::pair<int, InputDevice>(deviceid, *it));
     keyboards.erase(it);
     DeviceDataManager::OnKeyboardDevicesUpdated(keyboards);
   }
 }
 
 void DeviceDataManagerX11::EnableDevice(int deviceid) {
   blocked_devices_.set(deviceid, false);
-  std::map<int, KeyboardDevice>::iterator it =
-      blocked_keyboards_.find(deviceid);
-  if (it != blocked_keyboards_.end()) {
-    std::vector<KeyboardDevice> devices = keyboard_devices();
+  std::map<int, InputDevice>::iterator it =
+      blocked_keyboard_devices_.find(deviceid);
+  if (it != blocked_keyboard_devices_.end()) {
+    std::vector<InputDevice> devices = keyboard_devices();
     // Add device to current list of active devices.
     devices.push_back((*it).second);
-    blocked_keyboards_.erase(it);
+    blocked_keyboard_devices_.erase(it);
     DeviceDataManager::OnKeyboardDevicesUpdated(devices);
   }
 }
 
 bool DeviceDataManagerX11::IsDeviceEnabled(int device_id) const {
   return blocked_devices_.test(device_id);
 }
 
 bool DeviceDataManagerX11::IsEventBlocked(const XEvent& xev) {
   // Only check XI2 events which have a source device id.
   if (xev.type != GenericEvent)
     return false;
 
   XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xev.xcookie.data);
   // Allow any key events from blocked_keyboard_allowed_keys_.
   if (blocked_keyboard_allowed_keys_ &&
       (xievent->evtype == XI_KeyPress || xievent->evtype == XI_KeyRelease) &&
       blocked_keyboard_allowed_keys_->find(KeyboardCodeFromXKeyEvent(&xev)) !=
           blocked_keyboard_allowed_keys_->end()) {
     return false;
   }
 
   return blocked_devices_.test(xievent->sourceid);
 }
 
 void DeviceDataManagerX11::OnKeyboardDevicesUpdated(
-    const std::vector<KeyboardDevice>& devices) {
-  std::vector<KeyboardDevice> keyboards(devices);
-  for (std::map<int, KeyboardDevice>::iterator blocked_iter =
-           blocked_keyboards_.begin();
-       blocked_iter != blocked_keyboards_.end();) {
+    const std::vector<InputDevice>& devices) {
+  std::vector<InputDevice> keyboards(devices);
+  for (std::map<int, InputDevice>::iterator blocked_iter =
+           blocked_keyboard_devices_.begin();
+       blocked_iter != blocked_keyboard_devices_.end();) {
     // Check if the blocked device still exists in list of devices.
     int device_id = blocked_iter->first;
-    std::vector<KeyboardDevice>::iterator it =
+    std::vector<InputDevice>::iterator it =
         FindDeviceWithId(keyboards.begin(), keyboards.end(), device_id);
     // If the device no longer exists, unblock it, else filter it out from our
     // active list.
     if (it == keyboards.end()) {
       blocked_devices_.set((*blocked_iter).first, false);
-      blocked_keyboards_.erase(blocked_iter++);
+      blocked_keyboard_devices_.erase(blocked_iter++);
     } else {
       keyboards.erase(it);
       ++blocked_iter;
     }
   }
   // Notify base class of updated list.
   DeviceDataManager::OnKeyboardDevicesUpdated(keyboards);
 }
 
 }  // namespace ui