Block internal PlatformEvents before they are dispatched in touchview.

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/event_utils.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)
 #define XIScrollClass 3
@@ skipping 91 matching lines @@
   new DeviceDataManagerX11();
 }
 
 // static
 DeviceDataManagerX11* DeviceDataManagerX11::GetInstance() {
   return static_cast<DeviceDataManagerX11*>(DeviceDataManager::GetInstance());
 }
 
 DeviceDataManagerX11::DeviceDataManagerX11()
     : xi_opcode_(-1),
+      blocked_keyboard_(false),
       atom_cache_(gfx::GetXDisplay(), kCachedAtoms),
       button_map_count_(0) {
   CHECK(gfx::GetXDisplay());
   InitializeXInputInternal();
 
   // Make sure the sizes of enum and kCachedAtoms are aligned.
   CHECK(arraysize(kCachedAtoms) == static_cast<size_t>(DT_LAST_ENTRY) + 1);
   UpdateDeviceList(gfx::GetXDisplay());
   UpdateButtonMap();
 }
@@ skipping 523 matching lines @@
 #if defined(OS_CHROMEOS) && defined(USE_XI2_MT)
   int64 touch_display_id = GetDisplayForTouchDevice(touch_device_id);
   if (base::SysInfo::IsRunningOnChromeOS() &&
       touch_display_id == gfx::Display::InternalDisplayId()) {
     return true;
   }
 #endif  // defined(OS_CHROMEOS) && defined(USE_XI2_MT)
   return false;
 }
 
+void DeviceDataManagerX11::DisableKeyboard(
+    scoped_ptr<std::set<KeyboardCode> > excepted_keys) {
+  DCHECK(!blocked_keyboard_);
+  DCHECK(!blocked_keyboard_allowed_keys_.get());
+  blocked_keyboard_ = true;
+  blocked_keyboard_allowed_keys_ = excepted_keys.Pass();
+}
+
+void DeviceDataManagerX11::EnableKeyboard() {
+  DCHECK(blocked_keyboard_);
+  blocked_keyboard_ = false;
+  blocked_keyboard_allowed_keys_.reset();
+}
+
+void DeviceDataManagerX11::DisableDevice(unsigned int deviceid) {
+  blocked_devices_.set(deviceid, true);
+}
+
+void DeviceDataManagerX11::EnableDevice(unsigned int deviceid) {
+  blocked_devices_.set(deviceid, false);
+}
+
+bool DeviceDataManagerX11::IsEventBlocked(
+    const base::NativeEvent& native_event) {
+  switch (native_event->type) {
+    case KeyPress:
+    case KeyRelease:
+      return blocked_keyboard_ && (!blocked_keyboard_allowed_keys_ ||
+          blocked_keyboard_allowed_keys_->find(
+              KeyboardCodeFromNative(native_event)) ==
+                  blocked_keyboard_allowed_keys_->end());
+    case GenericEvent:
+      return blocked_devices_.test(
+          static_cast<XIDeviceEvent*>(native_event->xcookie.data)->sourceid);
+    default:
+      break;
+  }
+  return false;
+}
+
 }  // namespace ui