Block internal PlatformEvents before they are dispatched in touchview.

ui/events/x/device_data_manager.cc

 // Copyright 2013 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.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 82 matching lines @@
 bool DeviceDataManager::IsTouchDataType(const int type) {
   return (type >= kTouchDataTypeStart) && (type <= kTouchDataTypeEnd);
 }
 
 DeviceDataManager* DeviceDataManager::GetInstance() {
   return Singleton<DeviceDataManager>::get();
 }
 
 DeviceDataManager::DeviceDataManager()
     : 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();
   for (int i = 0; i < kMaxDeviceNum; i++)
@@ skipping 516 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 DeviceDataManager::DisableKeyboard(
+    scoped_ptr<std::set<KeyboardCode> > excepted_keys) {
+  DCHECK(!blocked_keyboard_);
+  DCHECK(!blocked_keyboard_allowed_keys_.get());
+  DCHECK(excepted_keys);

[sadrul, 2014/06/12 21:02:27]

This is probably not necessary? It should be possible to disable all keys.

[flackr, 2014/06/18 05:28:32]

Done.

+  blocked_keyboard_ = true;
+  blocked_keyboard_allowed_keys_ = excepted_keys.Pass();
+}
+
+void DeviceDataManager::EnableKeyboard() {
+  DCHECK(blocked_keyboard_);
+  blocked_keyboard_ = false;
+  blocked_keyboard_allowed_keys_.reset();
+}
+
+void DeviceDataManager::DisableDevice(unsigned int deviceid) {
+  blocked_devices_.set(deviceid, true);
+}
+
+void DeviceDataManager::EnableDevice(unsigned int deviceid) {
+  blocked_devices_.set(deviceid, false);
+}
+
+bool DeviceDataManager::EventBlocked(const base::NativeEvent& native_event) {
+  switch (native_event->type) {
+    case KeyPress:
+    case KeyRelease:
+      return blocked_keyboard_ && 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;
+}
+
 void DeviceDataManager::ClearTouchTransformerRecord() {
   for (int i = 0; i < kMaxDeviceNum; i++) {
     touch_device_transformer_map_[i] = gfx::Transform();
     touch_device_to_display_map_[i] = gfx::Display::kInvalidDisplayID;
   }
 }
 
 bool DeviceDataManager::IsTouchDeviceIdValid(int touch_device_id) const {
   return (touch_device_id > 0 && touch_device_id < kMaxDeviceNum);
 }
@@ skipping 20 matching lines @@
   }
 }
 
 int64 DeviceDataManager::GetDisplayForTouchDevice(int touch_device_id) const {
   if (IsTouchDeviceIdValid(touch_device_id))
     return touch_device_to_display_map_[touch_device_id];
   return gfx::Display::kInvalidDisplayID;
 }
 
 }  // namespace ui