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, int id) {
+  return keyboard.id == 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 554 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) {
+  LOG(ERROR) << "Disable the device:" << deviceid;

[flackr, 2014/10/10 17:49:31]

Remove this, not an error.

[rsadam, 2014/10/14 17:32:19]

Oops. Fixed.

   blocked_devices_.set(deviceid, true);
+  int id = static_cast<int>(deviceid);
+  // TODO(rsadam@): Support blocking touchscreen devices.
+  std::vector<KeyboardDevice> keyboards = keyboard_devices();
+  std::vector<KeyboardDevice>::iterator it =
+      std::find_if(keyboards.begin(), keyboards.end(), std::bind2nd(
+          std::ptr_fun(&HasId), id));
+  if (it != std::end(keyboards)) {
+    blocked_keyboards_.insert(std::pair<int, KeyboardDevice>(
+        id,

[flackr, 2014/10/10 17:49:31]

you can also just write blocked_keyboards_[id] = *it;

[rsadam, 2014/10/14 17:32:19]

As discussed offline, would require copy constructor for the struct so sticking
with original implementation.

[flackr, 2014/10/14 17:41:35]

Acknowledged, no need to wrap id, *it.

+        *it));
+    OnKeyboardDevicesUpdated(keyboards);

[flackr, 2014/10/10 17:49:30]

OnKeyboardDevices assumes it is getting the full list of keyboard devices.
Calling it directly with an already filtered list can result in it falsely
unblocking keyboards which were previously removed.

I.e.
DisableDevice(1);
DisableDevice(2); // Calls OnKeyboardDevicesUpdated which thinks device 1
doesn't exist anymore because it's not in keyboards

Same for line 720. This is why I proposed calling into the parent class only.

[rsadam, 2014/10/14 17:32:18]

Done.

[flackr, 2014/10/14 17:41:35]

Test?

[rsadam, 2014/10/14 17:55:01]

Done.

+  }
 }
 
 void DeviceDataManagerX11::EnableDevice(unsigned int deviceid) {
   blocked_devices_.set(deviceid, false);
+  int id = static_cast<int>(deviceid);
+  std::map<int, KeyboardDevice>::iterator it =
+      blocked_keyboards_.find(id);
+  if (it != blocked_keyboards_.end()) {
+    std::vector<KeyboardDevice> devices = keyboard_devices();
+    // Add device to current list of active devices.
+    devices.push_back((*it).second);
+    blocked_keyboards_.erase(it);
+    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);
+  std::map<int, KeyboardDevice>::iterator blocked_iter;
+  for (blocked_iter = blocked_keyboards_.begin();
+      blocked_iter != blocked_keyboards_.end();) {
+    // Check if the blocked device still exists in list of devices.
+    std::vector<KeyboardDevice>::iterator it =
+      std::find_if(keyboards.begin(), keyboards.end(), std::bind2nd(
+          std::ptr_fun(&HasId), (*blocked_iter).first));
+    // If the device no longer exists, unblock it, else filter it out from our
+    // active list.
+    if (it == keyboards.end()) {
+      unsigned int id = static_cast<int> ((*blocked_iter).first);
+      blocked_devices_.set(id, false);
+      blocked_keyboards_.erase(blocked_iter++);

[flackr, 2014/10/10 17:49:31]

This is not correct. std::vector::erase invalidates iterators pointing to the
erased position and beyond. In particular you will probably at least skip the
next keyboard if not overstep the end of the list. You need to use the returned
value to step to the next position:
blocked_iter = blocked_keyboards_.erase(blocked_iter);

[rsadam, 2014/10/14 17:32:19]

blocked_iter is a std::map::iter, and so as we discussed offline, the existing
approach should be fine.

[flackr, 2014/10/14 17:41:35]

Acknowledged.

+    } else {
+      keyboards.erase(it);
+      ++blocked_iter;
+    }
+  }
+  // Notify base class of updated list.
+  DeviceDataManager::OnKeyboardDevicesUpdated(keyboards);
+}
+
 }  // namespace ui