Block internal PlatformEvents before they are dispatched in touchview.

ui/events/x/events_x_unittest.cc

 // Copyright (c) 2012 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 <cstring>
+#include <set>
 
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/XKBlib.h>
 
 // Generically-named #defines from Xlib that conflict with symbols in GTest.
 #undef Bool
 #undef None
 
+#include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/test/events_test_utils_x11.h"
+#include "ui/events/x/device_data_manager.h"
+#include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/point.h"
 
 namespace ui {
 
 namespace {
 
 // Initializes the passed-in Xlib event.
 void InitButtonEvent(XEvent* event,
                      bool is_press,
                      const gfx::Point& location,
@@ skipping 391 matching lines @@
   EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F30));
   EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F31));
   EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F32));
   EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F33));
   EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F34));
   EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F35));
   // Max function key code plus 1.
   EXPECT_FALSE(HasFunctionKeyFlagSetIfSupported(display, XK_F35 + 1));
 }
 
+// Verifies that the type of events from a disabled keyboard is ET_UNKNOWN, but
+// that an exception list of keys can still be processed.
+TEST(EventsXTest, DisableKeyboard) {
+  DeviceDataManager* device_data_manager = DeviceDataManager::GetInstance();
+  scoped_ptr<std::set<KeyboardCode> > excepted_keys(new std::set<KeyboardCode>);
+  excepted_keys->insert(VKEY_B);
+  device_data_manager->DisableKeyboard(excepted_keys.Pass());
+
+  Display* display = gfx::GetXDisplay();
+  XEvent event;
+
+  // A is not allowed on the blocked keyboard, and should return ET_UNKNOWN.
+  InitKeyEvent(display, &event, true, XKeysymToKeycode(display, XK_A), 0);
+  EXPECT_EQ(ui::ET_UNKNOWN, ui::EventTypeFromNative(&event));
+
+  // The B key is allowed as an exception, and should return KEY_PRESSED.
+  InitKeyEvent(display, &event, true, XKeysymToKeycode(display, XK_B), 0);
+  EXPECT_EQ(ui::ET_KEY_PRESSED, ui::EventTypeFromNative(&event));
+
+  device_data_manager->EnableKeyboard();
+
+  // A key returns KEY_PRESSED as per usual now that keyboard was re-enabled.
+  InitKeyEvent(display, &event, true, XKeysymToKeycode(display, XK_A), 0);
+  EXPECT_EQ(ui::ET_KEY_PRESSED, ui::EventTypeFromNative(&event));
+}
+
+#if defined(USE_XI2_MT)
+// Verifies that the type of events from a disabled mouse is ET_UNKNOWN.
+TEST(EventsXTest, DisableMouse) {
+  DeviceDataManager* device_data_manager = DeviceDataManager::GetInstance();
+  unsigned int blocked_device_id = 1;
+  unsigned int other_device_id = 2;
+  std::vector<unsigned int> device_list;
+  device_list.push_back(blocked_device_id);
+  device_list.push_back(other_device_id);
+  TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list);
+
+  device_data_manager->DisableDevice(blocked_device_id);
+
+  ScopedXI2Event xev;
+  xev.InitGenericButtonEvent(blocked_device_id, ET_MOUSE_PRESSED, gfx::Point(),
+      EF_LEFT_MOUSE_BUTTON);
+  EXPECT_EQ(ui::ET_UNKNOWN, ui::EventTypeFromNative(xev));
+
+  xev.InitGenericButtonEvent(other_device_id, ET_MOUSE_PRESSED, gfx::Point(),
+      EF_LEFT_MOUSE_BUTTON);
+  EXPECT_EQ(ui::ET_MOUSE_PRESSED, ui::EventTypeFromNative(xev));
+
+  device_data_manager->EnableDevice(blocked_device_id);
+
+  xev.InitGenericButtonEvent(blocked_device_id, ET_MOUSE_PRESSED, gfx::Point(),
+      EF_LEFT_MOUSE_BUTTON);
+  EXPECT_EQ(ui::ET_MOUSE_PRESSED, ui::EventTypeFromNative(xev));
+}
+#endif
+
 }  // namespace ui