Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(213)

Side by Side Diff: chrome/browser/chromeos/events/event_rewriter_unittest.cc

Issue 255033003: Convert sticky keys to a chromeos::EventRewriter phase. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@x354034-er
Patch Set: address review comments Created 6 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "chrome/browser/chromeos/events/event_rewriter.h" 5 #include "chrome/browser/chromeos/events/event_rewriter.h"
6 6
7 #include <X11/keysym.h>
8 #include <X11/XF86keysym.h>
9 #include <X11/Xlib.h>
10 #undef Bool
11 #undef None
12 #undef RootWindow
13
14 #include <vector> 7 #include <vector>
15 8
9 #include "ash/shell.h"
10 #include "ash/sticky_keys/sticky_keys_controller.h"
16 #include "ash/test/ash_test_base.h" 11 #include "ash/test/ash_test_base.h"
17 #include "ash/wm/window_state.h" 12 #include "ash/wm/window_state.h"
18 #include "base/basictypes.h" 13 #include "base/basictypes.h"
19 #include "base/command_line.h" 14 #include "base/command_line.h"
20 #include "base/prefs/pref_member.h" 15 #include "base/prefs/pref_member.h"
21 #include "base/strings/stringprintf.h" 16 #include "base/strings/stringprintf.h"
22 #include "chrome/browser/chromeos/input_method/input_method_configuration.h" 17 #include "chrome/browser/chromeos/input_method/input_method_configuration.h"
23 #include "chrome/browser/chromeos/input_method/mock_input_method_manager.h" 18 #include "chrome/browser/chromeos/input_method/mock_input_method_manager.h"
24 #include "chrome/browser/chromeos/login/users/mock_user_manager.h" 19 #include "chrome/browser/chromeos/login/users/mock_user_manager.h"
25 #include "chrome/browser/chromeos/login/users/user_manager.h" 20 #include "chrome/browser/chromeos/login/users/user_manager.h"
26 #include "chrome/browser/chromeos/preferences.h" 21 #include "chrome/browser/chromeos/preferences.h"
27 #include "chrome/common/pref_names.h" 22 #include "chrome/common/pref_names.h"
28 #include "chrome/test/base/testing_pref_service_syncable.h" 23 #include "chrome/test/base/testing_pref_service_syncable.h"
29 #include "chromeos/chromeos_switches.h" 24 #include "chromeos/chromeos_switches.h"
30 #include "chromeos/ime/fake_ime_keyboard.h" 25 #include "chromeos/ime/fake_ime_keyboard.h"
31 #include "testing/gtest/include/gtest/gtest.h" 26 #include "testing/gtest/include/gtest/gtest.h"
32 #include "ui/aura/window.h" 27 #include "ui/aura/window.h"
33 #include "ui/events/event.h" 28 #include "ui/events/event.h"
34 #include "ui/events/event_rewriter.h" 29 #include "ui/events/event_rewriter.h"
30 #include "ui/events/test/test_event_processor.h"
31
32 #if defined(USE_X11)
33 #include <X11/keysym.h>
34
35 #include "ui/events/test/events_test_utils_x11.h" 35 #include "ui/events/test/events_test_utils_x11.h"
36 #include "ui/events/x/touch_factory_x11.h" 36 #include "ui/events/x/touch_factory_x11.h"
37 #include "ui/gfx/x/x11_types.h" 37 #include "ui/gfx/x/x11_types.h"
38 #endif
38 39
39 namespace { 40 namespace {
40 41
42 // The device id of the test touchpad device.
43 const unsigned int kTouchPadDeviceId = 1;
44
41 std::string GetExpectedResultAsString(ui::KeyboardCode ui_keycode, 45 std::string GetExpectedResultAsString(ui::KeyboardCode ui_keycode,
42 int ui_flags, 46 int ui_flags,
43 ui::EventType ui_type) { 47 ui::EventType ui_type) {
44 return base::StringPrintf("ui_keycode=0x%X ui_flags=0x%X ui_type=%d", 48 return base::StringPrintf("ui_keycode=0x%X ui_flags=0x%X ui_type=%d",
45 ui_keycode, 49 ui_keycode,
46 ui_flags & ~ui::EF_IS_REPEAT, 50 ui_flags & ~ui::EF_IS_REPEAT,
47 ui_type); 51 ui_type);
48 } 52 }
49 53
50 std::string GetKeyEventAsString(const ui::KeyEvent& keyevent) { 54 std::string GetKeyEventAsString(const ui::KeyEvent& keyevent) {
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after
135 #endif 139 #endif
136 } 140 }
137 141
138 } // namespace 142 } // namespace
139 143
140 namespace chromeos { 144 namespace chromeos {
141 145
142 class EventRewriterTest : public ash::test::AshTestBase { 146 class EventRewriterTest : public ash::test::AshTestBase {
143 public: 147 public:
144 EventRewriterTest() 148 EventRewriterTest()
145 : display_(gfx::GetXDisplay()), 149 : mock_user_manager_(new chromeos::MockUserManager),
146 mock_user_manager_(new chromeos::MockUserManager),
147 user_manager_enabler_(mock_user_manager_), 150 user_manager_enabler_(mock_user_manager_),
148 input_method_manager_mock_(NULL) {} 151 input_method_manager_mock_(NULL) {}
149 virtual ~EventRewriterTest() {} 152 virtual ~EventRewriterTest() {}
150 153
151 virtual void SetUp() { 154 virtual void SetUp() {
152 // Mocking user manager because the real one needs to be called on UI thread 155 // Mocking user manager because the real one needs to be called on UI thread
153 EXPECT_CALL(*mock_user_manager_, IsLoggedInAsGuest()) 156 EXPECT_CALL(*mock_user_manager_, IsLoggedInAsGuest())
154 .WillRepeatedly(testing::Return(false)); 157 .WillRepeatedly(testing::Return(false));
155 input_method_manager_mock_ = 158 input_method_manager_mock_ =
156 new chromeos::input_method::MockInputMethodManager; 159 new chromeos::input_method::MockInputMethodManager;
(...skipping 13 matching lines...) Expand all
170 void TestRewriteNumPadKeys(); 173 void TestRewriteNumPadKeys();
171 void TestRewriteNumPadKeysOnAppleKeyboard(); 174 void TestRewriteNumPadKeysOnAppleKeyboard();
172 175
173 int RewriteMouseEvent(chromeos::EventRewriter* rewriter, 176 int RewriteMouseEvent(chromeos::EventRewriter* rewriter,
174 const ui::MouseEvent& event) { 177 const ui::MouseEvent& event) {
175 int flags = event.flags(); 178 int flags = event.flags();
176 rewriter->RewriteLocatedEventForTesting(event, &flags); 179 rewriter->RewriteLocatedEventForTesting(event, &flags);
177 return flags; 180 return flags;
178 } 181 }
179 182
180 Display* display_;
181 chromeos::MockUserManager* mock_user_manager_; // Not owned. 183 chromeos::MockUserManager* mock_user_manager_; // Not owned.
182 chromeos::ScopedUserManagerEnabler user_manager_enabler_; 184 chromeos::ScopedUserManagerEnabler user_manager_enabler_;
183 chromeos::input_method::MockInputMethodManager* input_method_manager_mock_; 185 chromeos::input_method::MockInputMethodManager* input_method_manager_mock_;
184 }; 186 };
185 187
186 TEST_F(EventRewriterTest, TestRewriteCommandToControl) { 188 TEST_F(EventRewriterTest, TestRewriteCommandToControl) {
187 // First, test with a PC keyboard. 189 // First, test with a PC keyboard.
188 TestingPrefServiceSyncable prefs; 190 TestingPrefServiceSyncable prefs;
189 EventRewriter rewriter; 191 EventRewriter rewriter(NULL);
190 rewriter.DeviceAddedForTesting(0, "PC Keyboard"); 192 rewriter.DeviceAddedForTesting(0, "PC Keyboard");
191 rewriter.set_last_device_id_for_testing(0); 193 rewriter.set_last_device_id_for_testing(0);
192 rewriter.set_pref_service_for_testing(&prefs); 194 rewriter.set_pref_service_for_testing(&prefs);
193 195
194 KeyTestCase pc_keyboard_tests[] = { 196 KeyTestCase pc_keyboard_tests[] = {
195 // VKEY_A, Alt modifier. 197 // VKEY_A, Alt modifier.
196 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, 198 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
197 {ui::VKEY_A, ui::EF_ALT_DOWN}, 199 {ui::VKEY_A, ui::EF_ALT_DOWN},
198 {ui::VKEY_A, ui::EF_ALT_DOWN}}, 200 {ui::VKEY_A, ui::EF_ALT_DOWN}},
199 201
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after
260 262
261 // For crbug.com/133896. 263 // For crbug.com/133896.
262 TEST_F(EventRewriterTest, TestRewriteCommandToControlWithControlRemapped) { 264 TEST_F(EventRewriterTest, TestRewriteCommandToControlWithControlRemapped) {
263 // Remap Control to Alt. 265 // Remap Control to Alt.
264 TestingPrefServiceSyncable prefs; 266 TestingPrefServiceSyncable prefs;
265 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 267 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
266 IntegerPrefMember control; 268 IntegerPrefMember control;
267 control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); 269 control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
268 control.SetValue(chromeos::input_method::kAltKey); 270 control.SetValue(chromeos::input_method::kAltKey);
269 271
270 EventRewriter rewriter; 272 EventRewriter rewriter(NULL);
271 rewriter.set_pref_service_for_testing(&prefs); 273 rewriter.set_pref_service_for_testing(&prefs);
272 rewriter.DeviceAddedForTesting(0, "PC Keyboard"); 274 rewriter.DeviceAddedForTesting(0, "PC Keyboard");
273 rewriter.set_last_device_id_for_testing(0); 275 rewriter.set_last_device_id_for_testing(0);
274 276
275 KeyTestCase pc_keyboard_tests[] = {// Control should be remapped to Alt. 277 KeyTestCase pc_keyboard_tests[] = {// Control should be remapped to Alt.
276 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, 278 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
277 {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}, 279 {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN},
278 {ui::VKEY_MENU, ui::EF_ALT_DOWN}}, 280 {ui::VKEY_MENU, ui::EF_ALT_DOWN}},
279 }; 281 };
280 282
(...skipping 19 matching lines...) Expand all
300 {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN}}, 302 {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN}},
301 }; 303 };
302 304
303 for (size_t i = 0; i < arraysize(apple_keyboard_tests); ++i) { 305 for (size_t i = 0; i < arraysize(apple_keyboard_tests); ++i) {
304 CheckKeyTestCase(2000 + i, &rewriter, apple_keyboard_tests[i]); 306 CheckKeyTestCase(2000 + i, &rewriter, apple_keyboard_tests[i]);
305 } 307 }
306 } 308 }
307 309
308 void EventRewriterTest::TestRewriteNumPadKeys() { 310 void EventRewriterTest::TestRewriteNumPadKeys() {
309 TestingPrefServiceSyncable prefs; 311 TestingPrefServiceSyncable prefs;
310 EventRewriter rewriter; 312 EventRewriter rewriter(NULL);
311 rewriter.set_pref_service_for_testing(&prefs); 313 rewriter.set_pref_service_for_testing(&prefs);
312 314
313 KeyTestCase tests[] = { 315 KeyTestCase tests[] = {
314 // XK_KP_Insert (= NumPad 0 without Num Lock), no modifier. 316 // XK_KP_Insert (= NumPad 0 without Num Lock), no modifier.
315 {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, 317 {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED,
316 {ui::VKEY_INSERT, ui::EF_NUMPAD_KEY}, 318 {ui::VKEY_INSERT, ui::EF_NUMPAD_KEY},
317 {ui::VKEY_NUMPAD0, ui::EF_NUMPAD_KEY}}, 319 {ui::VKEY_NUMPAD0, ui::EF_NUMPAD_KEY}},
318 320
319 // XK_KP_Insert (= NumPad 0 without Num Lock), Alt modifier. 321 // XK_KP_Insert (= NumPad 0 without Num Lock), Alt modifier.
320 {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, 322 {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED,
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after
442 CommandLine::ForCurrentProcess()->AppendSwitchASCII( 444 CommandLine::ForCurrentProcess()->AppendSwitchASCII(
443 chromeos::switches::kHasChromeOSDiamondKey, ""); 445 chromeos::switches::kHasChromeOSDiamondKey, "");
444 446
445 TestRewriteNumPadKeys(); 447 TestRewriteNumPadKeys();
446 *CommandLine::ForCurrentProcess() = original_cl; 448 *CommandLine::ForCurrentProcess() = original_cl;
447 } 449 }
448 450
449 // Tests if the rewriter can handle a Command + Num Pad event. 451 // Tests if the rewriter can handle a Command + Num Pad event.
450 void EventRewriterTest::TestRewriteNumPadKeysOnAppleKeyboard() { 452 void EventRewriterTest::TestRewriteNumPadKeysOnAppleKeyboard() {
451 TestingPrefServiceSyncable prefs; 453 TestingPrefServiceSyncable prefs;
452 EventRewriter rewriter; 454 EventRewriter rewriter(NULL);
453 rewriter.DeviceAddedForTesting(0, "Apple Keyboard"); 455 rewriter.DeviceAddedForTesting(0, "Apple Keyboard");
454 rewriter.set_last_device_id_for_testing(0); 456 rewriter.set_last_device_id_for_testing(0);
455 rewriter.set_pref_service_for_testing(&prefs); 457 rewriter.set_pref_service_for_testing(&prefs);
456 458
457 KeyTestCase tests[] = { 459 KeyTestCase tests[] = {
458 // XK_KP_End (= NumPad 1 without Num Lock), Win modifier. 460 // XK_KP_End (= NumPad 1 without Num Lock), Win modifier.
459 // The result should be "Num Pad 1 with Control + Num Lock modifiers". 461 // The result should be "Num Pad 1 with Control + Num Lock modifiers".
460 {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, 462 {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED,
461 {ui::VKEY_END, ui::EF_COMMAND_DOWN | ui::EF_NUMPAD_KEY}, 463 {ui::VKEY_END, ui::EF_COMMAND_DOWN | ui::EF_NUMPAD_KEY},
462 {ui::VKEY_NUMPAD1, ui::EF_CONTROL_DOWN | ui::EF_NUMPAD_KEY}}, 464 {ui::VKEY_NUMPAD1, ui::EF_CONTROL_DOWN | ui::EF_NUMPAD_KEY}},
(...skipping 21 matching lines...) Expand all
484 const CommandLine original_cl(*CommandLine::ForCurrentProcess()); 486 const CommandLine original_cl(*CommandLine::ForCurrentProcess());
485 CommandLine::ForCurrentProcess()->AppendSwitchASCII( 487 CommandLine::ForCurrentProcess()->AppendSwitchASCII(
486 chromeos::switches::kHasChromeOSDiamondKey, ""); 488 chromeos::switches::kHasChromeOSDiamondKey, "");
487 489
488 TestRewriteNumPadKeysOnAppleKeyboard(); 490 TestRewriteNumPadKeysOnAppleKeyboard();
489 *CommandLine::ForCurrentProcess() = original_cl; 491 *CommandLine::ForCurrentProcess() = original_cl;
490 } 492 }
491 493
492 TEST_F(EventRewriterTest, TestRewriteModifiersNoRemap) { 494 TEST_F(EventRewriterTest, TestRewriteModifiersNoRemap) {
493 TestingPrefServiceSyncable prefs; 495 TestingPrefServiceSyncable prefs;
494 EventRewriter rewriter; 496 EventRewriter rewriter(NULL);
495 rewriter.set_pref_service_for_testing(&prefs); 497 rewriter.set_pref_service_for_testing(&prefs);
496 498
497 KeyTestCase tests[] = { 499 KeyTestCase tests[] = {
498 // Press Search. Confirm the event is not rewritten. 500 // Press Search. Confirm the event is not rewritten.
499 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, 501 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
500 {ui::VKEY_LWIN, ui::EF_NONE}, 502 {ui::VKEY_LWIN, ui::EF_NONE},
501 {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN}}, 503 {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN}},
502 504
503 // Press left Control. Confirm the event is not rewritten. 505 // Press left Control. Confirm the event is not rewritten.
504 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, 506 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
(...skipping 22 matching lines...) Expand all
527 {ui::VKEY_LWIN, ui::EF_NONE}}, 529 {ui::VKEY_LWIN, ui::EF_NONE}},
528 }; 530 };
529 531
530 for (size_t i = 0; i < arraysize(tests); ++i) { 532 for (size_t i = 0; i < arraysize(tests); ++i) {
531 CheckKeyTestCase(1000 + i, &rewriter, tests[i]); 533 CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
532 } 534 }
533 } 535 }
534 536
535 TEST_F(EventRewriterTest, TestRewriteModifiersNoRemapMultipleKeys) { 537 TEST_F(EventRewriterTest, TestRewriteModifiersNoRemapMultipleKeys) {
536 TestingPrefServiceSyncable prefs; 538 TestingPrefServiceSyncable prefs;
537 EventRewriter rewriter; 539 EventRewriter rewriter(NULL);
538 rewriter.set_pref_service_for_testing(&prefs); 540 rewriter.set_pref_service_for_testing(&prefs);
539 541
540 KeyTestCase tests[] = { 542 KeyTestCase tests[] = {
541 // Press Alt with Shift. Confirm the event is not rewritten. 543 // Press Alt with Shift. Confirm the event is not rewritten.
542 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, 544 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
543 {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN}, 545 {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN},
544 {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN}}, 546 {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN}},
545 547
546 // Press Search with Caps Lock mask. Confirm the event is not rewritten. 548 // Press Search with Caps Lock mask. Confirm the event is not rewritten.
547 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, 549 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
(...skipping 22 matching lines...) Expand all
570 // Disable Search and Control keys. 572 // Disable Search and Control keys.
571 TestingPrefServiceSyncable prefs; 573 TestingPrefServiceSyncable prefs;
572 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 574 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
573 IntegerPrefMember search; 575 IntegerPrefMember search;
574 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); 576 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
575 search.SetValue(chromeos::input_method::kVoidKey); 577 search.SetValue(chromeos::input_method::kVoidKey);
576 IntegerPrefMember control; 578 IntegerPrefMember control;
577 control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); 579 control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
578 control.SetValue(chromeos::input_method::kVoidKey); 580 control.SetValue(chromeos::input_method::kVoidKey);
579 581
580 EventRewriter rewriter; 582 EventRewriter rewriter(NULL);
581 rewriter.set_pref_service_for_testing(&prefs); 583 rewriter.set_pref_service_for_testing(&prefs);
582 584
583 KeyTestCase disabled_modifier_tests[] = { 585 KeyTestCase disabled_modifier_tests[] = {
584 // Press Alt with Shift. This key press shouldn't be affected by the 586 // Press Alt with Shift. This key press shouldn't be affected by the
585 // pref. Confirm the event is not rewritten. 587 // pref. Confirm the event is not rewritten.
586 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, 588 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
587 {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN}, 589 {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN},
588 {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN}}, 590 {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN}},
589 591
590 // Press Search. Confirm the event is now VKEY_UNKNOWN. 592 // Press Search. Confirm the event is now VKEY_UNKNOWN.
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after
645 } 647 }
646 648
647 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToControl) { 649 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToControl) {
648 // Remap Search to Control. 650 // Remap Search to Control.
649 TestingPrefServiceSyncable prefs; 651 TestingPrefServiceSyncable prefs;
650 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 652 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
651 IntegerPrefMember search; 653 IntegerPrefMember search;
652 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); 654 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
653 search.SetValue(chromeos::input_method::kControlKey); 655 search.SetValue(chromeos::input_method::kControlKey);
654 656
655 EventRewriter rewriter; 657 EventRewriter rewriter(NULL);
656 rewriter.set_pref_service_for_testing(&prefs); 658 rewriter.set_pref_service_for_testing(&prefs);
657 659
658 KeyTestCase s_tests[] = { 660 KeyTestCase s_tests[] = {
659 // Press Search. Confirm the event is now VKEY_CONTROL. 661 // Press Search. Confirm the event is now VKEY_CONTROL.
660 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, 662 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
661 {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN}, 663 {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN},
662 {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}}, 664 {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}},
663 }; 665 };
664 666
665 for (size_t i = 0; i < arraysize(s_tests); ++i) { 667 for (size_t i = 0; i < arraysize(s_tests); ++i) {
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
709 } 711 }
710 712
711 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToEscape) { 713 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToEscape) {
712 // Remap Search to ESC. 714 // Remap Search to ESC.
713 TestingPrefServiceSyncable prefs; 715 TestingPrefServiceSyncable prefs;
714 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 716 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
715 IntegerPrefMember search; 717 IntegerPrefMember search;
716 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); 718 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
717 search.SetValue(chromeos::input_method::kEscapeKey); 719 search.SetValue(chromeos::input_method::kEscapeKey);
718 720
719 EventRewriter rewriter; 721 EventRewriter rewriter(NULL);
720 rewriter.set_pref_service_for_testing(&prefs); 722 rewriter.set_pref_service_for_testing(&prefs);
721 723
722 KeyTestCase tests[] = {// Press Search. Confirm the event is now VKEY_ESCAPE. 724 KeyTestCase tests[] = {// Press Search. Confirm the event is now VKEY_ESCAPE.
723 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, 725 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
724 {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN}, 726 {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN},
725 {ui::VKEY_ESCAPE, ui::EF_NONE}}, 727 {ui::VKEY_ESCAPE, ui::EF_NONE}},
726 }; 728 };
727 729
728 for (size_t i = 0; i < arraysize(tests); ++i) { 730 for (size_t i = 0; i < arraysize(tests); ++i) {
729 CheckKeyTestCase(1000 + i, &rewriter, tests[i]); 731 CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
730 } 732 }
731 } 733 }
732 734
733 TEST_F(EventRewriterTest, TestRewriteModifiersRemapMany) { 735 TEST_F(EventRewriterTest, TestRewriteModifiersRemapMany) {
734 // Remap Search to Alt. 736 // Remap Search to Alt.
735 TestingPrefServiceSyncable prefs; 737 TestingPrefServiceSyncable prefs;
736 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 738 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
737 IntegerPrefMember search; 739 IntegerPrefMember search;
738 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); 740 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
739 search.SetValue(chromeos::input_method::kAltKey); 741 search.SetValue(chromeos::input_method::kAltKey);
740 742
741 EventRewriter rewriter; 743 EventRewriter rewriter(NULL);
742 rewriter.set_pref_service_for_testing(&prefs); 744 rewriter.set_pref_service_for_testing(&prefs);
743 745
744 KeyTestCase s2a_tests[] = { 746 KeyTestCase s2a_tests[] = {
745 // Press Search. Confirm the event is now VKEY_MENU. 747 // Press Search. Confirm the event is now VKEY_MENU.
746 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, 748 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
747 {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN}, 749 {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN},
748 {ui::VKEY_MENU, ui::EF_ALT_DOWN}}, 750 {ui::VKEY_MENU, ui::EF_ALT_DOWN}},
749 }; 751 };
750 752
751 for (size_t i = 0; i < arraysize(s2a_tests); ++i) { 753 for (size_t i = 0; i < arraysize(s2a_tests); ++i) {
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after
808 810
809 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToCapsLock) { 811 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToCapsLock) {
810 // Remap Search to Caps Lock. 812 // Remap Search to Caps Lock.
811 TestingPrefServiceSyncable prefs; 813 TestingPrefServiceSyncable prefs;
812 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 814 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
813 IntegerPrefMember search; 815 IntegerPrefMember search;
814 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); 816 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
815 search.SetValue(chromeos::input_method::kCapsLockKey); 817 search.SetValue(chromeos::input_method::kCapsLockKey);
816 818
817 chromeos::input_method::FakeImeKeyboard ime_keyboard; 819 chromeos::input_method::FakeImeKeyboard ime_keyboard;
818 EventRewriter rewriter; 820 EventRewriter rewriter(NULL);
819 rewriter.set_pref_service_for_testing(&prefs); 821 rewriter.set_pref_service_for_testing(&prefs);
820 rewriter.set_ime_keyboard_for_testing(&ime_keyboard); 822 rewriter.set_ime_keyboard_for_testing(&ime_keyboard);
821 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); 823 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_);
822 824
823 // Press Search. 825 // Press Search.
824 EXPECT_EQ( 826 EXPECT_EQ(
825 GetExpectedResultAsString(ui::VKEY_CAPITAL, 827 GetExpectedResultAsString(ui::VKEY_CAPITAL,
826 ui::EF_CAPS_LOCK_DOWN | ui::EF_MOD3_DOWN, 828 ui::EF_CAPS_LOCK_DOWN | ui::EF_MOD3_DOWN,
827 ui::ET_KEY_PRESSED), 829 ui::ET_KEY_PRESSED),
828 GetRewrittenEventAsString( 830 GetRewrittenEventAsString(
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after
878 GetRewrittenEventAsString( 880 GetRewrittenEventAsString(
879 &rewriter, ui::VKEY_CAPITAL, ui::EF_NONE, ui::ET_KEY_RELEASED)); 881 &rewriter, ui::VKEY_CAPITAL, ui::EF_NONE, ui::ET_KEY_RELEASED));
880 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); 882 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_);
881 } 883 }
882 884
883 TEST_F(EventRewriterTest, TestRewriteCapsLock) { 885 TEST_F(EventRewriterTest, TestRewriteCapsLock) {
884 TestingPrefServiceSyncable prefs; 886 TestingPrefServiceSyncable prefs;
885 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 887 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
886 888
887 chromeos::input_method::FakeImeKeyboard ime_keyboard; 889 chromeos::input_method::FakeImeKeyboard ime_keyboard;
888 EventRewriter rewriter; 890 EventRewriter rewriter(NULL);
889 rewriter.set_pref_service_for_testing(&prefs); 891 rewriter.set_pref_service_for_testing(&prefs);
890 rewriter.set_ime_keyboard_for_testing(&ime_keyboard); 892 rewriter.set_ime_keyboard_for_testing(&ime_keyboard);
891 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); 893 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_);
892 894
893 // On Chrome OS, CapsLock is mapped to F16 with Mod3Mask. 895 // On Chrome OS, CapsLock is mapped to F16 with Mod3Mask.
894 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL, 896 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
895 ui::EF_CAPS_LOCK_DOWN | ui::EF_MOD3_DOWN, 897 ui::EF_CAPS_LOCK_DOWN | ui::EF_MOD3_DOWN,
896 ui::ET_KEY_PRESSED), 898 ui::ET_KEY_PRESSED),
897 GetRewrittenEventAsString( 899 GetRewrittenEventAsString(
898 &rewriter, ui::VKEY_F16, ui::EF_MOD3_DOWN, ui::ET_KEY_PRESSED)); 900 &rewriter, ui::VKEY_F16, ui::EF_MOD3_DOWN, ui::ET_KEY_PRESSED));
899 EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_); 901 EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_);
900 } 902 }
901 903
902 TEST_F(EventRewriterTest, TestRewriteDiamondKey) { 904 TEST_F(EventRewriterTest, TestRewriteDiamondKey) {
903 TestingPrefServiceSyncable prefs; 905 TestingPrefServiceSyncable prefs;
904 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 906 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
905 907
906 chromeos::input_method::FakeImeKeyboard ime_keyboard; 908 chromeos::input_method::FakeImeKeyboard ime_keyboard;
907 EventRewriter rewriter; 909 EventRewriter rewriter(NULL);
908 rewriter.set_pref_service_for_testing(&prefs); 910 rewriter.set_pref_service_for_testing(&prefs);
909 rewriter.set_ime_keyboard_for_testing(&ime_keyboard); 911 rewriter.set_ime_keyboard_for_testing(&ime_keyboard);
910 912
911 KeyTestCase tests[] = { 913 KeyTestCase tests[] = {
912 // F15 should work as Ctrl when --has-chromeos-diamond-key is not 914 // F15 should work as Ctrl when --has-chromeos-diamond-key is not
913 // specified. 915 // specified.
914 {KeyTestCase::TEST_VKEY, 916 {KeyTestCase::TEST_VKEY,
915 ui::ET_KEY_PRESSED, 917 ui::ET_KEY_PRESSED,
916 {ui::VKEY_F15, ui::EF_NONE}, 918 {ui::VKEY_F15, ui::EF_NONE},
917 {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}}, 919 {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}},
(...skipping 12 matching lines...) Expand all
930 } 932 }
931 TEST_F(EventRewriterTest, TestRewriteDiamondKeyWithFlag) { 933 TEST_F(EventRewriterTest, TestRewriteDiamondKeyWithFlag) {
932 const CommandLine original_cl(*CommandLine::ForCurrentProcess()); 934 const CommandLine original_cl(*CommandLine::ForCurrentProcess());
933 CommandLine::ForCurrentProcess()->AppendSwitchASCII( 935 CommandLine::ForCurrentProcess()->AppendSwitchASCII(
934 chromeos::switches::kHasChromeOSDiamondKey, ""); 936 chromeos::switches::kHasChromeOSDiamondKey, "");
935 937
936 TestingPrefServiceSyncable prefs; 938 TestingPrefServiceSyncable prefs;
937 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 939 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
938 940
939 chromeos::input_method::FakeImeKeyboard ime_keyboard; 941 chromeos::input_method::FakeImeKeyboard ime_keyboard;
940 EventRewriter rewriter; 942 EventRewriter rewriter(NULL);
941 rewriter.set_pref_service_for_testing(&prefs); 943 rewriter.set_pref_service_for_testing(&prefs);
942 rewriter.set_ime_keyboard_for_testing(&ime_keyboard); 944 rewriter.set_ime_keyboard_for_testing(&ime_keyboard);
943 945
944 // By default, F15 should work as Control. 946 // By default, F15 should work as Control.
945 EXPECT_EQ(GetExpectedResultAsString( 947 EXPECT_EQ(GetExpectedResultAsString(
946 ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN, ui::ET_KEY_PRESSED), 948 ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN, ui::ET_KEY_PRESSED),
947 GetRewrittenEventAsString( 949 GetRewrittenEventAsString(
948 &rewriter, ui::VKEY_F15, ui::EF_NONE, ui::ET_KEY_PRESSED)); 950 &rewriter, ui::VKEY_F15, ui::EF_NONE, ui::ET_KEY_PRESSED));
949 951
950 IntegerPrefMember diamond; 952 IntegerPrefMember diamond;
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after
982 } 984 }
983 985
984 TEST_F(EventRewriterTest, TestRewriteCapsLockToControl) { 986 TEST_F(EventRewriterTest, TestRewriteCapsLockToControl) {
985 // Remap CapsLock to Control. 987 // Remap CapsLock to Control.
986 TestingPrefServiceSyncable prefs; 988 TestingPrefServiceSyncable prefs;
987 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 989 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
988 IntegerPrefMember control; 990 IntegerPrefMember control;
989 control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs); 991 control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs);
990 control.SetValue(chromeos::input_method::kControlKey); 992 control.SetValue(chromeos::input_method::kControlKey);
991 993
992 EventRewriter rewriter; 994 EventRewriter rewriter(NULL);
993 rewriter.set_pref_service_for_testing(&prefs); 995 rewriter.set_pref_service_for_testing(&prefs);
994 996
995 KeyTestCase tests[] = { 997 KeyTestCase tests[] = {
996 // Press CapsLock+a. Confirm that Mod3Mask is rewritten to ControlMask. 998 // Press CapsLock+a. Confirm that Mod3Mask is rewritten to ControlMask.
997 // On Chrome OS, CapsLock works as a Mod3 modifier. 999 // On Chrome OS, CapsLock works as a Mod3 modifier.
998 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, 1000 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
999 {ui::VKEY_A, ui::EF_MOD3_DOWN}, 1001 {ui::VKEY_A, ui::EF_MOD3_DOWN},
1000 {ui::VKEY_A, ui::EF_CONTROL_DOWN}}, 1002 {ui::VKEY_A, ui::EF_CONTROL_DOWN}},
1001 1003
1002 // Press Control+CapsLock+a. Confirm that Mod3Mask is rewritten to 1004 // Press Control+CapsLock+a. Confirm that Mod3Mask is rewritten to
(...skipping 15 matching lines...) Expand all
1018 } 1020 }
1019 1021
1020 TEST_F(EventRewriterTest, TestRewriteCapsLockMod3InUse) { 1022 TEST_F(EventRewriterTest, TestRewriteCapsLockMod3InUse) {
1021 // Remap CapsLock to Control. 1023 // Remap CapsLock to Control.
1022 TestingPrefServiceSyncable prefs; 1024 TestingPrefServiceSyncable prefs;
1023 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 1025 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1024 IntegerPrefMember control; 1026 IntegerPrefMember control;
1025 control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs); 1027 control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs);
1026 control.SetValue(chromeos::input_method::kControlKey); 1028 control.SetValue(chromeos::input_method::kControlKey);
1027 1029
1028 EventRewriter rewriter; 1030 EventRewriter rewriter(NULL);
1029 rewriter.set_pref_service_for_testing(&prefs); 1031 rewriter.set_pref_service_for_testing(&prefs);
1030 input_method_manager_mock_->set_mod3_used(true); 1032 input_method_manager_mock_->set_mod3_used(true);
1031 1033
1032 // Press CapsLock+a. Confirm that Mod3Mask is NOT rewritten to ControlMask 1034 // Press CapsLock+a. Confirm that Mod3Mask is NOT rewritten to ControlMask
1033 // when Mod3Mask is already in use by the current XKB layout. 1035 // when Mod3Mask is already in use by the current XKB layout.
1034 EXPECT_EQ( 1036 EXPECT_EQ(
1035 GetExpectedResultAsString(ui::VKEY_A, ui::EF_NONE, ui::ET_KEY_PRESSED), 1037 GetExpectedResultAsString(ui::VKEY_A, ui::EF_NONE, ui::ET_KEY_PRESSED),
1036 GetRewrittenEventAsString( 1038 GetRewrittenEventAsString(
1037 &rewriter, ui::VKEY_A, ui::EF_NONE, ui::ET_KEY_PRESSED)); 1039 &rewriter, ui::VKEY_A, ui::EF_NONE, ui::ET_KEY_PRESSED));
1038 1040
1039 input_method_manager_mock_->set_mod3_used(false); 1041 input_method_manager_mock_->set_mod3_used(false);
1040 } 1042 }
1041 1043
1042 TEST_F(EventRewriterTest, TestRewriteExtendedKeys) { 1044 TEST_F(EventRewriterTest, TestRewriteExtendedKeys) {
1043 TestingPrefServiceSyncable prefs; 1045 TestingPrefServiceSyncable prefs;
1044 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 1046 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1045 EventRewriter rewriter; 1047 EventRewriter rewriter(NULL);
1046 rewriter.DeviceAddedForTesting(0, "PC Keyboard"); 1048 rewriter.DeviceAddedForTesting(0, "PC Keyboard");
1047 rewriter.set_last_device_id_for_testing(0); 1049 rewriter.set_last_device_id_for_testing(0);
1048 rewriter.set_pref_service_for_testing(&prefs); 1050 rewriter.set_pref_service_for_testing(&prefs);
1049 1051
1050 KeyTestCase tests[] = { 1052 KeyTestCase tests[] = {
1051 // Alt+Backspace -> Delete 1053 // Alt+Backspace -> Delete
1052 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, 1054 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
1053 {ui::VKEY_BACK, ui::EF_ALT_DOWN}, 1055 {ui::VKEY_BACK, ui::EF_ALT_DOWN},
1054 {ui::VKEY_DELETE, ui::EF_NONE}}, 1056 {ui::VKEY_DELETE, ui::EF_NONE}},
1055 // Control+Alt+Backspace -> Control+Delete 1057 // Control+Alt+Backspace -> Control+Delete
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after
1144 {ui::VKEY_INSERT, ui::EF_CONTROL_DOWN}}}; 1146 {ui::VKEY_INSERT, ui::EF_CONTROL_DOWN}}};
1145 1147
1146 for (size_t i = 0; i < arraysize(tests); ++i) { 1148 for (size_t i = 0; i < arraysize(tests); ++i) {
1147 CheckKeyTestCase(1000 + i, &rewriter, tests[i]); 1149 CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
1148 } 1150 }
1149 } 1151 }
1150 1152
1151 TEST_F(EventRewriterTest, TestRewriteFunctionKeys) { 1153 TEST_F(EventRewriterTest, TestRewriteFunctionKeys) {
1152 TestingPrefServiceSyncable prefs; 1154 TestingPrefServiceSyncable prefs;
1153 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 1155 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1154 EventRewriter rewriter; 1156 EventRewriter rewriter(NULL);
1155 rewriter.set_pref_service_for_testing(&prefs); 1157 rewriter.set_pref_service_for_testing(&prefs);
1156 1158
1157 KeyTestCase tests[] = { 1159 KeyTestCase tests[] = {
1158 // F1 -> Back 1160 // F1 -> Back
1159 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, 1161 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
1160 {ui::VKEY_F1, ui::EF_NONE}, 1162 {ui::VKEY_F1, ui::EF_NONE},
1161 {ui::VKEY_BROWSER_BACK, ui::EF_NONE}}, 1163 {ui::VKEY_BROWSER_BACK, ui::EF_NONE}},
1162 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, 1164 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
1163 {ui::VKEY_F1, ui::EF_CONTROL_DOWN}, 1165 {ui::VKEY_F1, ui::EF_CONTROL_DOWN},
1164 {ui::VKEY_BROWSER_BACK, ui::EF_CONTROL_DOWN}}, 1166 {ui::VKEY_BROWSER_BACK, ui::EF_CONTROL_DOWN}},
(...skipping 235 matching lines...) Expand 10 before | Expand all | Expand 10 after
1400 TEST_F(EventRewriterTest, TestRewriteExtendedKeysWithSearchRemapped) { 1402 TEST_F(EventRewriterTest, TestRewriteExtendedKeysWithSearchRemapped) {
1401 const CommandLine original_cl(*CommandLine::ForCurrentProcess()); 1403 const CommandLine original_cl(*CommandLine::ForCurrentProcess());
1402 1404
1403 // Remap Search to Control. 1405 // Remap Search to Control.
1404 TestingPrefServiceSyncable prefs; 1406 TestingPrefServiceSyncable prefs;
1405 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 1407 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1406 IntegerPrefMember search; 1408 IntegerPrefMember search;
1407 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); 1409 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs);
1408 search.SetValue(chromeos::input_method::kControlKey); 1410 search.SetValue(chromeos::input_method::kControlKey);
1409 1411
1410 EventRewriter rewriter; 1412 EventRewriter rewriter(NULL);
1411 rewriter.set_pref_service_for_testing(&prefs); 1413 rewriter.set_pref_service_for_testing(&prefs);
1412 1414
1413 CommandLine::ForCurrentProcess()->AppendSwitchASCII( 1415 CommandLine::ForCurrentProcess()->AppendSwitchASCII(
1414 chromeos::switches::kHasChromeOSKeyboard, ""); 1416 chromeos::switches::kHasChromeOSKeyboard, "");
1415 1417
1416 KeyTestCase tests[] = { 1418 KeyTestCase tests[] = {
1417 // Alt+Search+Down -> End 1419 // Alt+Search+Down -> End
1418 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, 1420 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
1419 {ui::VKEY_DOWN, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}, 1421 {ui::VKEY_DOWN, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN},
1420 {ui::VKEY_END, ui::EF_NONE}}, 1422 {ui::VKEY_END, ui::EF_NONE}},
1421 1423
1422 // Shift+Alt+Search+Down -> Shift+End 1424 // Shift+Alt+Search+Down -> Shift+End
1423 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, 1425 {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED,
1424 {ui::VKEY_DOWN, 1426 {ui::VKEY_DOWN,
1425 ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}, 1427 ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN},
1426 {ui::VKEY_END, ui::EF_SHIFT_DOWN}}, 1428 {ui::VKEY_END, ui::EF_SHIFT_DOWN}},
1427 }; 1429 };
1428 1430
1429 for (size_t i = 0; i < arraysize(tests); ++i) { 1431 for (size_t i = 0; i < arraysize(tests); ++i) {
1430 CheckKeyTestCase(1000 + i, &rewriter, tests[i]); 1432 CheckKeyTestCase(1000 + i, &rewriter, tests[i]);
1431 } 1433 }
1432 1434
1433 *CommandLine::ForCurrentProcess() = original_cl; 1435 *CommandLine::ForCurrentProcess() = original_cl;
1434 } 1436 }
1435 1437
1436 TEST_F(EventRewriterTest, TestRewriteKeyEventSentByXSendEvent) { 1438 TEST_F(EventRewriterTest, TestRewriteKeyEventSentByXSendEvent) {
1439 #if defined(USE_X11)
1440 // TODO(kpschoedel): pending alternative to xevent.xany.send_event
1437 // Remap Control to Alt. 1441 // Remap Control to Alt.
1438 TestingPrefServiceSyncable prefs; 1442 TestingPrefServiceSyncable prefs;
1439 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 1443 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1440 IntegerPrefMember control; 1444 IntegerPrefMember control;
1441 control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); 1445 control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
1442 control.SetValue(chromeos::input_method::kAltKey); 1446 control.SetValue(chromeos::input_method::kAltKey);
1443 1447
1444 EventRewriter rewriter; 1448 EventRewriter rewriter(NULL);
1445 rewriter.set_pref_service_for_testing(&prefs); 1449 rewriter.set_pref_service_for_testing(&prefs);
1446 1450
1447 // Send left control press. 1451 // Send left control press.
1448 std::string rewritten_event; 1452 std::string rewritten_event;
1449 { 1453 {
1450 ui::ScopedXI2Event xev; 1454 ui::ScopedXI2Event xev;
1451 xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0); 1455 xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0);
1452 XEvent* xevent = xev; 1456 XEvent* xevent = xev;
1453 xevent->xkey.keycode = XKeysymToKeycode(gfx::GetXDisplay(), XK_Control_L); 1457 xevent->xkey.keycode = XKeysymToKeycode(gfx::GetXDisplay(), XK_Control_L);
1454 xevent->xkey.send_event = True; // XSendEvent() always does this. 1458 xevent->xkey.send_event = True; // XSendEvent() always does this.
1455 ui::KeyEvent keyevent(xev, false /* is_char */); 1459 ui::KeyEvent keyevent(xev, false /* is_char */);
1456 scoped_ptr<ui::Event> new_event; 1460 scoped_ptr<ui::Event> new_event;
1457 // Control should NOT be remapped to Alt if send_event 1461 // Control should NOT be remapped to Alt if send_event
1458 // flag in the event is True. 1462 // flag in the event is True.
1459 EXPECT_EQ(ui::EVENT_REWRITE_CONTINUE, 1463 EXPECT_EQ(ui::EVENT_REWRITE_CONTINUE,
1460 rewriter.RewriteEvent(keyevent, &new_event)); 1464 rewriter.RewriteEvent(keyevent, &new_event));
1461 EXPECT_FALSE(new_event); 1465 EXPECT_FALSE(new_event);
1462 } 1466 }
1467 #endif
1463 } 1468 }
1464 1469
1465 TEST_F(EventRewriterTest, TestRewriteNonNativeEvent) { 1470 TEST_F(EventRewriterTest, TestRewriteNonNativeEvent) {
1466 // Remap Control to Alt. 1471 // Remap Control to Alt.
1467 TestingPrefServiceSyncable prefs; 1472 TestingPrefServiceSyncable prefs;
1468 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 1473 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1469 IntegerPrefMember control; 1474 IntegerPrefMember control;
1470 control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); 1475 control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
1471 control.SetValue(chromeos::input_method::kAltKey); 1476 control.SetValue(chromeos::input_method::kAltKey);
1472 1477
1473 EventRewriter rewriter; 1478 EventRewriter rewriter(NULL);
1474 rewriter.set_pref_service_for_testing(&prefs); 1479 rewriter.set_pref_service_for_testing(&prefs);
1475 1480
1476 const int kTouchId = 2; 1481 const int kTouchId = 2;
1477 gfx::Point location(0, 0); 1482 gfx::Point location(0, 0);
1478 ui::TouchEvent press( 1483 ui::TouchEvent press(
1479 ui::ET_TOUCH_PRESSED, location, kTouchId, base::TimeDelta()); 1484 ui::ET_TOUCH_PRESSED, location, kTouchId, base::TimeDelta());
1480 press.set_flags(ui::EF_CONTROL_DOWN); 1485 press.set_flags(ui::EF_CONTROL_DOWN);
1481 1486
1482 scoped_ptr<ui::Event> new_event; 1487 scoped_ptr<ui::Event> new_event;
1483 rewriter.RewriteEvent(press, &new_event); 1488 rewriter.RewriteEvent(press, &new_event);
1484 EXPECT_TRUE(new_event); 1489 EXPECT_TRUE(new_event);
1485 // Control should be remapped to Alt. 1490 // Control should be remapped to Alt.
1486 EXPECT_EQ(ui::EF_ALT_DOWN, 1491 EXPECT_EQ(ui::EF_ALT_DOWN,
1487 new_event->flags() & (ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN)); 1492 new_event->flags() & (ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN));
1488 } 1493 }
1489 1494
1495 // Keeps a buffer of handled events.
1496 class EventBuffer : public ui::test::TestEventProcessor {
1497 public:
1498 EventBuffer() {}
1499 virtual ~EventBuffer() {}
1500
1501 void PopEvents(ScopedVector<ui::Event>* events) {
1502 events->clear();
1503 events->swap(events_);
1504 }
1505
1506 private:
1507 // ui::EventProcessor overrides:
1508 virtual ui::EventDispatchDetails OnEventFromSource(
1509 ui::Event* event) OVERRIDE {
1510 if (event->IsKeyEvent()) {
1511 events_.push_back(new ui::KeyEvent(*static_cast<ui::KeyEvent*>(event)));
1512 } else if (event->IsMouseWheelEvent()) {
1513 events_.push_back(
1514 new ui::MouseWheelEvent(*static_cast<ui::MouseWheelEvent*>(event)));
1515 } else if (event->IsMouseEvent()) {
1516 events_.push_back(
1517 new ui::MouseEvent(*static_cast<ui::MouseEvent*>(event)));
1518 }
1519 return ui::EventDispatchDetails();
1520 }
1521
1522 ScopedVector<ui::Event> events_;
1523
1524 DISALLOW_COPY_AND_ASSIGN(EventBuffer);
1525 };
1526
1527 // Trivial EventSource that does nothing but send events.
1528 class TestEventSource : public ui::EventSource {
1529 public:
1530 explicit TestEventSource(ui::EventProcessor* processor)
1531 : processor_(processor) {}
1532 virtual ui::EventProcessor* GetEventProcessor() OVERRIDE {
1533 return processor_;
1534 }
1535 ui::EventDispatchDetails Send(ui::Event* event) {
1536 return SendEventToProcessor(event);
1537 }
1538
1539 void SendActivateStickyKeyPattern(ui::KeyboardCode key_code) {
1540 ui::KeyEvent press(ui::ET_KEY_PRESSED, key_code, ui::EF_NONE, false);
1541 ui::EventDispatchDetails details = Send(&press);
1542 CHECK(!details.dispatcher_destroyed);
1543 ui::KeyEvent release(ui::ET_KEY_RELEASED, key_code, ui::EF_NONE, false);
1544 details = Send(&release);
1545 CHECK(!details.dispatcher_destroyed);
1546 }
1547
1548 private:
1549 ui::EventProcessor* processor_;
1550 };
1551
1490 // Tests of event rewriting that depend on the Ash window manager. 1552 // Tests of event rewriting that depend on the Ash window manager.
1491 class EventRewriterAshTest : public ash::test::AshTestBase { 1553 class EventRewriterAshTest : public ash::test::AshTestBase {
1492 public: 1554 public:
1493 EventRewriterAshTest() 1555 EventRewriterAshTest()
1494 : mock_user_manager_(new chromeos::MockUserManager), 1556 : mock_user_manager_(new chromeos::MockUserManager),
1495 user_manager_enabler_(mock_user_manager_) {} 1557 user_manager_enabler_(mock_user_manager_) {}
1496 virtual ~EventRewriterAshTest() {} 1558 virtual ~EventRewriterAshTest() {}
1497 1559
1498 bool RewriteFunctionKeys(const ui::Event& event, 1560 bool RewriteFunctionKeys(const ui::Event& event,
1499 scoped_ptr<ui::Event>* rewritten_event) { 1561 scoped_ptr<ui::Event>* rewritten_event) {
1500 return rewriter_->RewriteEvent(event, rewritten_event); 1562 return rewriter_->RewriteEvent(event, rewritten_event);
1501 } 1563 }
1502 1564
1565 EventRewriter* rewriter() const { return rewriter_.get(); }
1566
1567 ash::StickyKeysController* sticky_keys_controller() const {
1568 return sticky_keys_controller_;
1569 }
1570
1503 protected: 1571 protected:
1504 virtual void SetUp() OVERRIDE { 1572 virtual void SetUp() OVERRIDE {
1505 AshTestBase::SetUp(); 1573 AshTestBase::SetUp();
1506 rewriter_.reset(new EventRewriter()); 1574 sticky_keys_controller_ =
1575 ash::Shell::GetInstance()->sticky_keys_controller();
1576 rewriter_.reset(new EventRewriter(sticky_keys_controller_));
1507 chromeos::Preferences::RegisterProfilePrefs(prefs_.registry()); 1577 chromeos::Preferences::RegisterProfilePrefs(prefs_.registry());
1508 rewriter_->set_pref_service_for_testing(&prefs_); 1578 rewriter_->set_pref_service_for_testing(&prefs_);
1579 #if defined(USE_X11)
1580 ui::SetUpTouchPadForTest(kTouchPadDeviceId);
1581 #endif
1509 } 1582 }
1510 1583
1511 virtual void TearDown() OVERRIDE { 1584 virtual void TearDown() OVERRIDE {
1512 rewriter_.reset(); 1585 rewriter_.reset();
1513 AshTestBase::TearDown(); 1586 AshTestBase::TearDown();
1514 } 1587 }
1515 1588
1516 TestingPrefServiceSyncable prefs_; 1589 TestingPrefServiceSyncable prefs_;
1517 1590
1518 private: 1591 private:
1519 scoped_ptr<EventRewriter> rewriter_; 1592 scoped_ptr<EventRewriter> rewriter_;
1520 1593
1521 chromeos::MockUserManager* mock_user_manager_; // Not owned. 1594 chromeos::MockUserManager* mock_user_manager_; // Not owned.
1522 chromeos::ScopedUserManagerEnabler user_manager_enabler_; 1595 chromeos::ScopedUserManagerEnabler user_manager_enabler_;
1596 ash::StickyKeysController* sticky_keys_controller_;
1523 1597
1524 DISALLOW_COPY_AND_ASSIGN(EventRewriterAshTest); 1598 DISALLOW_COPY_AND_ASSIGN(EventRewriterAshTest);
1525 }; 1599 };
1526 1600
1527 TEST_F(EventRewriterAshTest, TopRowKeysAreFunctionKeys) { 1601 TEST_F(EventRewriterAshTest, TopRowKeysAreFunctionKeys) {
1528 scoped_ptr<aura::Window> window(CreateTestWindowInShellWithId(1)); 1602 scoped_ptr<aura::Window> window(CreateTestWindowInShellWithId(1));
1529 ash::wm::WindowState* window_state = ash::wm::GetWindowState(window.get()); 1603 ash::wm::WindowState* window_state = ash::wm::GetWindowState(window.get());
1530 window_state->Activate(); 1604 window_state->Activate();
1531 1605
1532 // Create a simulated keypress of F1 targetted at the window. 1606 // Create a simulated keypress of F1 targetted at the window.
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
1570 device_list.push_back(10); 1644 device_list.push_back(10);
1571 ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list); 1645 ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list);
1572 1646
1573 // Remap Control to Alt. 1647 // Remap Control to Alt.
1574 TestingPrefServiceSyncable prefs; 1648 TestingPrefServiceSyncable prefs;
1575 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); 1649 chromeos::Preferences::RegisterProfilePrefs(prefs.registry());
1576 IntegerPrefMember control; 1650 IntegerPrefMember control;
1577 control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); 1651 control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
1578 control.SetValue(chromeos::input_method::kAltKey); 1652 control.SetValue(chromeos::input_method::kAltKey);
1579 1653
1580 EventRewriter rewriter; 1654 EventRewriter rewriter(NULL);
1581 rewriter.set_pref_service_for_testing(&prefs); 1655 rewriter.set_pref_service_for_testing(&prefs);
1582 1656
1583 // Check that Control + Left Button is converted (via Alt + Left Button) 1657 // Check that Control + Left Button is converted (via Alt + Left Button)
1584 // to Right Button. 1658 // to Right Button.
1585 ui::ScopedXI2Event xev; 1659 ui::ScopedXI2Event xev;
1586 xev.InitGenericButtonEvent(10, 1660 xev.InitGenericButtonEvent(10,
1587 ui::ET_MOUSE_PRESSED, 1661 ui::ET_MOUSE_PRESSED,
1588 gfx::Point(), 1662 gfx::Point(),
1589 ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN); 1663 ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN);
1590 ui::MouseEvent press(xev); 1664 ui::MouseEvent press(xev);
1591 // Sanity check. 1665 // Sanity check.
1592 EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type()); 1666 EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type());
1593 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN, press.flags()); 1667 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN, press.flags());
1594 int flags = RewriteMouseEvent(&rewriter, press); 1668 int flags = RewriteMouseEvent(&rewriter, press);
1595 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & flags); 1669 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & flags);
1596 EXPECT_FALSE(ui::EF_CONTROL_DOWN & flags); 1670 EXPECT_FALSE(ui::EF_CONTROL_DOWN & flags);
1597 EXPECT_FALSE(ui::EF_ALT_DOWN & flags); 1671 EXPECT_FALSE(ui::EF_ALT_DOWN & flags);
1598 } 1672 }
1599 1673
1600 1674
1601 TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) { 1675 TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) {
1676 #if defined(USE_X11)
1677 // TODO(kpschoedel): pending changes for crbug.com/360377
1678 // to |chromeos::EventRewriter::RewriteLocatedEvent()
1602 std::vector<unsigned int> device_list; 1679 std::vector<unsigned int> device_list;
1603 device_list.push_back(10); 1680 device_list.push_back(10);
1604 device_list.push_back(11); 1681 device_list.push_back(11);
1605 ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list); 1682 ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list);
1606 TestingPrefServiceSyncable prefs; 1683 TestingPrefServiceSyncable prefs;
1607 EventRewriter rewriter; 1684 EventRewriter rewriter(NULL);
1608 rewriter.set_pref_service_for_testing(&prefs); 1685 rewriter.set_pref_service_for_testing(&prefs);
1609 const int kLeftAndAltFlag = ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN; 1686 const int kLeftAndAltFlag = ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN;
1610 { 1687 {
1611 ui::ScopedXI2Event xev; 1688 ui::ScopedXI2Event xev;
1612 xev.InitGenericButtonEvent( 1689 xev.InitGenericButtonEvent(
1613 10, ui::ET_MOUSE_PRESSED, gfx::Point(), kLeftAndAltFlag); 1690 10, ui::ET_MOUSE_PRESSED, gfx::Point(), kLeftAndAltFlag);
1614 ui::MouseEvent press(xev); 1691 ui::MouseEvent press(xev);
1615 // Sanity check. 1692 // Sanity check.
1616 EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type()); 1693 EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type());
1617 EXPECT_EQ(kLeftAndAltFlag, press.flags()); 1694 EXPECT_EQ(kLeftAndAltFlag, press.flags());
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after
1663 EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & flags); 1740 EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & flags);
1664 } 1741 }
1665 { 1742 {
1666 ui::ScopedXI2Event xev; 1743 ui::ScopedXI2Event xev;
1667 xev.InitGenericButtonEvent( 1744 xev.InitGenericButtonEvent(
1668 11, ui::ET_MOUSE_RELEASED, gfx::Point(), kLeftAndAltFlag); 1745 11, ui::ET_MOUSE_RELEASED, gfx::Point(), kLeftAndAltFlag);
1669 ui::MouseEvent release(xev); 1746 ui::MouseEvent release(xev);
1670 int flags = RewriteMouseEvent(&rewriter, release); 1747 int flags = RewriteMouseEvent(&rewriter, release);
1671 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & flags); 1748 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & flags);
1672 } 1749 }
1750 #endif
1751 }
1752
1753 TEST_F(EventRewriterAshTest, StickyKeyEventDispatchImpl) {
1754 // Test the actual key event dispatch implementation.
1755 EventBuffer buffer;
1756 TestEventSource source(&buffer);
1757 source.AddEventRewriter(rewriter());
1758 sticky_keys_controller()->Enable(true);
1759 ScopedVector<ui::Event> events;
1760
1761 source.SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
1762 buffer.PopEvents(&events);
1763 EXPECT_EQ(1u, events.size());
1764 EXPECT_EQ(ui::ET_KEY_PRESSED, events[0]->type());
1765 EXPECT_EQ(ui::VKEY_CONTROL,
1766 static_cast<ui::KeyEvent*>(events[0])->key_code());
1767
1768 // Test key press event is correctly modified and modifier release
1769 // event is sent.
1770 ui::KeyEvent press(ui::ET_KEY_PRESSED, ui::VKEY_C, ui::EF_NONE, false);
1771 ui::EventDispatchDetails details = source.Send(&press);
1772 buffer.PopEvents(&events);
1773 EXPECT_EQ(2u, events.size());
1774 EXPECT_EQ(ui::ET_KEY_PRESSED, events[0]->type());
1775 EXPECT_EQ(ui::VKEY_C, static_cast<ui::KeyEvent*>(events[0])->key_code());
1776 EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
1777 EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type());
1778 EXPECT_EQ(ui::VKEY_CONTROL,
1779 static_cast<ui::KeyEvent*>(events[1])->key_code());
1780
1781 // Test key release event is not modified.
1782 ui::KeyEvent release(ui::ET_KEY_RELEASED, ui::VKEY_C, ui::EF_NONE, false);
1783 details = source.Send(&release);
1784 ASSERT_FALSE(details.dispatcher_destroyed);
1785 buffer.PopEvents(&events);
1786 EXPECT_EQ(1u, events.size());
1787 EXPECT_EQ(ui::ET_KEY_RELEASED, events[0]->type());
1788 EXPECT_EQ(ui::VKEY_C, static_cast<ui::KeyEvent*>(events[0])->key_code());
1789 EXPECT_FALSE(events[0]->flags() & ui::EF_CONTROL_DOWN);
1790 }
1791
1792 TEST_F(EventRewriterAshTest, MouseEventDispatchImpl) {
1793 EventBuffer buffer;
1794 TestEventSource source(&buffer);
1795 source.AddEventRewriter(rewriter());
1796 sticky_keys_controller()->Enable(true);
1797 ScopedVector<ui::Event> events;
1798
1799 source.SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
1800 buffer.PopEvents(&events);
1801
1802 // Test mouse press event is correctly modified.
1803 gfx::Point location(0, 0);
1804 ui::MouseEvent press(ui::ET_MOUSE_PRESSED,
1805 location,
1806 location,
1807 ui::EF_LEFT_MOUSE_BUTTON,
1808 ui::EF_LEFT_MOUSE_BUTTON);
1809 ui::EventDispatchDetails details = source.Send(&press);
1810 ASSERT_FALSE(details.dispatcher_destroyed);
1811 buffer.PopEvents(&events);
1812 EXPECT_EQ(1u, events.size());
1813 EXPECT_EQ(ui::ET_MOUSE_PRESSED, events[0]->type());
1814 EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
1815
1816 // Test mouse release event is correctly modified and modifier release
1817 // event is sent. The mouse event should have the correct DIP location.
1818 ui::MouseEvent release(ui::ET_MOUSE_RELEASED,
1819 location,
1820 location,
1821 ui::EF_LEFT_MOUSE_BUTTON,
1822 ui::EF_LEFT_MOUSE_BUTTON);
1823 details = source.Send(&release);
1824 ASSERT_FALSE(details.dispatcher_destroyed);
1825 buffer.PopEvents(&events);
1826 EXPECT_EQ(2u, events.size());
1827 EXPECT_EQ(ui::ET_MOUSE_RELEASED, events[0]->type());
1828 EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
1829 EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type());
1830 EXPECT_EQ(ui::VKEY_CONTROL,
1831 static_cast<ui::KeyEvent*>(events[1])->key_code());
1832 }
1833
1834 TEST_F(EventRewriterAshTest, MouseWheelEventDispatchImpl) {
1835 EventBuffer buffer;
1836 TestEventSource source(&buffer);
1837 source.AddEventRewriter(rewriter());
1838 sticky_keys_controller()->Enable(true);
1839 ScopedVector<ui::Event> events;
1840
1841 // Test positive mouse wheel event is correctly modified and modifier release
1842 // event is sent.
1843 source.SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
1844 buffer.PopEvents(&events);
1845 gfx::Point location(0, 0);
1846 ui::MouseEvent mev(ui::ET_MOUSEWHEEL,
1847 location,
1848 location,
1849 ui::EF_LEFT_MOUSE_BUTTON,
1850 ui::EF_LEFT_MOUSE_BUTTON);
1851 ui::MouseWheelEvent positive(mev, 0, ui::MouseWheelEvent::kWheelDelta);
1852 ui::EventDispatchDetails details = source.Send(&positive);
1853 ASSERT_FALSE(details.dispatcher_destroyed);
1854 buffer.PopEvents(&events);
1855 EXPECT_EQ(2u, events.size());
1856 EXPECT_TRUE(events[0]->IsMouseWheelEvent());
1857 EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
1858 EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type());
1859 EXPECT_EQ(ui::VKEY_CONTROL,
1860 static_cast<ui::KeyEvent*>(events[1])->key_code());
1861
1862 // Test negative mouse wheel event is correctly modified and modifier release
1863 // event is sent.
1864 source.SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
1865 buffer.PopEvents(&events);
1866 ui::MouseWheelEvent negative(mev, 0, -ui::MouseWheelEvent::kWheelDelta);
1867 details = source.Send(&negative);
1868 ASSERT_FALSE(details.dispatcher_destroyed);
1869 buffer.PopEvents(&events);
1870 EXPECT_EQ(2u, events.size());
1871 EXPECT_TRUE(events[0]->IsMouseWheelEvent());
1872 EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
1873 EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type());
1874 EXPECT_EQ(ui::VKEY_CONTROL,
1875 static_cast<ui::KeyEvent*>(events[1])->key_code());
1673 } 1876 }
1674 1877
1675 } // namespace chromeos 1878 } // namespace chromeos
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698