Adds special support to the device manager for keyboards devices.

ui/events/x/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/x/device_data_manager_x11.h"
 
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 
+#include <utility>
+
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/sys_info.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_switches.h"
+#include "ui/events/keyboard_device.h"
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #include "ui/events/x/device_list_cache_x.h"
 #include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/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.
 #if !defined(XIScrollClass)
@@ skipping 73 matching lines @@
 
 // Constants for checking if a data type lies in the range of CMT/Touch data
 // types.
 const int kCMTDataTypeStart = ui::DeviceDataManagerX11::DT_CMT_SCROLL_X;
 const int kCMTDataTypeEnd = ui::DeviceDataManagerX11::DT_CMT_FINGER_COUNT;
 const int kTouchDataTypeStart = ui::DeviceDataManagerX11::DT_TOUCH_MAJOR;
 const int kTouchDataTypeEnd = ui::DeviceDataManagerX11::DT_TOUCH_RAW_TIMESTAMP;
 
 namespace ui {
 
+namespace {
+
+bool HasId(ui::KeyboardDevice keyboard, unsigned int id) {
+  return keyboard.id == static_cast<int>(id);
+}
+
+bool ShouldIgnoreKeyboard(
+    ui::KeyboardDevice keyboard,
+    const std::bitset<DeviceDataManagerX11::kMaxDeviceNum>& blocked_devices) {
+  return blocked_devices.test(keyboard.id);
+}
+
+}  // namespace
+
 bool DeviceDataManagerX11::IsCMTDataType(const int type) {
   return (type >= kCMTDataTypeStart) && (type <= kCMTDataTypeEnd);
 }
 
 bool DeviceDataManagerX11::IsTouchDataType(const int type) {
   return (type >= kTouchDataTypeStart) && (type <= kTouchDataTypeEnd);
 }
 
 // static
 void DeviceDataManagerX11::CreateInstance() {
@@ skipping 555 matching lines @@
 
 void DeviceDataManagerX11::SetDisabledKeyboardAllowedKeys(
     scoped_ptr<std::set<KeyboardCode> > excepted_keys) {
   DCHECK(!excepted_keys.get() ||
          !blocked_keyboard_allowed_keys_.get());
   blocked_keyboard_allowed_keys_ = excepted_keys.Pass();
 }
 
 void DeviceDataManagerX11::DisableDevice(unsigned 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::find_if(keyboards.begin(),
+                   keyboards.end(),

[flackr, 2014/10/08 21:58:11]

nit: Don't need to wrap this.

[rsadam, 2014/10/09 05:19:03]

Done.

+                   std::bind2nd(std::ptr_fun(&HasId), deviceid));
+  if (it != std::end(keyboards)) {
+    blocked_keyboards_.insert(std::pair<unsigned int, KeyboardDevice>(
+        deviceid,
+        *it));
+    OnKeyboardDevicesUpdated(keyboards);
+  }
 }
 
 void DeviceDataManagerX11::EnableDevice(unsigned int deviceid) {
   blocked_devices_.set(deviceid, false);
+  std::map<unsigned int, KeyboardDevice>::iterator it =
+      blocked_keyboards_.find(deviceid);
+  if (it != blocked_keyboards_.end()) {
+    std::vector<KeyboardDevice> devices = keyboard_devices();
+    devices.push_back(it->second);

[flackr, 2014/10/08 21:58:11]

Hmm, what if a device changes, or is removed while "blocked"? Then it seems this
cached list will be stale. The problem is of course in OnKeyboardDevicesUpdated
you may be getting called from line 711, 722 or you may be getting called from
the hotplug device manager. Maybe 711, 722 need to call straight into the base
class to just update the list so that 746 is always getting the full device
list.

[rsadam, 2014/10/09 05:19:03]

Handled that case with a slight variation of what we discuss- 711 and 722 still
call the overridden method, except we update the blocked list at 746, and re-add
the cached device on enable device.

When a device is blocked, it will get filtered since it's in blocked_keyboards_.
When a device is unblocked, it will update the base class to include this
device.

+    OnKeyboardDevicesUpdated(devices);
+  }
 }
 
 bool DeviceDataManagerX11::IsEventBlocked(
     const base::NativeEvent& native_event) {
   // Only check XI2 events which have a source device id.
   if (native_event->type != GenericEvent)
     return false;
 
   XIDeviceEvent* xievent =
       static_cast<XIDeviceEvent*>(native_event->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(native_event)) !=
           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);
+  keyboards.erase(
+      std::remove_if(keyboards.begin(), keyboards.end(),
+          std::bind2nd(
+              std::ptr_fun(&ShouldIgnoreKeyboard), blocked_devices_)),
+      keyboards.end());
+  DeviceDataManager::OnKeyboardDevicesUpdated(keyboards);
+}
+
 }  // namespace ui