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 "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 648 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);
+  OnTouchscreenDevicesUpdated(touchscreen_devices());
+  OnKeyboardDevicesUpdated(keyboard_devices());
 }
 
 void DeviceDataManagerX11::EnableDevice(unsigned int deviceid) {
   blocked_devices_.set(deviceid, false);
+  OnTouchscreenDevicesUpdated(touchscreen_devices());
+  OnKeyboardDevicesUpdated(keyboard_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);
 }
 
+bool DeviceDataManagerX11::ShouldIgnoreKeyboard(
+    const ui::KeyboardDevice keyboard, DeviceDataManagerX11* manager) {

[pkotwicz, 2014/10/05 18:53:02]

As a general rule we either pass in a const reference or a parameter which is
neither a reference nor const.

|keyboard| here is passed by copy. So it does not really matter if
ShouldIgnoreKeyboard() mutates it

[rsadam, 2014/10/06 15:40:17]

Done.

+  return manager->blocked_devices_.test(keyboard.id);
+}
+
+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(&DeviceDataManagerX11::ShouldIgnoreKeyboard),
+              this)),
+      keyboards.end());
+  DeviceDataManager::OnKeyboardDevicesUpdated(keyboards);
+}
+
 }  // namespace ui