1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include <cstring> 6 #include <set> 7 8 #include <X11/extensions/XInput2.h> 9 #include <X11/Xlib.h> 10 #include <X11/Xutil.h> 11 #include <X11/XKBlib.h> 12 13 // Generically-named #defines from Xlib that conflict with symbols in GTest. 14 #undef Bool 15 #undef None 16 17 #include "base/memory/scoped_ptr.h" 18 #include "testing/gtest/include/gtest/gtest.h" 19 #include "ui/events/event.h" 20 #include "ui/events/event_constants.h" 21 #include "ui/events/event_utils.h" 22 #include "ui/events/test/events_test_utils.h" 23 #include "ui/events/test/events_test_utils_x11.h" 24 #include "ui/events/x/device_data_manager_x11.h" 25 #include "ui/events/x/touch_factory_x11.h" 26 #include "ui/gfx/point.h" 27 28 namespace ui { 29 30 namespace { 31 32 // Initializes the passed-in Xlib event. 33 void InitButtonEvent(XEvent* event, 34 bool is_press, 35 const gfx::Point& location, 36 int button, 37 int state) { 38 memset(event, 0, sizeof(*event)); 39 40 // We don't bother setting fields that the event code doesn't use, such as 41 // x_root/y_root and window/root/subwindow. 42 XButtonEvent* button_event = &(event->xbutton); 43 button_event->type = is_press ? ButtonPress : ButtonRelease; 44 button_event->x = location.x(); 45 button_event->y = location.y(); 46 button_event->button = button; 47 button_event->state = state; 48 } 49 50 // Initializes the passed-in Xlib event. 51 void InitKeyEvent(Display* display, 52 XEvent* event, 53 bool is_press, 54 int keycode, 55 int state) { 56 memset(event, 0, sizeof(*event)); 57 58 // We don't bother setting fields that the event code doesn't use, such as 59 // x_root/y_root and window/root/subwindow. 60 XKeyEvent* key_event = &(event->xkey); 61 key_event->display = display; 62 key_event->type = is_press ? KeyPress : KeyRelease; 63 key_event->keycode = keycode; 64 key_event->state = state; 65 } 66 67 // Returns true if the keysym maps to a KeyEvent with the EF_FUNCTION_KEY 68 // flag set, or the keysym maps to a zero key code. 69 bool HasFunctionKeyFlagSetIfSupported(Display* display, int x_keysym) { 70 XEvent event; 71 int x_keycode = XKeysymToKeycode(display, x_keysym); 72 // Exclude keysyms for which the server has no corresponding keycode. 73 if (x_keycode) { 74 InitKeyEvent(display, &event, true, x_keycode, 0); 75 ui::KeyEvent ui_key_event(&event); 76 return (ui_key_event.flags() & ui::EF_FUNCTION_KEY); 77 } 78 return true; 79 } 80 81 } // namespace 82 83 class EventsXTest : public testing::Test { 84 public: 85 EventsXTest() {} 86 virtual ~EventsXTest() {} 87 88 virtual void SetUp() OVERRIDE { 89 DeviceDataManagerX11::CreateInstance(); 90 ui::TouchFactory::GetInstance()->ResetForTest(); 91 } 92 private: 93 DISALLOW_COPY_AND_ASSIGN(EventsXTest); 94 }; 95 96 TEST_F(EventsXTest, ButtonEvents) { 97 XEvent event; 98 gfx::Point location(5, 10); 99 gfx::Vector2d offset; 100 101 InitButtonEvent(&event, true, location, 1, 0); 102 EXPECT_EQ(ui::ET_MOUSE_PRESSED, ui::EventTypeFromNative(&event)); 103 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, ui::EventFlagsFromNative(&event)); 104 EXPECT_EQ(location, ui::EventLocationFromNative(&event)); 105 106 InitButtonEvent(&event, true, location, 2, Button1Mask | ShiftMask); 107 EXPECT_EQ(ui::ET_MOUSE_PRESSED, ui::EventTypeFromNative(&event)); 108 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON | ui::EF_MIDDLE_MOUSE_BUTTON | 109 ui::EF_SHIFT_DOWN, 110 ui::EventFlagsFromNative(&event)); 111 EXPECT_EQ(location, ui::EventLocationFromNative(&event)); 112 113 InitButtonEvent(&event, false, location, 3, 0); 114 EXPECT_EQ(ui::ET_MOUSE_RELEASED, ui::EventTypeFromNative(&event)); 115 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, ui::EventFlagsFromNative(&event)); 116 EXPECT_EQ(location, ui::EventLocationFromNative(&event)); 117 118 // Scroll up. 119 InitButtonEvent(&event, true, location, 4, 0); 120 EXPECT_EQ(ui::ET_MOUSEWHEEL, ui::EventTypeFromNative(&event)); 121 EXPECT_EQ(0, ui::EventFlagsFromNative(&event)); 122 EXPECT_EQ(location, ui::EventLocationFromNative(&event)); 123 offset = ui::GetMouseWheelOffset(&event); 124 EXPECT_GT(offset.y(), 0); 125 EXPECT_EQ(0, offset.x()); 126 127 // Scroll down. 128 InitButtonEvent(&event, true, location, 5, 0); 129 EXPECT_EQ(ui::ET_MOUSEWHEEL, ui::EventTypeFromNative(&event)); 130 EXPECT_EQ(0, ui::EventFlagsFromNative(&event)); 131 EXPECT_EQ(location, ui::EventLocationFromNative(&event)); 132 offset = ui::GetMouseWheelOffset(&event); 133 EXPECT_LT(offset.y(), 0); 134 EXPECT_EQ(0, offset.x()); 135 136 // Scroll left. 137 InitButtonEvent(&event, true, location, 6, 0); 138 EXPECT_EQ(ui::ET_MOUSEWHEEL, ui::EventTypeFromNative(&event)); 139 EXPECT_EQ(0, ui::EventFlagsFromNative(&event)); 140 EXPECT_EQ(location, ui::EventLocationFromNative(&event)); 141 offset = ui::GetMouseWheelOffset(&event); 142 EXPECT_EQ(0, offset.y()); 143 EXPECT_GT(offset.x(), 0); 144 145 // Scroll right. 146 InitButtonEvent(&event, true, location, 7, 0); 147 EXPECT_EQ(ui::ET_MOUSEWHEEL, ui::EventTypeFromNative(&event)); 148 EXPECT_EQ(0, ui::EventFlagsFromNative(&event)); 149 EXPECT_EQ(location, ui::EventLocationFromNative(&event)); 150 offset = ui::GetMouseWheelOffset(&event); 151 EXPECT_EQ(0, offset.y()); 152 EXPECT_LT(offset.x(), 0); 153 154 // TODO(derat): Test XInput code. 155 } 156 157 TEST_F(EventsXTest, AvoidExtraEventsOnWheelRelease) { 158 XEvent event; 159 gfx::Point location(5, 10); 160 161 InitButtonEvent(&event, true, location, 4, 0); 162 EXPECT_EQ(ui::ET_MOUSEWHEEL, ui::EventTypeFromNative(&event)); 163 164 // We should return ET_UNKNOWN for the release event instead of returning 165 // ET_MOUSEWHEEL; otherwise we'll scroll twice for each scrollwheel step. 166 InitButtonEvent(&event, false, location, 4, 0); 167 EXPECT_EQ(ui::ET_UNKNOWN, ui::EventTypeFromNative(&event)); 168 169 // TODO(derat): Test XInput code. 170 } 171 172 TEST_F(EventsXTest, EnterLeaveEvent) { 173 XEvent event; 174 event.xcrossing.type = EnterNotify; 175 event.xcrossing.x = 10; 176 event.xcrossing.y = 20; 177 event.xcrossing.x_root = 110; 178 event.xcrossing.y_root = 120; 179 180 // Mouse enter events are converted to mouse move events to be consistent with 181 // the way views handle mouse enter. See comments for EnterNotify case in 182 // ui::EventTypeFromNative for more details. 183 EXPECT_EQ(ui::ET_MOUSE_MOVED, ui::EventTypeFromNative(&event)); 184 EXPECT_EQ("10,20", ui::EventLocationFromNative(&event).ToString()); 185 EXPECT_EQ("110,120", ui::EventSystemLocationFromNative(&event).ToString()); 186 187 event.xcrossing.type = LeaveNotify; 188 event.xcrossing.x = 30; 189 event.xcrossing.y = 40; 190 event.xcrossing.x_root = 230; 191 event.xcrossing.y_root = 240; 192 EXPECT_EQ(ui::ET_MOUSE_EXITED, ui::EventTypeFromNative(&event)); 193 EXPECT_EQ("30,40", ui::EventLocationFromNative(&event).ToString()); 194 EXPECT_EQ("230,240", ui::EventSystemLocationFromNative(&event).ToString()); 195 } 196 197 TEST_F(EventsXTest, ClickCount) { 198 XEvent event; 199 gfx::Point location(5, 10); 200 201 for (int i = 1; i <= 3; ++i) { 202 InitButtonEvent(&event, true, location, 1, 0); 203 { 204 MouseEvent mouseev(&event); 205 EXPECT_EQ(ui::ET_MOUSE_PRESSED, mouseev.type()); 206 EXPECT_EQ(i, mouseev.GetClickCount()); 207 } 208 209 InitButtonEvent(&event, false, location, 1, 0); 210 { 211 MouseEvent mouseev(&event); 212 EXPECT_EQ(ui::ET_MOUSE_RELEASED, mouseev.type()); 213 EXPECT_EQ(i, mouseev.GetClickCount()); 214 } 215 } 216 } 217 218 #if defined(USE_XI2_MT) 219 TEST_F(EventsXTest, TouchEventBasic) { 220 std::vector<unsigned int> devices; 221 devices.push_back(0); 222 ui::SetUpTouchDevicesForTest(devices); 223 std::vector<Valuator> valuators; 224 225 // Init touch begin with tracking id 5, touch id 0. 226 valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_MAJOR, 20)); 227 valuators.push_back( 228 Valuator(DeviceDataManagerX11::DT_TOUCH_ORIENTATION, 0.3f)); 229 valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_PRESSURE, 100)); 230 ui::ScopedXI2Event scoped_xevent; 231 scoped_xevent.InitTouchEvent( 232 0, XI_TouchBegin, 5, gfx::Point(10, 10), valuators); 233 EXPECT_EQ(ui::ET_TOUCH_PRESSED, ui::EventTypeFromNative(scoped_xevent)); 234 EXPECT_EQ("10,10", ui::EventLocationFromNative(scoped_xevent).ToString()); 235 EXPECT_EQ(GetTouchId(scoped_xevent), 0); 236 EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 10); 237 EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.15f); 238 EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.1f); 239 240 // Touch update, with new orientation info. 241 valuators.clear(); 242 valuators.push_back( 243 Valuator(DeviceDataManagerX11::DT_TOUCH_ORIENTATION, 0.5f)); 244 scoped_xevent.InitTouchEvent( 245 0, XI_TouchUpdate, 5, gfx::Point(20, 20), valuators); 246 EXPECT_EQ(ui::ET_TOUCH_MOVED, ui::EventTypeFromNative(scoped_xevent)); 247 EXPECT_EQ("20,20", ui::EventLocationFromNative(scoped_xevent).ToString()); 248 EXPECT_EQ(GetTouchId(scoped_xevent), 0); 249 EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 10); 250 EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.25f); 251 EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.1f); 252 253 // Another touch with tracking id 6, touch id 1. 254 valuators.clear(); 255 valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_MAJOR, 100)); 256 valuators.push_back(Valuator( 257 DeviceDataManagerX11::DT_TOUCH_ORIENTATION, 0.9f)); 258 valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_PRESSURE, 500)); 259 scoped_xevent.InitTouchEvent( 260 0, XI_TouchBegin, 6, gfx::Point(200, 200), valuators); 261 EXPECT_EQ(ui::ET_TOUCH_PRESSED, ui::EventTypeFromNative(scoped_xevent)); 262 EXPECT_EQ("200,200", ui::EventLocationFromNative(scoped_xevent).ToString()); 263 EXPECT_EQ(GetTouchId(scoped_xevent), 1); 264 EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 50); 265 EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.45f); 266 EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.5f); 267 268 // Touch with tracking id 5 should have old radius/angle value and new pressue 269 // value. 270 valuators.clear(); 271 valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_PRESSURE, 50)); 272 scoped_xevent.InitTouchEvent( 273 0, XI_TouchEnd, 5, gfx::Point(30, 30), valuators); 274 EXPECT_EQ(ui::ET_TOUCH_RELEASED, ui::EventTypeFromNative(scoped_xevent)); 275 EXPECT_EQ("30,30", ui::EventLocationFromNative(scoped_xevent).ToString()); 276 EXPECT_EQ(GetTouchId(scoped_xevent), 0); 277 EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 10); 278 EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.25f); 279 EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.05f); 280 281 // Touch with tracking id 6 should have old angle/pressure value and new 282 // radius value. 283 valuators.clear(); 284 valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_MAJOR, 50)); 285 scoped_xevent.InitTouchEvent( 286 0, XI_TouchEnd, 6, gfx::Point(200, 200), valuators); 287 EXPECT_EQ(ui::ET_TOUCH_RELEASED, ui::EventTypeFromNative(scoped_xevent)); 288 EXPECT_EQ("200,200", ui::EventLocationFromNative(scoped_xevent).ToString()); 289 EXPECT_EQ(GetTouchId(scoped_xevent), 1); 290 EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 25); 291 EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.45f); 292 EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.5f); 293 } 294 295 int GetTouchIdForTrackingId(uint32 tracking_id) { 296 int slot = 0; 297 bool success = 298 TouchFactory::GetInstance()->QuerySlotForTrackingID(tracking_id, &slot); 299 if (success) 300 return slot; 301 return -1; 302 } 303 304 TEST_F(EventsXTest, TouchEventIdRefcounting) { 305 std::vector<unsigned int> devices; 306 devices.push_back(0); 307 ui::SetUpTouchDevicesForTest(devices); 308 std::vector<Valuator> valuators; 309 310 const int kTrackingId0 = 5; 311 const int kTrackingId1 = 7; 312 313 // Increment ref count once for first touch. 314 ui::ScopedXI2Event xpress0; 315 xpress0.InitTouchEvent( 316 0, XI_TouchBegin, kTrackingId0, gfx::Point(10, 10), valuators); 317 scoped_ptr<ui::TouchEvent> upress0(new ui::TouchEvent(xpress0)); 318 EXPECT_EQ(0, GetTouchIdForTrackingId(kTrackingId0)); 319 320 // Increment ref count 4 times for second touch. 321 ui::ScopedXI2Event xpress1; 322 xpress1.InitTouchEvent( 323 0, XI_TouchBegin, kTrackingId1, gfx::Point(20, 20), valuators); 324 325 for (int i = 0; i < 4; ++i) { 326 ui::TouchEvent upress1(xpress1); 327 EXPECT_EQ(1, GetTouchIdForTrackingId(kTrackingId1)); 328 } 329 330 ui::ScopedXI2Event xrelease1; 331 xrelease1.InitTouchEvent( 332 0, XI_TouchEnd, kTrackingId1, gfx::Point(10, 10), valuators); 333 334 // Decrement ref count 3 times for second touch. 335 for (int i = 0; i < 3; ++i) { 336 ui::TouchEvent urelease1(xrelease1); 337 EXPECT_EQ(1, GetTouchIdForTrackingId(kTrackingId1)); 338 } 339 340 // This should clear the touch id of the second touch. 341 scoped_ptr<ui::TouchEvent> urelease1(new ui::TouchEvent(xrelease1)); 342 urelease1.reset(); 343 EXPECT_EQ(-1, GetTouchIdForTrackingId(kTrackingId1)); 344 345 // This should clear the touch id of the first touch. 346 ui::ScopedXI2Event xrelease0; 347 xrelease0.InitTouchEvent( 348 0, XI_TouchEnd, kTrackingId0, gfx::Point(10, 10), valuators); 349 scoped_ptr<ui::TouchEvent> urelease0(new ui::TouchEvent(xrelease0)); 350 urelease0.reset(); 351 EXPECT_EQ(-1, GetTouchIdForTrackingId(kTrackingId0)); 352 } 353 #endif 354 355 TEST_F(EventsXTest, NumpadKeyEvents) { 356 XEvent event; 357 Display* display = gfx::GetXDisplay(); 358 359 struct { 360 bool is_numpad_key; 361 int x_keysym; 362 } keys[] = { 363 // XK_KP_Space and XK_KP_Equal are the extrema in the conventional 364 // keysymdef.h numbering. 365 { true, XK_KP_Space }, 366 { true, XK_KP_Equal }, 367 // Other numpad keysyms. (This is actually exhaustive in the current list.) 368 { true, XK_KP_Tab }, 369 { true, XK_KP_Enter }, 370 { true, XK_KP_F1 }, 371 { true, XK_KP_F2 }, 372 { true, XK_KP_F3 }, 373 { true, XK_KP_F4 }, 374 { true, XK_KP_Home }, 375 { true, XK_KP_Left }, 376 { true, XK_KP_Up }, 377 { true, XK_KP_Right }, 378 { true, XK_KP_Down }, 379 { true, XK_KP_Prior }, 380 { true, XK_KP_Page_Up }, 381 { true, XK_KP_Next }, 382 { true, XK_KP_Page_Down }, 383 { true, XK_KP_End }, 384 { true, XK_KP_Begin }, 385 { true, XK_KP_Insert }, 386 { true, XK_KP_Delete }, 387 { true, XK_KP_Multiply }, 388 { true, XK_KP_Add }, 389 { true, XK_KP_Separator }, 390 { true, XK_KP_Subtract }, 391 { true, XK_KP_Decimal }, 392 { true, XK_KP_Divide }, 393 { true, XK_KP_0 }, 394 { true, XK_KP_1 }, 395 { true, XK_KP_2 }, 396 { true, XK_KP_3 }, 397 { true, XK_KP_4 }, 398 { true, XK_KP_5 }, 399 { true, XK_KP_6 }, 400 { true, XK_KP_7 }, 401 { true, XK_KP_8 }, 402 { true, XK_KP_9 }, 403 // Largest keysym preceding XK_KP_Space. 404 { false, XK_Num_Lock }, 405 // Smallest keysym following XK_KP_Equal. 406 { false, XK_F1 }, 407 // Non-numpad analogues of numpad keysyms. 408 { false, XK_Tab }, 409 { false, XK_Return }, 410 { false, XK_F1 }, 411 { false, XK_F2 }, 412 { false, XK_F3 }, 413 { false, XK_F4 }, 414 { false, XK_Home }, 415 { false, XK_Left }, 416 { false, XK_Up }, 417 { false, XK_Right }, 418 { false, XK_Down }, 419 { false, XK_Prior }, 420 { false, XK_Page_Up }, 421 { false, XK_Next }, 422 { false, XK_Page_Down }, 423 { false, XK_End }, 424 { false, XK_Insert }, 425 { false, XK_Delete }, 426 { false, XK_multiply }, 427 { false, XK_plus }, 428 { false, XK_minus }, 429 { false, XK_period }, 430 { false, XK_slash }, 431 { false, XK_0 }, 432 { false, XK_1 }, 433 { false, XK_2 }, 434 { false, XK_3 }, 435 { false, XK_4 }, 436 { false, XK_5 }, 437 { false, XK_6 }, 438 { false, XK_7 }, 439 { false, XK_8 }, 440 { false, XK_9 }, 441 // Miscellaneous other keysyms. 442 { false, XK_BackSpace }, 443 { false, XK_Scroll_Lock }, 444 { false, XK_Multi_key }, 445 { false, XK_Select }, 446 { false, XK_Num_Lock }, 447 { false, XK_Shift_L }, 448 { false, XK_space }, 449 { false, XK_A }, 450 }; 451 452 for (size_t k = 0; k < ARRAYSIZE_UNSAFE(keys); ++k) { 453 int x_keycode = XKeysymToKeycode(display, keys[k].x_keysym); 454 // Exclude keysyms for which the server has no corresponding keycode. 455 if (x_keycode) { 456 InitKeyEvent(display, &event, true, x_keycode, 0); 457 // int keysym = XLookupKeysym(&event.xkey, 0); 458 // if (keysym) { 459 ui::KeyEvent ui_key_event(&event); 460 EXPECT_EQ(keys[k].is_numpad_key ? ui::EF_NUMPAD_KEY : 0, 461 ui_key_event.flags() & ui::EF_NUMPAD_KEY); 462 } 463 } 464 } 465 466 TEST_F(EventsXTest, FunctionKeyEvents) { 467 Display* display = gfx::GetXDisplay(); 468 469 // Min function key code minus 1. 470 EXPECT_FALSE(HasFunctionKeyFlagSetIfSupported(display, XK_F1 - 1)); 471 // All function keys. 472 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F1)); 473 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F2)); 474 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F3)); 475 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F4)); 476 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F5)); 477 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F6)); 478 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F7)); 479 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F8)); 480 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F9)); 481 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F10)); 482 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F11)); 483 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F12)); 484 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F13)); 485 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F14)); 486 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F15)); 487 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F16)); 488 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F17)); 489 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F18)); 490 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F19)); 491 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F20)); 492 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F21)); 493 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F22)); 494 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F23)); 495 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F24)); 496 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F25)); 497 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F26)); 498 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F27)); 499 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F28)); 500 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F29)); 501 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F30)); 502 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F31)); 503 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F32)); 504 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F33)); 505 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F34)); 506 EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F35)); 507 // Max function key code plus 1. 508 EXPECT_FALSE(HasFunctionKeyFlagSetIfSupported(display, XK_F35 + 1)); 509 } 510 511 #if defined(USE_XI2_MT) 512 // Verifies that the type of events from a disabled keyboard is ET_UNKNOWN, but 513 // that an exception list of keys can still be processed. 514 TEST_F(EventsXTest, DisableKeyboard) { 515 DeviceDataManagerX11* device_data_manager = 516 static_cast<DeviceDataManagerX11*>( 517 DeviceDataManager::GetInstance()); 518 unsigned int blocked_device_id = 1; 519 unsigned int other_device_id = 2; 520 unsigned int master_device_id = 3; 521 device_data_manager->DisableDevice(blocked_device_id); 522 523 scoped_ptr<std::set<KeyboardCode> > excepted_keys(new std::set<KeyboardCode>); 524 excepted_keys->insert(VKEY_B); 525 device_data_manager->SetDisabledKeyboardAllowedKeys(excepted_keys.Pass()); 526 527 ScopedXI2Event xev; 528 // A is not allowed on the blocked keyboard, and should return ET_UNKNOWN. 529 xev.InitGenericKeyEvent(master_device_id, 530 blocked_device_id, 531 ui::ET_KEY_PRESSED, 532 ui::VKEY_A, 533 0); 534 EXPECT_EQ(ui::ET_UNKNOWN, ui::EventTypeFromNative(xev)); 535 536 // The B key is allowed as an exception, and should return KEY_PRESSED. 537 xev.InitGenericKeyEvent(master_device_id, 538 blocked_device_id, 539 ui::ET_KEY_PRESSED, 540 ui::VKEY_B, 541 0); 542 EXPECT_EQ(ui::ET_KEY_PRESSED, ui::EventTypeFromNative(xev)); 543 544 // Both A and B are allowed on an unblocked keyboard device. 545 xev.InitGenericKeyEvent(master_device_id, 546 other_device_id, 547 ui::ET_KEY_PRESSED, 548 ui::VKEY_A, 549 0); 550 EXPECT_EQ(ui::ET_KEY_PRESSED, ui::EventTypeFromNative(xev)); 551 xev.InitGenericKeyEvent(master_device_id, 552 other_device_id, 553 ui::ET_KEY_PRESSED, 554 ui::VKEY_B, 555 0); 556 EXPECT_EQ(ui::ET_KEY_PRESSED, ui::EventTypeFromNative(xev)); 557 558 device_data_manager->EnableDevice(blocked_device_id); 559 device_data_manager->SetDisabledKeyboardAllowedKeys( 560 scoped_ptr<std::set<KeyboardCode> >()); 561 562 // A key returns KEY_PRESSED as per usual now that keyboard was re-enabled. 563 xev.InitGenericKeyEvent(master_device_id, 564 blocked_device_id, 565 ui::ET_KEY_PRESSED, 566 ui::VKEY_A, 567 0); 568 EXPECT_EQ(ui::ET_KEY_PRESSED, ui::EventTypeFromNative(xev)); 569 } 570 571 // Verifies that the type of events from a disabled mouse is ET_UNKNOWN. 572 TEST_F(EventsXTest, DisableMouse) { 573 DeviceDataManagerX11* device_data_manager = 574 static_cast<DeviceDataManagerX11*>( 575 DeviceDataManager::GetInstance()); 576 unsigned int blocked_device_id = 1; 577 unsigned int other_device_id = 2; 578 std::vector<unsigned int> device_list; 579 device_list.push_back(blocked_device_id); 580 device_list.push_back(other_device_id); 581 TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list); 582 583 device_data_manager->DisableDevice(blocked_device_id); 584 585 ScopedXI2Event xev; 586 xev.InitGenericButtonEvent(blocked_device_id, ET_MOUSE_PRESSED, gfx::Point(), 587 EF_LEFT_MOUSE_BUTTON); 588 EXPECT_EQ(ui::ET_UNKNOWN, ui::EventTypeFromNative(xev)); 589 590 xev.InitGenericButtonEvent(other_device_id, ET_MOUSE_PRESSED, gfx::Point(), 591 EF_LEFT_MOUSE_BUTTON); 592 EXPECT_EQ(ui::ET_MOUSE_PRESSED, ui::EventTypeFromNative(xev)); 593 594 device_data_manager->EnableDevice(blocked_device_id); 595 596 xev.InitGenericButtonEvent(blocked_device_id, ET_MOUSE_PRESSED, gfx::Point(), 597 EF_LEFT_MOUSE_BUTTON); 598 EXPECT_EQ(ui::ET_MOUSE_PRESSED, ui::EventTypeFromNative(xev)); 599 } 600 #endif // defined(USE_XI2_MT) 601 602 #if !defined(OS_CHROMEOS) 603 TEST_F(EventsXTest, ImeFabricatedKeyEvents) { 604 Display* display = gfx::GetXDisplay(); 605 606 unsigned int state_to_be_fabricated[] = { 607 0, ShiftMask, LockMask, ShiftMask | LockMask, 608 }; 609 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(state_to_be_fabricated); ++i) { 610 unsigned int state = state_to_be_fabricated[i]; 611 for (int is_char = 0; is_char < 2; ++is_char) { 612 XEvent x_event; 613 InitKeyEvent(display, &x_event, true, 0, state); 614 ui::KeyEvent key_event(&x_event); 615 if (is_char) { 616 KeyEventTestApi test_event(&key_event); 617 test_event.set_is_char(true); 618 } 619 EXPECT_TRUE(key_event.flags() & ui::EF_IME_FABRICATED_KEY); 620 } 621 } 622 623 unsigned int state_to_be_not_fabricated[] = { 624 ControlMask, Mod1Mask, Mod2Mask, ShiftMask | ControlMask, 625 }; 626 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(state_to_be_not_fabricated); ++i) { 627 unsigned int state = state_to_be_not_fabricated[i]; 628 for (int is_char = 0; is_char < 2; ++is_char) { 629 XEvent x_event; 630 InitKeyEvent(display, &x_event, true, 0, state); 631 ui::KeyEvent key_event(&x_event); 632 if (is_char) { 633 KeyEventTestApi test_event(&key_event); 634 test_event.set_is_char(true); 635 } 636 EXPECT_FALSE(key_event.flags() & ui::EF_IME_FABRICATED_KEY); 637 } 638 } 639 } 640 #endif 641 642 } // namespace ui 643
