1 // Copyright 2013 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 "ash/sticky_keys/sticky_keys_controller.h" 6 7 #include <X11/Xlib.h> 8 #undef None 9 #undef Bool 10 #undef RootWindow 11 12 #include "ash/shell.h" 13 #include "ash/test/ash_test_base.h" 14 #include "base/bind.h" 15 #include "base/callback.h" 16 #include "base/memory/scoped_vector.h" 17 #include "ui/aura/window.h" 18 #include "ui/aura/window_tree_host.h" 19 #include "ui/events/event_handler.h" 20 #include "ui/events/event_processor.h" 21 #include "ui/events/test/events_test_utils_x11.h" 22 #include "ui/events/x/device_data_manager.h" 23 24 namespace ash { 25 26 namespace { 27 28 // The device id of the test touchpad device. 29 const unsigned int kTouchPadDeviceId = 1; 30 31 } // namespace 32 33 // Keeps a buffer of handled events. 34 class EventBuffer : public ui::EventHandler { 35 public: 36 EventBuffer() {} 37 virtual ~EventBuffer() {} 38 39 void PopEvents(ScopedVector<ui::Event>* events) { 40 events->clear(); 41 events->swap(events_); 42 } 43 44 private: 45 // ui::EventHandler overrides: 46 virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE { 47 events_.push_back(new ui::KeyEvent(*event)); 48 } 49 50 virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE { 51 if (event->IsMouseWheelEvent()) { 52 events_.push_back( 53 new ui::MouseWheelEvent(*static_cast<ui::MouseWheelEvent*>(event))); 54 } else { 55 events_.push_back(new ui::MouseEvent(*event)); 56 } 57 } 58 59 ScopedVector<ui::Event> events_; 60 61 DISALLOW_COPY_AND_ASSIGN(EventBuffer); 62 }; 63 64 // A testable and StickyKeysHandler. 65 class MockStickyKeysHandlerDelegate : 66 public StickyKeysHandler::StickyKeysHandlerDelegate { 67 public: 68 class Delegate { 69 public: 70 virtual aura::Window* GetExpectedTarget() = 0; 71 virtual void OnShortcutPressed() = 0; 72 73 protected: 74 virtual ~Delegate() {} 75 }; 76 77 MockStickyKeysHandlerDelegate(Delegate* delegate) : delegate_(delegate) {} 78 79 virtual ~MockStickyKeysHandlerDelegate() {} 80 81 // StickyKeysHandler override. 82 virtual void DispatchKeyEvent(ui::KeyEvent* event, 83 aura::Window* target) OVERRIDE { 84 ASSERT_EQ(delegate_->GetExpectedTarget(), target); 85 86 // Detect a special shortcut when it is dispatched. This shortcut will 87 // not be hit in the LOCKED state as this case does not involve the 88 // delegate. 89 if (event->type() == ui::ET_KEY_PRESSED && 90 event->key_code() == ui::VKEY_J && 91 event->flags() | ui::EF_CONTROL_DOWN) { 92 delegate_->OnShortcutPressed(); 93 } 94 95 events_.push_back(new ui::KeyEvent(*event)); 96 } 97 98 virtual void DispatchMouseEvent(ui::MouseEvent* event, 99 aura::Window* target) OVERRIDE { 100 ASSERT_EQ(delegate_->GetExpectedTarget(), target); 101 events_.push_back( 102 new ui::MouseEvent(*event, target, target->GetRootWindow())); 103 } 104 105 virtual void DispatchScrollEvent(ui::ScrollEvent* event, 106 aura::Window* target) OVERRIDE { 107 events_.push_back(new ui::ScrollEvent(event->native_event())); 108 } 109 110 // Returns the count of dispatched events. 111 size_t GetEventCount() const { 112 return events_.size(); 113 } 114 115 // Returns the |index|-th dispatched event. 116 const ui::Event* GetEvent(size_t index) const { 117 return events_[index]; 118 } 119 120 // Clears all previously dispatched events. 121 void ClearEvents() { 122 events_.clear(); 123 } 124 125 private: 126 ScopedVector<ui::Event> events_; 127 Delegate* delegate_; 128 129 DISALLOW_COPY_AND_ASSIGN(MockStickyKeysHandlerDelegate); 130 }; 131 132 class StickyKeysTest : public test::AshTestBase, 133 public MockStickyKeysHandlerDelegate::Delegate { 134 protected: 135 StickyKeysTest() 136 : target_(NULL), 137 root_window_(NULL) {} 138 139 virtual void SetUp() OVERRIDE { 140 test::AshTestBase::SetUp(); 141 142 // |target_| owned by root window of shell. It is still safe to delete 143 // it ourselves. 144 target_ = CreateTestWindowInShellWithId(0); 145 root_window_ = target_->GetRootWindow(); 146 147 ui::SetUpTouchPadForTest(kTouchPadDeviceId); 148 } 149 150 virtual void TearDown() OVERRIDE { 151 test::AshTestBase::TearDown(); 152 } 153 154 // Overridden from MockStickyKeysHandlerDelegate::Delegate: 155 virtual aura::Window* GetExpectedTarget() OVERRIDE { 156 return target_ ? target_ : root_window_; 157 } 158 159 virtual void OnShortcutPressed() OVERRIDE { 160 if (target_) { 161 delete target_; 162 target_ = NULL; 163 } 164 } 165 166 ui::KeyEvent* GenerateKey(bool is_key_press, ui::KeyboardCode code) { 167 scoped_xevent_.InitKeyEvent( 168 is_key_press ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED, 169 code, 170 0); 171 ui::KeyEvent* event = new ui::KeyEvent(scoped_xevent_, false); 172 ui::Event::DispatcherApi dispatcher(event); 173 dispatcher.set_target(target_); 174 return event; 175 } 176 177 // Creates a mouse event backed by a native XInput2 generic button event. 178 // This is the standard native event on Chromebooks. 179 ui::MouseEvent* GenerateMouseEvent(bool is_button_press) { 180 return GenerateMouseEventAt(is_button_press, gfx::Point()); 181 } 182 183 // Creates a mouse event backed by a native XInput2 generic button event. 184 // The |location| should be in physical pixels. 185 ui::MouseEvent* GenerateMouseEventAt(bool is_button_press, 186 const gfx::Point& location) { 187 scoped_xevent_.InitGenericButtonEvent( 188 kTouchPadDeviceId, 189 is_button_press ? ui::ET_MOUSE_PRESSED : ui::ET_MOUSE_RELEASED, 190 location, 191 0); 192 ui::MouseEvent* event = new ui::MouseEvent(scoped_xevent_); 193 ui::Event::DispatcherApi dispatcher(event); 194 dispatcher.set_target(target_); 195 return event; 196 } 197 198 ui::MouseWheelEvent* GenerateMouseWheelEvent(int wheel_delta) { 199 EXPECT_NE(0, wheel_delta); 200 scoped_xevent_.InitGenericMouseWheelEvent( 201 kTouchPadDeviceId, wheel_delta, 0); 202 ui::MouseWheelEvent* event = new ui::MouseWheelEvent(scoped_xevent_); 203 ui::Event::DispatcherApi dispatcher(event); 204 dispatcher.set_target(target_); 205 return event; 206 } 207 208 ui::ScrollEvent* GenerateScrollEvent(int scroll_delta) { 209 scoped_xevent_.InitScrollEvent(kTouchPadDeviceId, // deviceid 210 0, // x_offset 211 scroll_delta, // y_offset 212 0, // x_offset_ordinal 213 scroll_delta, // y_offset_ordinal 214 2); // finger_count 215 ui::ScrollEvent* event = new ui::ScrollEvent(scoped_xevent_); 216 ui::Event::DispatcherApi dispatcher(event); 217 dispatcher.set_target(target_); 218 return event; 219 } 220 221 ui::ScrollEvent* GenerateFlingScrollEvent(int fling_delta, 222 bool is_cancel) { 223 scoped_xevent_.InitFlingScrollEvent( 224 kTouchPadDeviceId, // deviceid 225 0, // x_velocity 226 fling_delta, // y_velocity 227 0, // x_velocity_ordinal 228 fling_delta, // y_velocity_ordinal 229 is_cancel); // is_cancel 230 ui::ScrollEvent* event = new ui::ScrollEvent(scoped_xevent_); 231 ui::Event::DispatcherApi dispatcher(event); 232 dispatcher.set_target(target_); 233 return event; 234 } 235 236 // Creates a synthesized KeyEvent that is not backed by a native event. 237 ui::KeyEvent* GenerateSynthesizedKeyEvent( 238 bool is_key_press, ui::KeyboardCode code) { 239 ui::KeyEvent* event = new ui::KeyEvent( 240 is_key_press ? ui::ET_KEY_PRESSED : ui::ET_MOUSE_RELEASED, 241 code, 0, true); 242 ui::Event::DispatcherApi dispatcher(event); 243 dispatcher.set_target(target_); 244 return event; 245 } 246 247 // Creates a synthesized MouseEvent that is not backed by a native event. 248 ui::MouseEvent* GenerateSynthesizedMouseEventAt(ui::EventType event_type, 249 const gfx::Point& location) { 250 ui::MouseEvent* event = new ui::MouseEvent(event_type, 251 location, 252 location, 253 ui::EF_LEFT_MOUSE_BUTTON, 254 ui::EF_LEFT_MOUSE_BUTTON); 255 ui::Event::DispatcherApi dispatcher(event); 256 dispatcher.set_target(target_); 257 return event; 258 } 259 260 // Creates a synthesized mouse press or release event. 261 ui::MouseEvent* GenerateSynthesizedMouseClickEvent( 262 bool is_button_press, 263 const gfx::Point& location) { 264 return GenerateSynthesizedMouseEventAt( 265 is_button_press ? ui::ET_MOUSE_PRESSED : ui::ET_MOUSE_RELEASED, 266 location); 267 } 268 269 // Creates a synthesized ET_MOUSE_MOVED event. 270 ui::MouseEvent* GenerateSynthesizedMouseMoveEvent( 271 const gfx::Point& location) { 272 return GenerateSynthesizedMouseEventAt(ui::ET_MOUSE_MOVED, location); 273 } 274 275 // Creates a synthesized MouseWHeel event. 276 ui::MouseWheelEvent* GenerateSynthesizedMouseWheelEvent(int wheel_delta) { 277 scoped_ptr<ui::MouseEvent> mev( 278 GenerateSynthesizedMouseEventAt(ui::ET_MOUSEWHEEL, gfx::Point(0, 0))); 279 ui::MouseWheelEvent* event = new ui::MouseWheelEvent(*mev, 0, wheel_delta); 280 ui::Event::DispatcherApi dispatcher(event); 281 dispatcher.set_target(target_); 282 return event; 283 } 284 285 void SendActivateStickyKeyPattern(StickyKeysHandler* handler, 286 ui::KeyboardCode key_code) { 287 scoped_ptr<ui::KeyEvent> ev; 288 ev.reset(GenerateKey(true, key_code)); 289 handler->HandleKeyEvent(ev.get()); 290 ev.reset(GenerateKey(false, key_code)); 291 handler->HandleKeyEvent(ev.get()); 292 } 293 294 void SendActivateStickyKeyPattern(ui::EventProcessor* dispatcher, 295 ui::KeyboardCode key_code) { 296 scoped_ptr<ui::KeyEvent> ev; 297 ev.reset(GenerateKey(true, key_code)); 298 ui::EventDispatchDetails details = dispatcher->OnEventFromSource(ev.get()); 299 CHECK(!details.dispatcher_destroyed); 300 ev.reset(GenerateKey(false, key_code)); 301 details = dispatcher->OnEventFromSource(ev.get()); 302 CHECK(!details.dispatcher_destroyed); 303 } 304 305 aura::Window* target() { return target_; } 306 307 private: 308 // Owned by root window of shell, but we can still delete |target_| safely. 309 aura::Window* target_; 310 // The root window of |target_|. Not owned. 311 aura::Window* root_window_; 312 313 // Used to construct the various X events. 314 ui::ScopedXI2Event scoped_xevent_; 315 316 DISALLOW_COPY_AND_ASSIGN(StickyKeysTest); 317 }; 318 319 TEST_F(StickyKeysTest, BasicOneshotScenarioTest) { 320 scoped_ptr<ui::KeyEvent> ev; 321 MockStickyKeysHandlerDelegate* mock_delegate = 322 new MockStickyKeysHandlerDelegate(this); 323 StickyKeysHandler sticky_key(ui::EF_SHIFT_DOWN, mock_delegate); 324 325 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 326 327 // By typing Shift key, internal state become ENABLED. 328 SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_SHIFT); 329 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 330 331 ev.reset(GenerateKey(true, ui::VKEY_A)); 332 sticky_key.HandleKeyEvent(ev.get()); 333 334 // Next keyboard event is shift modified. 335 EXPECT_TRUE(ev->flags() & ui::EF_SHIFT_DOWN); 336 337 ev.reset(GenerateKey(false, ui::VKEY_A)); 338 sticky_key.HandleKeyEvent(ev.get()); 339 340 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 341 // Making sure Shift up keyboard event is dispatched. 342 ASSERT_EQ(2U, mock_delegate->GetEventCount()); 343 EXPECT_EQ(ui::ET_KEY_PRESSED, mock_delegate->GetEvent(0)->type()); 344 EXPECT_EQ(ui::VKEY_A, 345 static_cast<const ui::KeyEvent*>(mock_delegate->GetEvent(0)) 346 ->key_code()); 347 EXPECT_EQ(ui::ET_KEY_RELEASED, mock_delegate->GetEvent(1)->type()); 348 EXPECT_EQ(ui::VKEY_SHIFT, 349 static_cast<const ui::KeyEvent*>(mock_delegate->GetEvent(1)) 350 ->key_code()); 351 352 // Enabled state is one shot, so next key event should not be shift modified. 353 ev.reset(GenerateKey(true, ui::VKEY_A)); 354 sticky_key.HandleKeyEvent(ev.get()); 355 EXPECT_FALSE(ev->flags() & ui::EF_SHIFT_DOWN); 356 357 ev.reset(GenerateKey(false, ui::VKEY_A)); 358 sticky_key.HandleKeyEvent(ev.get()); 359 EXPECT_FALSE(ev->flags() & ui::EF_SHIFT_DOWN); 360 } 361 362 TEST_F(StickyKeysTest, BasicLockedScenarioTest) { 363 scoped_ptr<ui::KeyEvent> ev; 364 MockStickyKeysHandlerDelegate* mock_delegate = 365 new MockStickyKeysHandlerDelegate(this); 366 StickyKeysHandler sticky_key(ui::EF_SHIFT_DOWN, mock_delegate); 367 368 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 369 370 // By typing shift key, internal state become ENABLED. 371 SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_SHIFT); 372 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 373 374 // By typing shift key again, internal state become LOCKED. 375 SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_SHIFT); 376 EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state()); 377 378 // All keyboard events including keyUp become shift modified. 379 ev.reset(GenerateKey(true, ui::VKEY_A)); 380 sticky_key.HandleKeyEvent(ev.get()); 381 EXPECT_TRUE(ev->flags() & ui::EF_SHIFT_DOWN); 382 383 ev.reset(GenerateKey(false, ui::VKEY_A)); 384 sticky_key.HandleKeyEvent(ev.get()); 385 EXPECT_TRUE(ev->flags() & ui::EF_SHIFT_DOWN); 386 387 // Locked state keeps after normal keyboard event. 388 EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state()); 389 390 ev.reset(GenerateKey(true, ui::VKEY_B)); 391 sticky_key.HandleKeyEvent(ev.get()); 392 EXPECT_TRUE(ev->flags() & ui::EF_SHIFT_DOWN); 393 394 ev.reset(GenerateKey(false, ui::VKEY_B)); 395 sticky_key.HandleKeyEvent(ev.get()); 396 EXPECT_TRUE(ev->flags() & ui::EF_SHIFT_DOWN); 397 398 EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state()); 399 400 // By typing shift key again, internal state become back to DISABLED. 401 SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_SHIFT); 402 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 403 } 404 405 TEST_F(StickyKeysTest, NonTargetModifierTest) { 406 scoped_ptr<ui::KeyEvent> ev; 407 MockStickyKeysHandlerDelegate* mock_delegate = 408 new MockStickyKeysHandlerDelegate(this); 409 StickyKeysHandler sticky_key(ui::EF_SHIFT_DOWN, mock_delegate); 410 411 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 412 413 // Non target modifier key does not affect internal state 414 ev.reset(GenerateKey(true, ui::VKEY_MENU)); 415 sticky_key.HandleKeyEvent(ev.get()); 416 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 417 418 ev.reset(GenerateKey(false, ui::VKEY_MENU)); 419 sticky_key.HandleKeyEvent(ev.get()); 420 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 421 422 SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_SHIFT); 423 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 424 425 // Non target modifier key does not affect internal state 426 ev.reset(GenerateKey(true, ui::VKEY_MENU)); 427 sticky_key.HandleKeyEvent(ev.get()); 428 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 429 430 ev.reset(GenerateKey(false, ui::VKEY_MENU)); 431 sticky_key.HandleKeyEvent(ev.get()); 432 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 433 434 SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_SHIFT); 435 EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state()); 436 437 // Non target modifier key does not affect internal state 438 ev.reset(GenerateKey(true, ui::VKEY_MENU)); 439 sticky_key.HandleKeyEvent(ev.get()); 440 EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state()); 441 442 ev.reset(GenerateKey(false, ui::VKEY_MENU)); 443 sticky_key.HandleKeyEvent(ev.get()); 444 EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state()); 445 } 446 447 TEST_F(StickyKeysTest, NormalShortcutTest) { 448 // Sticky keys should not be enabled if we perform a normal shortcut. 449 scoped_ptr<ui::KeyEvent> ev; 450 MockStickyKeysHandlerDelegate* mock_delegate = 451 new MockStickyKeysHandlerDelegate(this); 452 StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate); 453 454 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 455 456 // Perform ctrl+n shortcut. 457 ev.reset(GenerateKey(true, ui::VKEY_CONTROL)); 458 sticky_key.HandleKeyEvent(ev.get()); 459 ev.reset(GenerateKey(true, ui::VKEY_N)); 460 sticky_key.HandleKeyEvent(ev.get()); 461 ev.reset(GenerateKey(false, ui::VKEY_N)); 462 sticky_key.HandleKeyEvent(ev.get()); 463 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 464 465 // Sticky keys should not be enabled afterwards. 466 ev.reset(GenerateKey(false, ui::VKEY_CONTROL)); 467 sticky_key.HandleKeyEvent(ev.get()); 468 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 469 } 470 471 TEST_F(StickyKeysTest, NormalModifiedClickTest) { 472 scoped_ptr<ui::KeyEvent> kev; 473 scoped_ptr<ui::MouseEvent> mev; 474 MockStickyKeysHandlerDelegate* mock_delegate = 475 new MockStickyKeysHandlerDelegate(this); 476 StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate); 477 478 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 479 480 // Perform ctrl+click. 481 kev.reset(GenerateKey(true, ui::VKEY_CONTROL)); 482 sticky_key.HandleKeyEvent(kev.get()); 483 mev.reset(GenerateMouseEvent(true)); 484 sticky_key.HandleMouseEvent(mev.get()); 485 mev.reset(GenerateMouseEvent(false)); 486 sticky_key.HandleMouseEvent(mev.get()); 487 488 // Sticky keys should not be enabled afterwards. 489 kev.reset(GenerateKey(false, ui::VKEY_CONTROL)); 490 sticky_key.HandleKeyEvent(kev.get()); 491 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 492 } 493 494 TEST_F(StickyKeysTest, MouseMovedModifierTest) { 495 scoped_ptr<ui::KeyEvent> kev; 496 scoped_ptr<ui::MouseEvent> mev; 497 MockStickyKeysHandlerDelegate* mock_delegate = 498 new MockStickyKeysHandlerDelegate(this); 499 StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate); 500 501 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 502 503 // Press ctrl and handle mouse move events. 504 kev.reset(GenerateKey(true, ui::VKEY_CONTROL)); 505 sticky_key.HandleKeyEvent(kev.get()); 506 mev.reset(GenerateSynthesizedMouseMoveEvent(gfx::Point(0, 0))); 507 sticky_key.HandleMouseEvent(mev.get()); 508 mev.reset(GenerateSynthesizedMouseMoveEvent(gfx::Point(100, 100))); 509 sticky_key.HandleMouseEvent(mev.get()); 510 511 // Sticky keys should be enabled afterwards. 512 kev.reset(GenerateKey(false, ui::VKEY_CONTROL)); 513 sticky_key.HandleKeyEvent(kev.get()); 514 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 515 } 516 517 TEST_F(StickyKeysTest, NormalModifiedScrollTest) { 518 scoped_ptr<ui::KeyEvent> kev; 519 scoped_ptr<ui::ScrollEvent> sev; 520 MockStickyKeysHandlerDelegate* mock_delegate = 521 new MockStickyKeysHandlerDelegate(this); 522 StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate); 523 524 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 525 526 // Perform ctrl+scroll. 527 kev.reset(GenerateKey(true, ui::VKEY_CONTROL)); 528 sev.reset(GenerateFlingScrollEvent(0, true)); 529 sticky_key.HandleScrollEvent(sev.get()); 530 sev.reset(GenerateScrollEvent(10)); 531 sticky_key.HandleScrollEvent(sev.get()); 532 sev.reset(GenerateFlingScrollEvent(10, false)); 533 sticky_key.HandleScrollEvent(sev.get()); 534 535 // Sticky keys should not be enabled afterwards. 536 kev.reset(GenerateKey(false, ui::VKEY_CONTROL)); 537 sticky_key.HandleKeyEvent(kev.get()); 538 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 539 } 540 541 TEST_F(StickyKeysTest, MouseEventOneshot) { 542 scoped_ptr<ui::MouseEvent> ev; 543 scoped_ptr<ui::KeyEvent> kev; 544 MockStickyKeysHandlerDelegate* mock_delegate = 545 new MockStickyKeysHandlerDelegate(this); 546 StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate); 547 548 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 549 SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL); 550 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 551 552 // We should still be in the ENABLED state until we get the mouse 553 // release event. 554 ev.reset(GenerateMouseEvent(true)); 555 sticky_key.HandleMouseEvent(ev.get()); 556 EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN); 557 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 558 559 ev.reset(GenerateMouseEvent(false)); 560 sticky_key.HandleMouseEvent(ev.get()); 561 EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN); 562 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 563 564 // Making sure modifier key release event is dispatched in the right order. 565 ASSERT_EQ(2u, mock_delegate->GetEventCount()); 566 EXPECT_EQ(ui::ET_MOUSE_RELEASED, mock_delegate->GetEvent(0)->type()); 567 EXPECT_EQ(ui::ET_KEY_RELEASED, mock_delegate->GetEvent(1)->type()); 568 EXPECT_EQ(ui::VKEY_CONTROL, 569 static_cast<const ui::KeyEvent*>(mock_delegate->GetEvent(1)) 570 ->key_code()); 571 572 // Enabled state is one shot, so next click should not be control modified. 573 ev.reset(GenerateMouseEvent(true)); 574 sticky_key.HandleMouseEvent(ev.get()); 575 EXPECT_FALSE(ev->flags() & ui::EF_CONTROL_DOWN); 576 577 ev.reset(GenerateMouseEvent(false)); 578 sticky_key.HandleMouseEvent(ev.get()); 579 EXPECT_FALSE(ev->flags() & ui::EF_CONTROL_DOWN); 580 } 581 582 TEST_F(StickyKeysTest, MouseEventLocked) { 583 scoped_ptr<ui::MouseEvent> ev; 584 scoped_ptr<ui::KeyEvent> kev; 585 MockStickyKeysHandlerDelegate* mock_delegate = 586 new MockStickyKeysHandlerDelegate(this); 587 StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate); 588 589 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 590 591 // Pressing modifier key twice should make us enter lock state. 592 SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL); 593 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 594 SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL); 595 EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state()); 596 597 // Mouse events should not disable locked mode. 598 for (int i = 0; i < 3; ++i) { 599 ev.reset(GenerateMouseEvent(true)); 600 sticky_key.HandleMouseEvent(ev.get()); 601 EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN); 602 ev.reset(GenerateMouseEvent(false)); 603 sticky_key.HandleMouseEvent(ev.get()); 604 EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN); 605 EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state()); 606 } 607 608 // Test with mouse wheel. 609 for (int i = 0; i < 3; ++i) { 610 ev.reset(GenerateMouseWheelEvent(ui::MouseWheelEvent::kWheelDelta)); 611 sticky_key.HandleMouseEvent(ev.get()); 612 ev.reset(GenerateMouseWheelEvent(-ui::MouseWheelEvent::kWheelDelta)); 613 sticky_key.HandleMouseEvent(ev.get()); 614 EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN); 615 EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state()); 616 } 617 618 // Test mixed case with mouse events and key events. 619 ev.reset(GenerateMouseWheelEvent(ui::MouseWheelEvent::kWheelDelta)); 620 sticky_key.HandleMouseEvent(ev.get()); 621 EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN); 622 kev.reset(GenerateKey(true, ui::VKEY_N)); 623 sticky_key.HandleKeyEvent(kev.get()); 624 EXPECT_TRUE(kev->flags() & ui::EF_CONTROL_DOWN); 625 kev.reset(GenerateKey(false, ui::VKEY_N)); 626 sticky_key.HandleKeyEvent(kev.get()); 627 EXPECT_TRUE(kev->flags() & ui::EF_CONTROL_DOWN); 628 629 EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state()); 630 } 631 632 TEST_F(StickyKeysTest, ScrollEventOneshot) { 633 scoped_ptr<ui::ScrollEvent> ev; 634 scoped_ptr<ui::KeyEvent> kev; 635 MockStickyKeysHandlerDelegate* mock_delegate = 636 new MockStickyKeysHandlerDelegate(this); 637 StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate); 638 639 int scroll_deltas[] = {-10, 10}; 640 for (int i = 0; i < 2; ++i) { 641 mock_delegate->ClearEvents(); 642 643 // Enable sticky keys. 644 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 645 SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL); 646 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 647 648 // Test a scroll sequence. Sticky keys should only be disabled at the end 649 // of the scroll sequence. Fling cancel event starts the scroll sequence. 650 ev.reset(GenerateFlingScrollEvent(0, true)); 651 sticky_key.HandleScrollEvent(ev.get()); 652 EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN); 653 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 654 655 // Scrolls should all be modified but not disable sticky keys. 656 for (int j = 0; j < 3; ++j) { 657 ev.reset(GenerateScrollEvent(scroll_deltas[i])); 658 sticky_key.HandleScrollEvent(ev.get()); 659 EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN); 660 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 661 } 662 663 // Fling start event ends scroll sequence. 664 ev.reset(GenerateFlingScrollEvent(scroll_deltas[i], false)); 665 sticky_key.HandleScrollEvent(ev.get()); 666 EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN); 667 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 668 669 ASSERT_EQ(2U, mock_delegate->GetEventCount()); 670 EXPECT_EQ(ui::ET_SCROLL_FLING_START, mock_delegate->GetEvent(0)->type()); 671 EXPECT_FLOAT_EQ(scroll_deltas[i], 672 static_cast<const ui::ScrollEvent*>( 673 mock_delegate->GetEvent(0))->y_offset()); 674 EXPECT_EQ(ui::ET_KEY_RELEASED, mock_delegate->GetEvent(1)->type()); 675 EXPECT_EQ(ui::VKEY_CONTROL, 676 static_cast<const ui::KeyEvent*>(mock_delegate->GetEvent(1)) 677 ->key_code()); 678 } 679 } 680 681 TEST_F(StickyKeysTest, ScrollDirectionChanged) { 682 scoped_ptr<ui::ScrollEvent> ev; 683 scoped_ptr<ui::KeyEvent> kev; 684 MockStickyKeysHandlerDelegate* mock_delegate = 685 new MockStickyKeysHandlerDelegate(this); 686 StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate); 687 688 // Test direction change with both boundary value and negative value. 689 const int direction_change_values[2] = {0, -10}; 690 for (int i = 0; i < 2; ++i) { 691 SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL); 692 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 693 694 // Fling cancel starts scroll sequence. 695 ev.reset(GenerateFlingScrollEvent(0, true)); 696 sticky_key.HandleScrollEvent(ev.get()); 697 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 698 699 // Test that changing directions in a scroll sequence will 700 // return sticky keys to DISABLED state. 701 for (int j = 0; j < 3; ++j) { 702 ev.reset(GenerateScrollEvent(10)); 703 sticky_key.HandleScrollEvent(ev.get()); 704 EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN); 705 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 706 } 707 708 ev.reset(GenerateScrollEvent(direction_change_values[i])); 709 sticky_key.HandleScrollEvent(ev.get()); 710 EXPECT_FALSE(ev->flags() & ui::EF_CONTROL_DOWN); 711 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 712 } 713 } 714 715 TEST_F(StickyKeysTest, ScrollEventLocked) { 716 scoped_ptr<ui::ScrollEvent> ev; 717 scoped_ptr<ui::KeyEvent> kev; 718 MockStickyKeysHandlerDelegate* mock_delegate = 719 new MockStickyKeysHandlerDelegate(this); 720 StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate); 721 722 // Lock sticky keys. 723 SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL); 724 SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL); 725 EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state()); 726 727 // Test scroll events are correctly modified in locked state. 728 for (int i = 0; i < 5; ++i) { 729 // Fling cancel starts scroll sequence. 730 ev.reset(GenerateFlingScrollEvent(0, true)); 731 sticky_key.HandleScrollEvent(ev.get()); 732 733 ev.reset(GenerateScrollEvent(10)); 734 sticky_key.HandleScrollEvent(ev.get()); 735 EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN); 736 ev.reset(GenerateScrollEvent(-10)); 737 sticky_key.HandleScrollEvent(ev.get()); 738 EXPECT_TRUE(ev->flags() & ui::EF_CONTROL_DOWN); 739 740 // Fling start ends scroll sequence. 741 ev.reset(GenerateFlingScrollEvent(-10, false)); 742 sticky_key.HandleScrollEvent(ev.get()); 743 } 744 745 EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state()); 746 } 747 748 TEST_F(StickyKeysTest, EventTargetDestroyed) { 749 scoped_ptr<ui::KeyEvent> ev; 750 MockStickyKeysHandlerDelegate* mock_delegate = 751 new MockStickyKeysHandlerDelegate(this); 752 StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate); 753 754 target()->Focus(); 755 756 // Go into ENABLED state. 757 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 758 SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL); 759 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 760 761 // CTRL+J is a special shortcut that will destroy the event target. 762 ev.reset(GenerateKey(true, ui::VKEY_J)); 763 sticky_key.HandleKeyEvent(ev.get()); 764 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 765 EXPECT_FALSE(target()); 766 } 767 768 TEST_F(StickyKeysTest, SynthesizedEvents) { 769 // Non-native, internally generated events should be properly handled 770 // by sticky keys. 771 MockStickyKeysHandlerDelegate* mock_delegate = 772 new MockStickyKeysHandlerDelegate(this); 773 StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN, mock_delegate); 774 775 // Test non-native key events. 776 scoped_ptr<ui::KeyEvent> kev; 777 SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL); 778 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 779 780 kev.reset(GenerateSynthesizedKeyEvent(true, ui::VKEY_K)); 781 sticky_key.HandleKeyEvent(kev.get()); 782 EXPECT_TRUE(kev->flags() & ui::EF_CONTROL_DOWN); 783 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 784 785 kev.reset(GenerateSynthesizedKeyEvent(false, ui::VKEY_K)); 786 sticky_key.HandleKeyEvent(kev.get()); 787 EXPECT_FALSE(kev->flags() & ui::EF_CONTROL_DOWN); 788 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 789 790 // Test non-native mouse events. 791 SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL); 792 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 793 794 scoped_ptr<ui::MouseEvent> mev; 795 mev.reset(GenerateSynthesizedMouseClickEvent(true, gfx::Point(0, 0))); 796 sticky_key.HandleMouseEvent(mev.get()); 797 EXPECT_TRUE(mev->flags() & ui::EF_CONTROL_DOWN); 798 EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state()); 799 800 mev.reset(GenerateSynthesizedMouseClickEvent(false, gfx::Point(0, 0))); 801 sticky_key.HandleMouseEvent(mev.get()); 802 EXPECT_TRUE(mev->flags() & ui::EF_CONTROL_DOWN); 803 EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state()); 804 } 805 806 TEST_F(StickyKeysTest, KeyEventDispatchImpl) { 807 // Test the actual key event dispatch implementation. 808 EventBuffer buffer; 809 ScopedVector<ui::Event> events; 810 ui::EventProcessor* dispatcher = 811 Shell::GetPrimaryRootWindow()->GetHost()->event_processor(); 812 Shell::GetInstance()->AddPreTargetHandler(&buffer); 813 Shell::GetInstance()->sticky_keys_controller()->Enable(true); 814 815 SendActivateStickyKeyPattern(dispatcher, ui::VKEY_CONTROL); 816 scoped_ptr<ui::KeyEvent> ev; 817 buffer.PopEvents(&events); 818 819 // Test key press event is correctly modified and modifier release 820 // event is sent. 821 ev.reset(GenerateKey(true, ui::VKEY_C)); 822 ui::EventDispatchDetails details = dispatcher->OnEventFromSource(ev.get()); 823 buffer.PopEvents(&events); 824 EXPECT_EQ(2u, events.size()); 825 EXPECT_EQ(ui::ET_KEY_PRESSED, events[0]->type()); 826 EXPECT_EQ(ui::VKEY_C, static_cast<ui::KeyEvent*>(events[0])->key_code()); 827 EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN); 828 EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type()); 829 EXPECT_EQ(ui::VKEY_CONTROL, 830 static_cast<ui::KeyEvent*>(events[1])->key_code()); 831 832 // Test key release event is not modified. 833 ev.reset(GenerateKey(false, ui::VKEY_C)); 834 details = dispatcher->OnEventFromSource(ev.get()); 835 ASSERT_FALSE(details.dispatcher_destroyed); 836 buffer.PopEvents(&events); 837 EXPECT_EQ(1u, events.size()); 838 EXPECT_EQ(ui::ET_KEY_RELEASED, events[0]->type()); 839 EXPECT_EQ(ui::VKEY_C, 840 static_cast<ui::KeyEvent*>(events[0])->key_code()); 841 EXPECT_FALSE(events[0]->flags() & ui::EF_CONTROL_DOWN); 842 843 // Test that synthesized key events are dispatched correctly. 844 SendActivateStickyKeyPattern(dispatcher, ui::VKEY_CONTROL); 845 buffer.PopEvents(&events); 846 scoped_ptr<ui::KeyEvent> kev; 847 kev.reset(GenerateSynthesizedKeyEvent(true, ui::VKEY_K)); 848 details = dispatcher->OnEventFromSource(kev.get()); 849 ASSERT_FALSE(details.dispatcher_destroyed); 850 buffer.PopEvents(&events); 851 EXPECT_EQ(2u, events.size()); 852 EXPECT_EQ(ui::ET_KEY_PRESSED, events[0]->type()); 853 EXPECT_EQ(ui::VKEY_K, static_cast<ui::KeyEvent*>(events[0])->key_code()); 854 EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN); 855 EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type()); 856 EXPECT_EQ(ui::VKEY_CONTROL, 857 static_cast<ui::KeyEvent*>(events[1])->key_code()); 858 859 Shell::GetInstance()->RemovePreTargetHandler(&buffer); 860 } 861 862 class StickyKeysMouseDispatchTest 863 : public StickyKeysTest, 864 public ::testing::WithParamInterface<int> { 865 }; 866 867 TEST_P(StickyKeysMouseDispatchTest, MouseEventDispatchImpl) { 868 int scale_factor = GetParam(); 869 std::ostringstream display_specs; 870 display_specs << "1280x1024*" << scale_factor; 871 UpdateDisplay(display_specs.str()); 872 873 EventBuffer buffer; 874 ScopedVector<ui::Event> events; 875 ui::EventProcessor* dispatcher = 876 Shell::GetPrimaryRootWindow()->GetHost()->event_processor(); 877 Shell::GetInstance()->AddPreTargetHandler(&buffer); 878 Shell::GetInstance()->sticky_keys_controller()->Enable(true); 879 880 scoped_ptr<ui::MouseEvent> ev; 881 SendActivateStickyKeyPattern(dispatcher, ui::VKEY_CONTROL); 882 buffer.PopEvents(&events); 883 884 // Test mouse press event is correctly modified and has correct DIP location. 885 gfx::Point physical_location(400, 400); 886 gfx::Point dip_location(physical_location.x() / scale_factor, 887 physical_location.y() / scale_factor); 888 ev.reset(GenerateMouseEventAt(true, physical_location)); 889 ui::EventDispatchDetails details = dispatcher->OnEventFromSource(ev.get()); 890 buffer.PopEvents(&events); 891 EXPECT_EQ(1u, events.size()); 892 EXPECT_EQ(ui::ET_MOUSE_PRESSED, events[0]->type()); 893 EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN); 894 EXPECT_EQ(dip_location.ToString(), 895 static_cast<ui::MouseEvent*>(events[0])->location().ToString()); 896 897 // Test mouse release event is correctly modified and modifier release 898 // event is sent. The mouse event should have the correct DIP location. 899 ev.reset(GenerateMouseEventAt(false, physical_location)); 900 details = dispatcher->OnEventFromSource(ev.get()); 901 ASSERT_FALSE(details.dispatcher_destroyed); 902 buffer.PopEvents(&events); 903 EXPECT_EQ(2u, events.size()); 904 EXPECT_EQ(ui::ET_MOUSE_RELEASED, events[0]->type()); 905 EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN); 906 EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type()); 907 EXPECT_EQ(dip_location.ToString(), 908 static_cast<ui::MouseEvent*>(events[0])->location().ToString()); 909 EXPECT_EQ(ui::VKEY_CONTROL, 910 static_cast<ui::KeyEvent*>(events[1])->key_code()); 911 912 // Test synthesized mouse events are dispatched correctly. 913 SendActivateStickyKeyPattern(dispatcher, ui::VKEY_CONTROL); 914 buffer.PopEvents(&events); 915 ev.reset(GenerateSynthesizedMouseClickEvent(false, physical_location)); 916 details = dispatcher->OnEventFromSource(ev.get()); 917 ASSERT_FALSE(details.dispatcher_destroyed); 918 buffer.PopEvents(&events); 919 EXPECT_EQ(2u, events.size()); 920 EXPECT_EQ(ui::ET_MOUSE_RELEASED, events[0]->type()); 921 EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN); 922 EXPECT_EQ(dip_location.ToString(), 923 static_cast<ui::MouseEvent*>(events[0])->location().ToString()); 924 EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type()); 925 EXPECT_EQ(ui::VKEY_CONTROL, 926 static_cast<ui::KeyEvent*>(events[1])->key_code()); 927 928 Shell::GetInstance()->RemovePreTargetHandler(&buffer); 929 } 930 931 TEST_P(StickyKeysMouseDispatchTest, MouseWheelEventDispatchImpl) { 932 int scale_factor = GetParam(); 933 std::ostringstream display_specs; 934 display_specs << "1280x1024*" << scale_factor; 935 UpdateDisplay(display_specs.str()); 936 937 // Test the actual mouse wheel event dispatch implementation. 938 EventBuffer buffer; 939 ScopedVector<ui::Event> events; 940 ui::EventProcessor* dispatcher = 941 Shell::GetPrimaryRootWindow()->GetHost()->event_processor(); 942 Shell::GetInstance()->AddPreTargetHandler(&buffer); 943 Shell::GetInstance()->sticky_keys_controller()->Enable(true); 944 945 scoped_ptr<ui::MouseWheelEvent> ev; 946 SendActivateStickyKeyPattern(dispatcher, ui::VKEY_CONTROL); 947 buffer.PopEvents(&events); 948 949 // Test positive mouse wheel event is correctly modified and modifier release 950 // event is sent. 951 ev.reset(GenerateMouseWheelEvent(ui::MouseWheelEvent::kWheelDelta)); 952 ui::EventDispatchDetails details = dispatcher->OnEventFromSource(ev.get()); 953 ASSERT_FALSE(details.dispatcher_destroyed); 954 buffer.PopEvents(&events); 955 EXPECT_EQ(2u, events.size()); 956 EXPECT_TRUE(events[0]->IsMouseWheelEvent()); 957 EXPECT_EQ(ui::MouseWheelEvent::kWheelDelta / scale_factor, 958 static_cast<ui::MouseWheelEvent*>(events[0])->y_offset()); 959 EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN); 960 EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type()); 961 EXPECT_EQ(ui::VKEY_CONTROL, 962 static_cast<ui::KeyEvent*>(events[1])->key_code()); 963 964 // Test negative mouse wheel event is correctly modified and modifier release 965 // event is sent. 966 SendActivateStickyKeyPattern(dispatcher, ui::VKEY_CONTROL); 967 buffer.PopEvents(&events); 968 969 ev.reset(GenerateMouseWheelEvent(-ui::MouseWheelEvent::kWheelDelta)); 970 details = dispatcher->OnEventFromSource(ev.get()); 971 ASSERT_FALSE(details.dispatcher_destroyed); 972 buffer.PopEvents(&events); 973 EXPECT_EQ(2u, events.size()); 974 EXPECT_TRUE(events[0]->IsMouseWheelEvent()); 975 EXPECT_EQ(-ui::MouseWheelEvent::kWheelDelta / scale_factor, 976 static_cast<ui::MouseWheelEvent*>(events[0])->y_offset()); 977 EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN); 978 EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type()); 979 EXPECT_EQ(ui::VKEY_CONTROL, 980 static_cast<ui::KeyEvent*>(events[1])->key_code()); 981 982 // Test synthesized mouse wheel events are dispatched correctly. 983 SendActivateStickyKeyPattern(dispatcher, ui::VKEY_CONTROL); 984 buffer.PopEvents(&events); 985 ev.reset( 986 GenerateSynthesizedMouseWheelEvent(ui::MouseWheelEvent::kWheelDelta)); 987 details = dispatcher->OnEventFromSource(ev.get()); 988 ASSERT_FALSE(details.dispatcher_destroyed); 989 buffer.PopEvents(&events); 990 EXPECT_EQ(2u, events.size()); 991 EXPECT_TRUE(events[0]->IsMouseWheelEvent()); 992 EXPECT_EQ(ui::MouseWheelEvent::kWheelDelta / scale_factor, 993 static_cast<ui::MouseWheelEvent*>(events[0])->y_offset()); 994 EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN); 995 EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN); 996 EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type()); 997 EXPECT_EQ(ui::VKEY_CONTROL, 998 static_cast<ui::KeyEvent*>(events[1])->key_code()); 999 1000 Shell::GetInstance()->RemovePreTargetHandler(&buffer); 1001 } 1002 1003 INSTANTIATE_TEST_CASE_P(DPIScaleFactors, 1004 StickyKeysMouseDispatchTest, 1005 ::testing::Values(1, 2)); 1006 1007 } // namespace ash 1008
