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_x11.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 405 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_F(EventsXTest, DisableKeyboard) {
+  DeviceDataManagerX11* device_data_manager =
+      static_cast<DeviceDataManagerX11*>(
+          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_F(EventsXTest, DisableMouse) {
+  DeviceDataManagerX11* device_data_manager =
+      static_cast<DeviceDataManagerX11*>(
+          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  // defined(USE_XI2_MT)
+
 #if !defined(OS_CHROMEOS)
 TEST_F(EventsXTest, ImeFabricatedKeyEvents) {
   Display* display = gfx::GetXDisplay();
 
   unsigned int state_to_be_fabricated[] = {
     0, ShiftMask, LockMask, ShiftMask | LockMask,
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(state_to_be_fabricated); ++i) {
     unsigned int state = state_to_be_fabricated[i];
     for (int is_char = 0; is_char < 2; ++is_char) {
@@ skipping 13 matching lines @@
       XEvent x_event;
       InitKeyEvent(display, &x_event, true, 0, state);
       ui::KeyEvent key_event(&x_event, is_char);
       EXPECT_FALSE(key_event.flags() & ui::EF_IME_FABRICATED_KEY);
     }
   }
 }
 #endif
 
 }  // namespace ui