| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/chromeos/events/event_rewriter.h" |
| |
| #include <X11/keysym.h> |
| #include <X11/XF86keysym.h> |
| #include <X11/Xlib.h> |
| #undef Bool |
| #undef None |
| #undef RootWindow |
| |
| #include <vector> |
| |
| #include "ash/test/ash_test_base.h" |
| #include "ash/wm/window_state.h" |
| #include "base/basictypes.h" |
| #include "base/command_line.h" |
| #include "base/prefs/pref_member.h" |
| #include "base/strings/stringprintf.h" |
| #include "chrome/browser/chromeos/input_method/input_method_configuration.h" |
| #include "chrome/browser/chromeos/input_method/mock_input_method_manager.h" |
| #include "chrome/browser/chromeos/login/users/mock_user_manager.h" |
| #include "chrome/browser/chromeos/login/users/user_manager.h" |
| #include "chrome/browser/chromeos/preferences.h" |
| #include "chrome/common/pref_names.h" |
| #include "chrome/test/base/testing_pref_service_syncable.h" |
| #include "chromeos/chromeos_switches.h" |
| #include "chromeos/ime/fake_ime_keyboard.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "ui/aura/window.h" |
| #include "ui/events/event.h" |
| #include "ui/events/event_rewriter.h" |
| #include "ui/events/test/events_test_utils_x11.h" |
| #include "ui/events/x/touch_factory_x11.h" |
| #include "ui/gfx/x/x11_types.h" |
| |
| namespace { |
| |
| std::string GetExpectedResultAsString(ui::KeyboardCode ui_keycode, |
| int ui_flags, |
| ui::EventType ui_type) { |
| return base::StringPrintf("ui_keycode=0x%X ui_flags=0x%X ui_type=%d", |
| ui_keycode, |
| ui_flags & ~ui::EF_IS_REPEAT, |
| ui_type); |
| } |
| |
| std::string GetKeyEventAsString(const ui::KeyEvent& keyevent) { |
| return GetExpectedResultAsString( |
| keyevent.key_code(), keyevent.flags(), keyevent.type()); |
| } |
| |
| std::string GetRewrittenEventAsString(chromeos::EventRewriter* rewriter, |
| ui::KeyboardCode ui_keycode, |
| int ui_flags, |
| ui::EventType ui_type) { |
| const ui::KeyEvent event(ui_type, ui_keycode, ui_flags, false); |
| scoped_ptr<ui::Event> new_event; |
| rewriter->RewriteEvent(event, &new_event); |
| if (new_event) |
| return GetKeyEventAsString( |
| static_cast<const ui::KeyEvent&>(*new_event.get())); |
| return GetKeyEventAsString(event); |
| } |
| |
| // Table entry for simple single key event rewriting tests. |
| struct KeyTestCase { |
| enum { |
| // Test types: |
| TEST_VKEY = 1 << 0, // Test ui::KeyEvent with no native event |
| TEST_X11 = 1 << 1, // Test ui::KeyEvent with native XKeyEvent |
| TEST_ALL = TEST_VKEY|TEST_X11, |
| // Special test flags: |
| NUMPAD = 1 << 8, // Set EF_NUMPAD_KEY on native-based event, because |
| // |XKeysymForWindowsKeyCode()| can not distinguish |
| // between pairs like XK_Insert and XK_KP_Insert. |
| }; |
| int test; |
| ui::EventType type; |
| struct { |
| ui::KeyboardCode key_code; |
| int flags; |
| } input, expected; |
| }; |
| |
| // Tests a single stateless key rewrite operation. |
| // |i| is a an identifying number to locate failing tests in the tables. |
| void CheckKeyTestCase(size_t i, |
| chromeos::EventRewriter* rewriter, |
| const KeyTestCase& test) { |
| std::string id = base::StringPrintf("(%zu) ", i); |
| std::string expected = |
| id + GetExpectedResultAsString( |
| test.expected.key_code, test.expected.flags, test.type); |
| |
| if (test.test & KeyTestCase::TEST_VKEY) { |
| // Check rewriting of a non-native-based key event. |
| EXPECT_EQ( |
| expected, |
| id + GetRewrittenEventAsString( |
| rewriter, test.input.key_code, test.input.flags, test.type)); |
| } |
| |
| #if defined(USE_X11) |
| if (test.test & KeyTestCase::TEST_X11) { |
| ui::ScopedXI2Event xev; |
| xev.InitKeyEvent(test.type, test.input.key_code, test.input.flags); |
| XEvent* xevent = xev; |
| if (xevent->xkey.keycode) { |
| ui::KeyEvent xkey_event(xevent, false); |
| if (test.test & KeyTestCase::NUMPAD) |
| xkey_event.set_flags(xkey_event.flags() | ui::EF_NUMPAD_KEY); |
| // Verify that the X11-based key event is as expected. |
| EXPECT_EQ(id + GetExpectedResultAsString( |
| test.input.key_code, test.input.flags, test.type), |
| id + GetKeyEventAsString(xkey_event)); |
| // Rewrite the event and check the result. |
| scoped_ptr<ui::Event> new_event; |
| rewriter->RewriteEvent(xkey_event, &new_event); |
| ui::KeyEvent& rewritten_key_event = |
| new_event ? *static_cast<ui::KeyEvent*>(new_event.get()) : xkey_event; |
| EXPECT_EQ(expected, id + GetKeyEventAsString(rewritten_key_event)); |
| if ((rewritten_key_event.key_code() != ui::VKEY_UNKNOWN) && |
| (rewritten_key_event.native_event()->xkey.keycode != 0)) { |
| // Build a new ui::KeyEvent from the rewritten native component, |
| // and check that it also matches the rewritten event. |
| ui::KeyEvent from_native_event(rewritten_key_event.native_event(), |
| false); |
| EXPECT_EQ(expected, id + GetKeyEventAsString(from_native_event)); |
| } |
| } |
| } |
| #endif |
| } |
| |
| // Table entry for simple single function key event rewriting tests. |
| struct FunctionKeyTestCase { |
| ui::EventType type; |
| struct { |
| ui::KeyboardCode key_code; |
| int flags; |
| } input, vkey_expected, native_expected; |
| }; |
| |
| // Tests a single stateless function key rewrite operation. |
| // |i| is a an identifying number to locate failing tests in the tables. |
| // Function key mapping differs from the other key mappings because the |
| // EF_FUNCTION_KEY flag is set during ui::KeyEvent construction when passing in |
| // a native X11 event and the flag is not set when using other constructors. |
| void CheckFunctionKeyTestCase(size_t i, |
| chromeos::EventRewriter* rewriter, |
| const FunctionKeyTestCase& test) { |
| std::string id = base::StringPrintf("(%zu) ", i); |
| std::string vkey_expected = |
| id + GetExpectedResultAsString( |
| test.vkey_expected.key_code, |
| test.vkey_expected.flags, |
| test.type); |
| // Check rewriting of a non-native-based key event. |
| EXPECT_EQ( |
| vkey_expected, |
| id + GetRewrittenEventAsString( |
| rewriter, test.input.key_code, test.input.flags, test.type)); |
| |
| #if defined(USE_X11) |
| ui::ScopedXI2Event xev; |
| xev.InitKeyEvent(test.type, test.input.key_code, test.input.flags); |
| XEvent* xevent = xev; |
| if (xevent->xkey.keycode) { |
| ui::KeyEvent xkey_event(xevent, false); |
| // Rewrite the event and check the result. |
| scoped_ptr<ui::Event> new_event; |
| rewriter->RewriteEvent(xkey_event, &new_event); |
| ui::KeyEvent& rewritten_key_event = |
| new_event ? *static_cast<ui::KeyEvent*>(new_event.get()) : xkey_event; |
| std::string native_expected = |
| id + GetExpectedResultAsString( |
| test.native_expected.key_code, |
| test.native_expected.flags, |
| test.type); |
| EXPECT_EQ(native_expected, id + GetKeyEventAsString(rewritten_key_event)); |
| } |
| #endif |
| } |
| |
| } // namespace |
| |
| namespace chromeos { |
| |
| class EventRewriterTest : public ash::test::AshTestBase { |
| public: |
| EventRewriterTest() |
| : display_(gfx::GetXDisplay()), |
| mock_user_manager_(new chromeos::MockUserManager), |
| user_manager_enabler_(mock_user_manager_), |
| input_method_manager_mock_(NULL) {} |
| virtual ~EventRewriterTest() {} |
| |
| virtual void SetUp() { |
| // Mocking user manager because the real one needs to be called on UI thread |
| EXPECT_CALL(*mock_user_manager_, IsLoggedInAsGuest()) |
| .WillRepeatedly(testing::Return(false)); |
| input_method_manager_mock_ = |
| new chromeos::input_method::MockInputMethodManager; |
| chromeos::input_method::InitializeForTesting( |
| input_method_manager_mock_); // pass ownership |
| |
| AshTestBase::SetUp(); |
| } |
| |
| virtual void TearDown() { |
| AshTestBase::TearDown(); |
| // Shutdown() deletes the IME mock object. |
| chromeos::input_method::Shutdown(); |
| } |
| |
| protected: |
| void TestRewriteNumPadKeys(); |
| void TestRewriteNumPadKeysOnAppleKeyboard(); |
| |
| int RewriteMouseEvent(chromeos::EventRewriter* rewriter, |
| const ui::MouseEvent& event) { |
| int flags = event.flags(); |
| rewriter->RewriteLocatedEventForTesting(event, &flags); |
| return flags; |
| } |
| |
| Display* display_; |
| chromeos::MockUserManager* mock_user_manager_; // Not owned. |
| chromeos::ScopedUserManagerEnabler user_manager_enabler_; |
| chromeos::input_method::MockInputMethodManager* input_method_manager_mock_; |
| }; |
| |
| TEST_F(EventRewriterTest, TestRewriteCommandToControl) { |
| // First, test with a PC keyboard. |
| TestingPrefServiceSyncable prefs; |
| EventRewriter rewriter; |
| rewriter.DeviceAddedForTesting(0, "PC Keyboard"); |
| rewriter.set_last_device_id_for_testing(0); |
| rewriter.set_pref_service_for_testing(&prefs); |
| |
| KeyTestCase pc_keyboard_tests[] = { |
| // VKEY_A, Alt modifier. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_A, ui::EF_ALT_DOWN}, |
| {ui::VKEY_A, ui::EF_ALT_DOWN}}, |
| |
| // VKEY_A, Win modifier. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_A, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_A, ui::EF_COMMAND_DOWN}}, |
| |
| // VKEY_A, Alt+Win modifier. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_A, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_A, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}}, |
| |
| // VKEY_LWIN (left Windows key), Alt modifier. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LWIN, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_LWIN, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}}, |
| |
| // VKEY_RWIN (right Windows key), Alt modifier. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_RWIN, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_RWIN, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(pc_keyboard_tests); ++i) { |
| CheckKeyTestCase(1000 + i, &rewriter, pc_keyboard_tests[i]); |
| } |
| |
| // An Apple keyboard reusing the ID, zero. |
| rewriter.DeviceAddedForTesting(0, "Apple Keyboard"); |
| rewriter.set_last_device_id_for_testing(0); |
| |
| KeyTestCase apple_keyboard_tests[] = { |
| // VKEY_A, Alt modifier. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_A, ui::EF_ALT_DOWN}, |
| {ui::VKEY_A, ui::EF_ALT_DOWN}}, |
| |
| // VKEY_A, Win modifier. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_A, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_A, ui::EF_CONTROL_DOWN}}, |
| |
| // VKEY_A, Alt+Win modifier. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_A, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_A, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN}}, |
| |
| // VKEY_LWIN (left Windows key), Alt modifier. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN}, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN}}, |
| |
| // VKEY_RWIN (right Windows key), Alt modifier. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_RWIN, ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN}, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(apple_keyboard_tests); ++i) { |
| CheckKeyTestCase(2000 + i, &rewriter, apple_keyboard_tests[i]); |
| } |
| } |
| |
| // For crbug.com/133896. |
| TEST_F(EventRewriterTest, TestRewriteCommandToControlWithControlRemapped) { |
| // Remap Control to Alt. |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| IntegerPrefMember control; |
| control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); |
| control.SetValue(chromeos::input_method::kAltKey); |
| |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| rewriter.DeviceAddedForTesting(0, "PC Keyboard"); |
| rewriter.set_last_device_id_for_testing(0); |
| |
| KeyTestCase pc_keyboard_tests[] = {// Control should be remapped to Alt. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_MENU, ui::EF_ALT_DOWN}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(pc_keyboard_tests); ++i) { |
| CheckKeyTestCase(1000 + i, &rewriter, pc_keyboard_tests[i]); |
| } |
| |
| // An Apple keyboard reusing the ID, zero. |
| rewriter.DeviceAddedForTesting(0, "Apple Keyboard"); |
| rewriter.set_last_device_id_for_testing(0); |
| |
| KeyTestCase apple_keyboard_tests[] = { |
| // VKEY_LWIN (left Command key) with Alt modifier. The remapped Command |
| // key should never be re-remapped to Alt. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN}, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN}}, |
| |
| // VKEY_RWIN (right Command key) with Alt modifier. The remapped Command |
| // key should never be re-remapped to Alt. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_RWIN, ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN}, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(apple_keyboard_tests); ++i) { |
| CheckKeyTestCase(2000 + i, &rewriter, apple_keyboard_tests[i]); |
| } |
| } |
| |
| void EventRewriterTest::TestRewriteNumPadKeys() { |
| TestingPrefServiceSyncable prefs; |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| |
| KeyTestCase tests[] = { |
| // XK_KP_Insert (= NumPad 0 without Num Lock), no modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_INSERT, ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD0, ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_Insert (= NumPad 0 without Num Lock), Alt modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_INSERT, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD0, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_Delete (= NumPad . without Num Lock), Alt modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_DELETE, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_DECIMAL, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_End (= NumPad 1 without Num Lock), Alt modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_END, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD1, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_Down (= NumPad 2 without Num Lock), Alt modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_DOWN, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD2, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_Next (= NumPad 3 without Num Lock), Alt modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_NEXT, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD3, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_Left (= NumPad 4 without Num Lock), Alt modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LEFT, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD4, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_Begin (= NumPad 5 without Num Lock), Alt modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_CLEAR, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD5, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_Right (= NumPad 6 without Num Lock), Alt modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_RIGHT, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD6, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_Home (= NumPad 7 without Num Lock), Alt modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_HOME, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD7, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_Up (= NumPad 8 without Num Lock), Alt modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_UP, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD8, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_Prior (= NumPad 9 without Num Lock), Alt modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_PRIOR, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD9, ui::EF_ALT_DOWN | ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_0 (= NumPad 0 with Num Lock), Num Lock modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_NUMPAD0, ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD0, ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_DECIMAL (= NumPad . with Num Lock), Num Lock modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_DECIMAL, ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_DECIMAL, ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_1 (= NumPad 1 with Num Lock), Num Lock modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_NUMPAD1, ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD1, ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_2 (= NumPad 2 with Num Lock), Num Lock modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_NUMPAD2, ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD2, ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_3 (= NumPad 3 with Num Lock), Num Lock modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_NUMPAD3, ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD3, ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_4 (= NumPad 4 with Num Lock), Num Lock modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_NUMPAD4, ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD4, ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_5 (= NumPad 5 with Num Lock), Num Lock modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_NUMPAD5, ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD5, ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_6 (= NumPad 6 with Num Lock), Num Lock modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_NUMPAD6, ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD6, ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_7 (= NumPad 7 with Num Lock), Num Lock modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_NUMPAD7, ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD7, ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_8 (= NumPad 8 with Num Lock), Num Lock modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_NUMPAD8, ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD8, ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_9 (= NumPad 9 with Num Lock), Num Lock modifier. |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_NUMPAD9, ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD9, ui::EF_NUMPAD_KEY}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(tests); ++i) { |
| CheckKeyTestCase(1000 + i, &rewriter, tests[i]); |
| } |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteNumPadKeys) { |
| TestRewriteNumPadKeys(); |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteNumPadKeysWithDiamondKeyFlag) { |
| // Make sure the num lock works correctly even when Diamond key exists. |
| const CommandLine original_cl(*CommandLine::ForCurrentProcess()); |
| CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
| chromeos::switches::kHasChromeOSDiamondKey, ""); |
| |
| TestRewriteNumPadKeys(); |
| *CommandLine::ForCurrentProcess() = original_cl; |
| } |
| |
| // Tests if the rewriter can handle a Command + Num Pad event. |
| void EventRewriterTest::TestRewriteNumPadKeysOnAppleKeyboard() { |
| TestingPrefServiceSyncable prefs; |
| EventRewriter rewriter; |
| rewriter.DeviceAddedForTesting(0, "Apple Keyboard"); |
| rewriter.set_last_device_id_for_testing(0); |
| rewriter.set_pref_service_for_testing(&prefs); |
| |
| KeyTestCase tests[] = { |
| // XK_KP_End (= NumPad 1 without Num Lock), Win modifier. |
| // The result should be "Num Pad 1 with Control + Num Lock modifiers". |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_END, ui::EF_COMMAND_DOWN | ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD1, ui::EF_CONTROL_DOWN | ui::EF_NUMPAD_KEY}}, |
| |
| // XK_KP_1 (= NumPad 1 with Num Lock), Win modifier. |
| // The result should also be "Num Pad 1 with Control + Num Lock |
| // modifiers". |
| {KeyTestCase::TEST_ALL|KeyTestCase::NUMPAD, ui::ET_KEY_PRESSED, |
| {ui::VKEY_NUMPAD1, ui::EF_COMMAND_DOWN | ui::EF_NUMPAD_KEY}, |
| {ui::VKEY_NUMPAD1, ui::EF_CONTROL_DOWN | ui::EF_NUMPAD_KEY}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(tests); ++i) { |
| CheckKeyTestCase(1000 + i, &rewriter, tests[i]); |
| } |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteNumPadKeysOnAppleKeyboard) { |
| TestRewriteNumPadKeysOnAppleKeyboard(); |
| } |
| |
| TEST_F(EventRewriterTest, |
| TestRewriteNumPadKeysOnAppleKeyboardWithDiamondKeyFlag) { |
| // Makes sure the num lock works correctly even when Diamond key exists. |
| const CommandLine original_cl(*CommandLine::ForCurrentProcess()); |
| CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
| chromeos::switches::kHasChromeOSDiamondKey, ""); |
| |
| TestRewriteNumPadKeysOnAppleKeyboard(); |
| *CommandLine::ForCurrentProcess() = original_cl; |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteModifiersNoRemap) { |
| TestingPrefServiceSyncable prefs; |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| |
| KeyTestCase tests[] = { |
| // Press Search. Confirm the event is not rewritten. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LWIN, ui::EF_NONE}, |
| {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN}}, |
| |
| // Press left Control. Confirm the event is not rewritten. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}}, |
| |
| // Press right Control. Confirm the event is not rewritten. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}}, |
| |
| // Press left Alt. Confirm the event is not rewritten. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_MENU, ui::EF_ALT_DOWN}, |
| {ui::VKEY_MENU, ui::EF_ALT_DOWN}}, |
| |
| // Press right Alt. Confirm the event is not rewritten. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_MENU, ui::EF_ALT_DOWN}, |
| {ui::VKEY_MENU, ui::EF_ALT_DOWN}}, |
| |
| // Test KeyRelease event, just in case. |
| // Release Search. Confirm the release event is not rewritten. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_RELEASED, |
| {ui::VKEY_LWIN, ui::EF_NONE}, |
| {ui::VKEY_LWIN, ui::EF_NONE}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(tests); ++i) { |
| CheckKeyTestCase(1000 + i, &rewriter, tests[i]); |
| } |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteModifiersNoRemapMultipleKeys) { |
| TestingPrefServiceSyncable prefs; |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| |
| KeyTestCase tests[] = { |
| // Press Alt with Shift. Confirm the event is not rewritten. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN}, |
| {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN}}, |
| |
| // Press Search with Caps Lock mask. Confirm the event is not rewritten. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LWIN, ui::EF_CAPS_LOCK_DOWN | ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_LWIN, ui::EF_CAPS_LOCK_DOWN | ui::EF_COMMAND_DOWN}}, |
| |
| // Release Search with Caps Lock mask. Confirm the event is not rewritten. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_RELEASED, |
| {ui::VKEY_LWIN, ui::EF_CAPS_LOCK_DOWN}, |
| {ui::VKEY_LWIN, ui::EF_CAPS_LOCK_DOWN}}, |
| |
| // Press Shift+Ctrl+Alt+Search+A. Confirm the event is not rewritten. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_B, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | |
| ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_B, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | |
| ui::EF_COMMAND_DOWN}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(tests); ++i) { |
| CheckKeyTestCase(1000 + i, &rewriter, tests[i]); |
| } |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteModifiersDisableSome) { |
| // Disable Search and Control keys. |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| IntegerPrefMember search; |
| search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); |
| search.SetValue(chromeos::input_method::kVoidKey); |
| IntegerPrefMember control; |
| control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); |
| control.SetValue(chromeos::input_method::kVoidKey); |
| |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| |
| KeyTestCase disabled_modifier_tests[] = { |
| // Press Alt with Shift. This key press shouldn't be affected by the |
| // pref. Confirm the event is not rewritten. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN}, |
| {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN}}, |
| |
| // Press Search. Confirm the event is now VKEY_UNKNOWN. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LWIN, ui::EF_NONE}, |
| {ui::VKEY_UNKNOWN, ui::EF_NONE}}, |
| |
| // Press Control. Confirm the event is now VKEY_UNKNOWN. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_UNKNOWN, ui::EF_NONE}}, |
| |
| // Press Control+Search. Confirm the event is now VKEY_UNKNOWN |
| // without any modifiers. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LWIN, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_UNKNOWN, ui::EF_NONE}}, |
| |
| // Press Control+Search+a. Confirm the event is now VKEY_A without any |
| // modifiers. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_A, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_A, ui::EF_NONE}}, |
| |
| // Press Control+Search+Alt+a. Confirm the event is now VKEY_A only with |
| // the Alt modifier. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_A, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN}, |
| {ui::VKEY_A, ui::EF_ALT_DOWN}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(disabled_modifier_tests); ++i) { |
| CheckKeyTestCase(1000 + i, &rewriter, disabled_modifier_tests[i]); |
| } |
| |
| // Remap Alt to Control. |
| IntegerPrefMember alt; |
| alt.Init(prefs::kLanguageRemapAltKeyTo, &prefs); |
| alt.SetValue(chromeos::input_method::kControlKey); |
| |
| KeyTestCase tests[] = { |
| // Press left Alt. Confirm the event is now VKEY_CONTROL |
| // even though the Control key itself is disabled. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_MENU, ui::EF_ALT_DOWN}, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}}, |
| |
| // Press Alt+a. Confirm the event is now Control+a even though the Control |
| // key itself is disabled. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_A, ui::EF_ALT_DOWN}, |
| {ui::VKEY_A, ui::EF_CONTROL_DOWN}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(tests); ++i) { |
| CheckKeyTestCase(2000 + i, &rewriter, tests[i]); |
| } |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteModifiersRemapToControl) { |
| // Remap Search to Control. |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| IntegerPrefMember search; |
| search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); |
| search.SetValue(chromeos::input_method::kControlKey); |
| |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| |
| KeyTestCase s_tests[] = { |
| // Press Search. Confirm the event is now VKEY_CONTROL. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(s_tests); ++i) { |
| CheckKeyTestCase(1000 + i, &rewriter, s_tests[i]); |
| } |
| |
| // Remap Alt to Control too. |
| IntegerPrefMember alt; |
| alt.Init(prefs::kLanguageRemapAltKeyTo, &prefs); |
| alt.SetValue(chromeos::input_method::kControlKey); |
| |
| KeyTestCase sa_tests[] = { |
| // Press Alt. Confirm the event is now VKEY_CONTROL. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_MENU, ui::EF_ALT_DOWN}, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}}, |
| |
| // Press Alt+Search. Confirm the event is now VKEY_CONTROL. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LWIN, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}}, |
| |
| // Press Control+Alt+Search. Confirm the event is now VKEY_CONTROL. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LWIN, |
| ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}}, |
| |
| // Press Shift+Control+Alt+Search. Confirm the event is now Control with |
| // Shift and Control modifiers. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LWIN, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | |
| ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_CONTROL, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN}}, |
| |
| // Press Shift+Control+Alt+Search+B. Confirm the event is now B with Shift |
| // and Control modifiers. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_B, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | |
| ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_B, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(sa_tests); ++i) { |
| CheckKeyTestCase(2000 + i, &rewriter, sa_tests[i]); |
| } |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteModifiersRemapToEscape) { |
| // Remap Search to ESC. |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| IntegerPrefMember search; |
| search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); |
| search.SetValue(chromeos::input_method::kEscapeKey); |
| |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| |
| KeyTestCase tests[] = {// Press Search. Confirm the event is now VKEY_ESCAPE. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_ESCAPE, ui::EF_NONE}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(tests); ++i) { |
| CheckKeyTestCase(1000 + i, &rewriter, tests[i]); |
| } |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteModifiersRemapMany) { |
| // Remap Search to Alt. |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| IntegerPrefMember search; |
| search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); |
| search.SetValue(chromeos::input_method::kAltKey); |
| |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| |
| KeyTestCase s2a_tests[] = { |
| // Press Search. Confirm the event is now VKEY_MENU. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_MENU, ui::EF_ALT_DOWN}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(s2a_tests); ++i) { |
| CheckKeyTestCase(1000 + i, &rewriter, s2a_tests[i]); |
| } |
| |
| // Remap Alt to Control. |
| IntegerPrefMember alt; |
| alt.Init(prefs::kLanguageRemapAltKeyTo, &prefs); |
| alt.SetValue(chromeos::input_method::kControlKey); |
| |
| KeyTestCase a2c_tests[] = { |
| // Press left Alt. Confirm the event is now VKEY_CONTROL. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_MENU, ui::EF_ALT_DOWN}, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(a2c_tests); ++i) { |
| CheckKeyTestCase(2000 + i, &rewriter, a2c_tests[i]); |
| } |
| |
| // Remap Control to Search. |
| IntegerPrefMember control; |
| control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); |
| control.SetValue(chromeos::input_method::kSearchKey); |
| |
| KeyTestCase c2s_tests[] = { |
| // Press left Control. Confirm the event is now VKEY_LWIN. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_LWIN, ui::EF_COMMAND_DOWN}}, |
| |
| // Then, press all of the three, Control+Alt+Search. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LWIN, |
| ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_MENU, |
| ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}}, |
| |
| // Press Shift+Control+Alt+Search. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LWIN, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | |
| ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_MENU, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | |
| ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}}, |
| |
| // Press Shift+Control+Alt+Search+B |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_B, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | |
| ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_B, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | |
| ui::EF_COMMAND_DOWN}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(c2s_tests); ++i) { |
| CheckKeyTestCase(3000 + i, &rewriter, c2s_tests[i]); |
| } |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteModifiersRemapToCapsLock) { |
| // Remap Search to Caps Lock. |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| IntegerPrefMember search; |
| search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); |
| search.SetValue(chromeos::input_method::kCapsLockKey); |
| |
| chromeos::input_method::FakeImeKeyboard ime_keyboard; |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| rewriter.set_ime_keyboard_for_testing(&ime_keyboard); |
| EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); |
| |
| // Press Search. |
| EXPECT_EQ( |
| GetExpectedResultAsString(ui::VKEY_CAPITAL, |
| ui::EF_CAPS_LOCK_DOWN | ui::EF_MOD3_DOWN, |
| ui::ET_KEY_PRESSED), |
| GetRewrittenEventAsString( |
| &rewriter, ui::VKEY_LWIN, ui::EF_COMMAND_DOWN, ui::ET_KEY_PRESSED)); |
| // Confirm that the Caps Lock status is changed. |
| EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_); |
| |
| // Release Search. |
| EXPECT_EQ(GetExpectedResultAsString( |
| ui::VKEY_CAPITAL, ui::EF_NONE, ui::ET_KEY_RELEASED), |
| GetRewrittenEventAsString( |
| &rewriter, ui::VKEY_LWIN, ui::EF_NONE, ui::ET_KEY_RELEASED)); |
| // Confirm that the Caps Lock status is not changed. |
| EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_); |
| |
| // Press Search. |
| EXPECT_EQ( |
| GetExpectedResultAsString(ui::VKEY_CAPITAL, |
| ui::EF_CAPS_LOCK_DOWN | ui::EF_MOD3_DOWN, |
| ui::ET_KEY_PRESSED), |
| GetRewrittenEventAsString(&rewriter, |
| ui::VKEY_LWIN, |
| ui::EF_COMMAND_DOWN | ui::EF_CAPS_LOCK_DOWN, |
| ui::ET_KEY_PRESSED)); |
| // Confirm that the Caps Lock status is changed. |
| EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); |
| |
| // Release Search. |
| EXPECT_EQ(GetExpectedResultAsString( |
| ui::VKEY_CAPITAL, ui::EF_NONE, ui::ET_KEY_RELEASED), |
| GetRewrittenEventAsString( |
| &rewriter, ui::VKEY_LWIN, ui::EF_NONE, ui::ET_KEY_RELEASED)); |
| // Confirm that the Caps Lock status is not changed. |
| EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); |
| |
| // Press Caps Lock (on an external keyboard). |
| EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL, |
| ui::EF_CAPS_LOCK_DOWN | ui::EF_MOD3_DOWN, |
| ui::ET_KEY_PRESSED), |
| GetRewrittenEventAsString(&rewriter, |
| ui::VKEY_CAPITAL, |
| ui::EF_CAPS_LOCK_DOWN | ui::EF_MOD3_DOWN, |
| ui::ET_KEY_PRESSED)); |
| |
| // Confirm that calling RewriteForTesting() does not change the state of |
| // |ime_keyboard|. In this case, X Window system itself should change the |
| // Caps Lock state, not ash::EventRewriter. |
| EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); |
| |
| // Release Caps Lock (on an external keyboard). |
| EXPECT_EQ(GetExpectedResultAsString( |
| ui::VKEY_CAPITAL, ui::EF_NONE, ui::ET_KEY_RELEASED), |
| GetRewrittenEventAsString( |
| &rewriter, ui::VKEY_CAPITAL, ui::EF_NONE, ui::ET_KEY_RELEASED)); |
| EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteCapsLock) { |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| |
| chromeos::input_method::FakeImeKeyboard ime_keyboard; |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| rewriter.set_ime_keyboard_for_testing(&ime_keyboard); |
| EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); |
| |
| // On Chrome OS, CapsLock is mapped to F16 with Mod3Mask. |
| EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL, |
| ui::EF_CAPS_LOCK_DOWN | ui::EF_MOD3_DOWN, |
| ui::ET_KEY_PRESSED), |
| GetRewrittenEventAsString( |
| &rewriter, ui::VKEY_F16, ui::EF_MOD3_DOWN, ui::ET_KEY_PRESSED)); |
| EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_); |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteDiamondKey) { |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| |
| chromeos::input_method::FakeImeKeyboard ime_keyboard; |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| rewriter.set_ime_keyboard_for_testing(&ime_keyboard); |
| |
| KeyTestCase tests[] = { |
| // F15 should work as Ctrl when --has-chromeos-diamond-key is not |
| // specified. |
| {KeyTestCase::TEST_VKEY, |
| ui::ET_KEY_PRESSED, |
| {ui::VKEY_F15, ui::EF_NONE}, |
| {ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN}}, |
| |
| // However, Mod2Mask should not be rewritten to CtrlMask when |
| // --has-chromeos-diamond-key is not specified. |
| {KeyTestCase::TEST_VKEY, |
| ui::ET_KEY_PRESSED, |
| {ui::VKEY_A, ui::EF_NONE}, |
| {ui::VKEY_A, ui::EF_NONE}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(tests); ++i) { |
| CheckKeyTestCase(1000 + i, &rewriter, tests[i]); |
| } |
| } |
| TEST_F(EventRewriterTest, TestRewriteDiamondKeyWithFlag) { |
| const CommandLine original_cl(*CommandLine::ForCurrentProcess()); |
| CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
| chromeos::switches::kHasChromeOSDiamondKey, ""); |
| |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| |
| chromeos::input_method::FakeImeKeyboard ime_keyboard; |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| rewriter.set_ime_keyboard_for_testing(&ime_keyboard); |
| |
| // By default, F15 should work as Control. |
| EXPECT_EQ(GetExpectedResultAsString( |
| ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN, ui::ET_KEY_PRESSED), |
| GetRewrittenEventAsString( |
| &rewriter, ui::VKEY_F15, ui::EF_NONE, ui::ET_KEY_PRESSED)); |
| |
| IntegerPrefMember diamond; |
| diamond.Init(prefs::kLanguageRemapDiamondKeyTo, &prefs); |
| diamond.SetValue(chromeos::input_method::kVoidKey); |
| |
| EXPECT_EQ(GetExpectedResultAsString( |
| ui::VKEY_UNKNOWN, ui::EF_NONE, ui::ET_KEY_PRESSED), |
| GetRewrittenEventAsString( |
| &rewriter, ui::VKEY_F15, ui::EF_NONE, ui::ET_KEY_PRESSED)); |
| |
| diamond.SetValue(chromeos::input_method::kControlKey); |
| |
| EXPECT_EQ(GetExpectedResultAsString( |
| ui::VKEY_CONTROL, ui::EF_CONTROL_DOWN, ui::ET_KEY_PRESSED), |
| GetRewrittenEventAsString( |
| &rewriter, ui::VKEY_F15, ui::EF_NONE, ui::ET_KEY_PRESSED)); |
| |
| diamond.SetValue(chromeos::input_method::kAltKey); |
| |
| EXPECT_EQ(GetExpectedResultAsString( |
| ui::VKEY_MENU, ui::EF_ALT_DOWN, ui::ET_KEY_PRESSED), |
| GetRewrittenEventAsString( |
| &rewriter, ui::VKEY_F15, ui::EF_NONE, ui::ET_KEY_PRESSED)); |
| |
| diamond.SetValue(chromeos::input_method::kCapsLockKey); |
| |
| EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL, |
| ui::EF_CAPS_LOCK_DOWN | ui::EF_MOD3_DOWN, |
| ui::ET_KEY_PRESSED), |
| GetRewrittenEventAsString( |
| &rewriter, ui::VKEY_F15, ui::EF_NONE, ui::ET_KEY_PRESSED)); |
| |
| *CommandLine::ForCurrentProcess() = original_cl; |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteCapsLockToControl) { |
| // Remap CapsLock to Control. |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| IntegerPrefMember control; |
| control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs); |
| control.SetValue(chromeos::input_method::kControlKey); |
| |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| |
| KeyTestCase tests[] = { |
| // Press CapsLock+a. Confirm that Mod3Mask is rewritten to ControlMask. |
| // On Chrome OS, CapsLock works as a Mod3 modifier. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_A, ui::EF_MOD3_DOWN}, |
| {ui::VKEY_A, ui::EF_CONTROL_DOWN}}, |
| |
| // Press Control+CapsLock+a. Confirm that Mod3Mask is rewritten to |
| // ControlMask |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_A, ui::EF_CONTROL_DOWN | ui::EF_MOD3_DOWN}, |
| {ui::VKEY_A, ui::EF_CONTROL_DOWN}}, |
| |
| // Press Alt+CapsLock+a. Confirm that Mod3Mask is rewritten to |
| // ControlMask. |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_A, ui::EF_ALT_DOWN | ui::EF_MOD3_DOWN}, |
| {ui::VKEY_A, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(tests); ++i) { |
| CheckKeyTestCase(1000 + i, &rewriter, tests[i]); |
| } |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteCapsLockMod3InUse) { |
| // Remap CapsLock to Control. |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| IntegerPrefMember control; |
| control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs); |
| control.SetValue(chromeos::input_method::kControlKey); |
| |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| input_method_manager_mock_->set_mod3_used(true); |
| |
| // Press CapsLock+a. Confirm that Mod3Mask is NOT rewritten to ControlMask |
| // when Mod3Mask is already in use by the current XKB layout. |
| EXPECT_EQ( |
| GetExpectedResultAsString(ui::VKEY_A, ui::EF_NONE, ui::ET_KEY_PRESSED), |
| GetRewrittenEventAsString( |
| &rewriter, ui::VKEY_A, ui::EF_NONE, ui::ET_KEY_PRESSED)); |
| |
| input_method_manager_mock_->set_mod3_used(false); |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteExtendedKeys) { |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| EventRewriter rewriter; |
| rewriter.DeviceAddedForTesting(0, "PC Keyboard"); |
| rewriter.set_last_device_id_for_testing(0); |
| rewriter.set_pref_service_for_testing(&prefs); |
| |
| KeyTestCase tests[] = { |
| // Alt+Backspace -> Delete |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_BACK, ui::EF_ALT_DOWN}, |
| {ui::VKEY_DELETE, ui::EF_NONE}}, |
| // Control+Alt+Backspace -> Control+Delete |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_BACK, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_DELETE, ui::EF_CONTROL_DOWN}}, |
| // Search+Alt+Backspace -> Alt+Backspace |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_BACK, ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN}, |
| {ui::VKEY_BACK, ui::EF_ALT_DOWN}}, |
| // Search+Control+Alt+Backspace -> Control+Alt+Backspace |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_BACK, |
| ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_BACK, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN}}, |
| // Alt+Up -> Prior |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_UP, ui::EF_ALT_DOWN}, |
| {ui::VKEY_PRIOR, ui::EF_NONE}}, |
| // Alt+Down -> Next |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_DOWN, ui::EF_ALT_DOWN}, |
| {ui::VKEY_NEXT, ui::EF_NONE}}, |
| // Ctrl+Alt+Up -> Home |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_UP, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_HOME, ui::EF_NONE}}, |
| // Ctrl+Alt+Down -> End |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_DOWN, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_END, ui::EF_NONE}}, |
| |
| // Search+Alt+Up -> Alt+Up |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_UP, ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN}, |
| {ui::VKEY_UP, ui::EF_ALT_DOWN}}, |
| // Search+Alt+Down -> Alt+Down |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_DOWN, ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN}, |
| {ui::VKEY_DOWN, ui::EF_ALT_DOWN}}, |
| // Search+Ctrl+Alt+Up -> Search+Ctrl+Alt+Up |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_UP, |
| ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_UP, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN}}, |
| // Search+Ctrl+Alt+Down -> Ctrl+Alt+Down |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_DOWN, |
| ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_DOWN, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN}}, |
| |
| // Period -> Period |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_OEM_PERIOD, ui::EF_NONE}, |
| {ui::VKEY_OEM_PERIOD, ui::EF_NONE}}, |
| |
| // Search+Backspace -> Delete |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_BACK, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_DELETE, ui::EF_NONE}}, |
| // Search+Up -> Prior |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_UP, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_PRIOR, ui::EF_NONE}}, |
| // Search+Down -> Next |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_DOWN, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_NEXT, ui::EF_NONE}}, |
| // Search+Left -> Home |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LEFT, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_HOME, ui::EF_NONE}}, |
| // Control+Search+Left -> Home |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_LEFT, ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_HOME, ui::EF_CONTROL_DOWN}}, |
| // Search+Right -> End |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_RIGHT, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_END, ui::EF_NONE}}, |
| // Control+Search+Right -> End |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_RIGHT, ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_END, ui::EF_CONTROL_DOWN}}, |
| // Search+Period -> Insert |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_OEM_PERIOD, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_INSERT, ui::EF_NONE}}, |
| // Control+Search+Period -> Control+Insert |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_OEM_PERIOD, ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_INSERT, ui::EF_CONTROL_DOWN}}}; |
| |
| for (size_t i = 0; i < arraysize(tests); ++i) { |
| CheckKeyTestCase(1000 + i, &rewriter, tests[i]); |
| } |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteFunctionKeys) { |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| |
| FunctionKeyTestCase tests[] = { |
| // F1 -> Back |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F1, ui::EF_NONE}, |
| {ui::VKEY_BROWSER_BACK, ui::EF_NONE}, |
| {ui::VKEY_BROWSER_BACK, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F1, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_BROWSER_BACK, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_BROWSER_BACK, ui::EF_CONTROL_DOWN | ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F1, ui::EF_ALT_DOWN}, |
| {ui::VKEY_BROWSER_BACK, ui::EF_ALT_DOWN}, |
| {ui::VKEY_BROWSER_BACK, ui::EF_ALT_DOWN | ui::EF_FUNCTION_KEY}}, |
| // F2 -> Forward |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F2, ui::EF_NONE}, |
| {ui::VKEY_BROWSER_FORWARD, ui::EF_NONE}, |
| {ui::VKEY_BROWSER_FORWARD, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F2, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_BROWSER_FORWARD, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_BROWSER_FORWARD, ui::EF_CONTROL_DOWN | ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F2, ui::EF_ALT_DOWN}, |
| {ui::VKEY_BROWSER_FORWARD, ui::EF_ALT_DOWN}, |
| {ui::VKEY_BROWSER_FORWARD, ui::EF_ALT_DOWN | ui::EF_FUNCTION_KEY}}, |
| // F3 -> Refresh |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F3, ui::EF_NONE}, |
| {ui::VKEY_BROWSER_REFRESH, ui::EF_NONE}, |
| {ui::VKEY_BROWSER_REFRESH, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F3, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_BROWSER_REFRESH, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_BROWSER_REFRESH, ui::EF_CONTROL_DOWN | ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F3, ui::EF_ALT_DOWN}, |
| {ui::VKEY_BROWSER_REFRESH, ui::EF_ALT_DOWN}, |
| {ui::VKEY_BROWSER_REFRESH, ui::EF_ALT_DOWN | ui::EF_FUNCTION_KEY}}, |
| // F4 -> Launch App 2 |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F4, ui::EF_NONE}, |
| {ui::VKEY_MEDIA_LAUNCH_APP2, ui::EF_NONE}, |
| {ui::VKEY_MEDIA_LAUNCH_APP2, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F4, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_MEDIA_LAUNCH_APP2, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_MEDIA_LAUNCH_APP2, ui::EF_CONTROL_DOWN | ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F4, ui::EF_ALT_DOWN}, |
| {ui::VKEY_MEDIA_LAUNCH_APP2, ui::EF_ALT_DOWN}, |
| {ui::VKEY_MEDIA_LAUNCH_APP2, ui::EF_ALT_DOWN | ui::EF_FUNCTION_KEY}}, |
| // F5 -> Launch App 1 |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F5, ui::EF_NONE}, |
| {ui::VKEY_MEDIA_LAUNCH_APP1, ui::EF_NONE}, |
| {ui::VKEY_MEDIA_LAUNCH_APP1, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F5, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_MEDIA_LAUNCH_APP1, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_MEDIA_LAUNCH_APP1, ui::EF_CONTROL_DOWN | ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F5, ui::EF_ALT_DOWN}, |
| {ui::VKEY_MEDIA_LAUNCH_APP1, ui::EF_ALT_DOWN}, |
| {ui::VKEY_MEDIA_LAUNCH_APP1, ui::EF_ALT_DOWN | ui::EF_FUNCTION_KEY}}, |
| // F6 -> Brightness down |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F6, ui::EF_NONE}, |
| {ui::VKEY_BRIGHTNESS_DOWN, ui::EF_NONE}, |
| {ui::VKEY_BRIGHTNESS_DOWN, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F6, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_BRIGHTNESS_DOWN, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_BRIGHTNESS_DOWN, ui::EF_CONTROL_DOWN | ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F6, ui::EF_ALT_DOWN}, |
| {ui::VKEY_BRIGHTNESS_DOWN, ui::EF_ALT_DOWN}, |
| {ui::VKEY_BRIGHTNESS_DOWN, ui::EF_ALT_DOWN | ui::EF_FUNCTION_KEY}}, |
| // F7 -> Brightness up |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F7, ui::EF_NONE}, |
| {ui::VKEY_BRIGHTNESS_UP, ui::EF_NONE}, |
| {ui::VKEY_BRIGHTNESS_UP, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F7, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_BRIGHTNESS_UP, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_BRIGHTNESS_UP, ui::EF_CONTROL_DOWN | ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F7, ui::EF_ALT_DOWN}, |
| {ui::VKEY_BRIGHTNESS_UP, ui::EF_ALT_DOWN}, |
| {ui::VKEY_BRIGHTNESS_UP, ui::EF_ALT_DOWN | ui::EF_FUNCTION_KEY}}, |
| // F8 -> Volume Mute |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F8, ui::EF_NONE}, |
| {ui::VKEY_VOLUME_MUTE, ui::EF_NONE}, |
| {ui::VKEY_VOLUME_MUTE, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F8, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_VOLUME_MUTE, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_VOLUME_MUTE, ui::EF_CONTROL_DOWN | ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F8, ui::EF_ALT_DOWN}, |
| {ui::VKEY_VOLUME_MUTE, ui::EF_ALT_DOWN}, |
| {ui::VKEY_VOLUME_MUTE, ui::EF_ALT_DOWN | ui::EF_FUNCTION_KEY}}, |
| // F9 -> Volume Down |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F9, ui::EF_NONE}, |
| {ui::VKEY_VOLUME_DOWN, ui::EF_NONE}, |
| {ui::VKEY_VOLUME_DOWN, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F9, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_VOLUME_DOWN, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_VOLUME_DOWN, ui::EF_CONTROL_DOWN | ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F9, ui::EF_ALT_DOWN}, |
| {ui::VKEY_VOLUME_DOWN, ui::EF_ALT_DOWN}, |
| {ui::VKEY_VOLUME_DOWN, ui::EF_ALT_DOWN | ui::EF_FUNCTION_KEY}}, |
| // F10 -> Volume Up |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F10, ui::EF_NONE}, |
| {ui::VKEY_VOLUME_UP, ui::EF_NONE}, |
| {ui::VKEY_VOLUME_UP, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F10, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_VOLUME_UP, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_VOLUME_UP, ui::EF_CONTROL_DOWN | ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F10, ui::EF_ALT_DOWN}, |
| {ui::VKEY_VOLUME_UP, ui::EF_ALT_DOWN}, |
| {ui::VKEY_VOLUME_UP, ui::EF_ALT_DOWN | ui::EF_FUNCTION_KEY}}, |
| // F11 -> F11 |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F11, ui::EF_NONE}, |
| {ui::VKEY_F11, ui::EF_NONE}, |
| {ui::VKEY_F11, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F11, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_F11, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_F11, ui::EF_CONTROL_DOWN | ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F11, ui::EF_ALT_DOWN}, |
| {ui::VKEY_F11, ui::EF_ALT_DOWN}, |
| {ui::VKEY_F11, ui::EF_ALT_DOWN | ui::EF_FUNCTION_KEY}}, |
| // F12 -> F12 |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F12, ui::EF_NONE}, |
| {ui::VKEY_F12, ui::EF_NONE}, |
| {ui::VKEY_F12, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F12, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_F12, ui::EF_CONTROL_DOWN}, |
| {ui::VKEY_F12, ui::EF_CONTROL_DOWN | ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F12, ui::EF_ALT_DOWN}, |
| {ui::VKEY_F12, ui::EF_ALT_DOWN}, |
| {ui::VKEY_F12, ui::EF_ALT_DOWN | ui::EF_FUNCTION_KEY}}, |
| |
| // The number row should not be rewritten without Search key. |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_1, ui::EF_NONE}, |
| {ui::VKEY_1, ui::EF_NONE}, |
| {ui::VKEY_1, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_2, ui::EF_NONE}, |
| {ui::VKEY_2, ui::EF_NONE}, |
| {ui::VKEY_2, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_3, ui::EF_NONE}, |
| {ui::VKEY_3, ui::EF_NONE}, |
| {ui::VKEY_3, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_4, ui::EF_NONE}, |
| {ui::VKEY_4, ui::EF_NONE}, |
| {ui::VKEY_4, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_5, ui::EF_NONE}, |
| {ui::VKEY_5, ui::EF_NONE}, |
| {ui::VKEY_5, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_6, ui::EF_NONE}, |
| {ui::VKEY_6, ui::EF_NONE}, |
| {ui::VKEY_6, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_7, ui::EF_NONE}, |
| {ui::VKEY_7, ui::EF_NONE}, |
| {ui::VKEY_7, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_8, ui::EF_NONE}, |
| {ui::VKEY_8, ui::EF_NONE}, |
| {ui::VKEY_8, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_9, ui::EF_NONE}, |
| {ui::VKEY_9, ui::EF_NONE}, |
| {ui::VKEY_9, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_0, ui::EF_NONE}, |
| {ui::VKEY_0, ui::EF_NONE}, |
| {ui::VKEY_0, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_OEM_MINUS, ui::EF_NONE}, |
| {ui::VKEY_OEM_MINUS, ui::EF_NONE}, |
| {ui::VKEY_OEM_MINUS, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_OEM_PLUS, ui::EF_NONE}, |
| {ui::VKEY_OEM_PLUS, ui::EF_NONE}, |
| {ui::VKEY_OEM_PLUS, ui::EF_NONE}}, |
| |
| // The number row should be rewritten as the F<number> row with Search |
| // key. |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_1, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F1, ui::EF_NONE}, |
| {ui::VKEY_F1, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_2, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F2, ui::EF_NONE}, |
| {ui::VKEY_F2, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_3, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F3, ui::EF_NONE}, |
| {ui::VKEY_F3, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_4, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F4, ui::EF_NONE}, |
| {ui::VKEY_F4, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_5, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F5, ui::EF_NONE}, |
| {ui::VKEY_F5, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_6, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F6, ui::EF_NONE}, |
| {ui::VKEY_F6, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_7, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F7, ui::EF_NONE}, |
| {ui::VKEY_F7, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_8, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F8, ui::EF_NONE}, |
| {ui::VKEY_F8, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_9, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F9, ui::EF_NONE}, |
| {ui::VKEY_F9, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_0, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F10, ui::EF_NONE}, |
| {ui::VKEY_F10, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_OEM_MINUS, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F11, ui::EF_NONE}, |
| {ui::VKEY_F11, ui::EF_NONE}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_OEM_PLUS, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F12, ui::EF_NONE}, |
| {ui::VKEY_F12, ui::EF_NONE}}, |
| |
| // The function keys should not be rewritten with Search key pressed. |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F1, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F1, ui::EF_NONE}, |
| {ui::VKEY_F1, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F2, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F2, ui::EF_NONE}, |
| {ui::VKEY_F2, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F3, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F3, ui::EF_NONE}, |
| {ui::VKEY_F3, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F4, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F4, ui::EF_NONE}, |
| {ui::VKEY_F4, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F5, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F5, ui::EF_NONE}, |
| {ui::VKEY_F5, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F6, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F6, ui::EF_NONE}, |
| {ui::VKEY_F6, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F7, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F7, ui::EF_NONE}, |
| {ui::VKEY_F7, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F8, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F8, ui::EF_NONE}, |
| {ui::VKEY_F8, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F9, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F9, ui::EF_NONE}, |
| {ui::VKEY_F9, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F10, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F10, ui::EF_NONE}, |
| {ui::VKEY_F10, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F11, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F11, ui::EF_NONE}, |
| {ui::VKEY_F11, ui::EF_FUNCTION_KEY}}, |
| {ui::ET_KEY_PRESSED, |
| {ui::VKEY_F12, ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_F12, ui::EF_NONE}, |
| {ui::VKEY_F12, ui::EF_FUNCTION_KEY}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(tests); ++i) { |
| CheckFunctionKeyTestCase(1000 + i, &rewriter, tests[i]); |
| } |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteExtendedKeysWithSearchRemapped) { |
| const CommandLine original_cl(*CommandLine::ForCurrentProcess()); |
| |
| // Remap Search to Control. |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| IntegerPrefMember search; |
| search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); |
| search.SetValue(chromeos::input_method::kControlKey); |
| |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| |
| CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
| chromeos::switches::kHasChromeOSKeyboard, ""); |
| |
| KeyTestCase tests[] = { |
| // Alt+Search+Down -> End |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_DOWN, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_END, ui::EF_NONE}}, |
| |
| // Shift+Alt+Search+Down -> Shift+End |
| {KeyTestCase::TEST_ALL, ui::ET_KEY_PRESSED, |
| {ui::VKEY_DOWN, |
| ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN}, |
| {ui::VKEY_END, ui::EF_SHIFT_DOWN}}, |
| }; |
| |
| for (size_t i = 0; i < arraysize(tests); ++i) { |
| CheckKeyTestCase(1000 + i, &rewriter, tests[i]); |
| } |
| |
| *CommandLine::ForCurrentProcess() = original_cl; |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteKeyEventSentByXSendEvent) { |
| // Remap Control to Alt. |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| IntegerPrefMember control; |
| control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); |
| control.SetValue(chromeos::input_method::kAltKey); |
| |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| |
| // Send left control press. |
| std::string rewritten_event; |
| { |
| ui::ScopedXI2Event xev; |
| xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0); |
| XEvent* xevent = xev; |
| xevent->xkey.keycode = XKeysymToKeycode(gfx::GetXDisplay(), XK_Control_L); |
| xevent->xkey.send_event = True; // XSendEvent() always does this. |
| ui::KeyEvent keyevent(xev, false /* is_char */); |
| scoped_ptr<ui::Event> new_event; |
| // Control should NOT be remapped to Alt if send_event |
| // flag in the event is True. |
| EXPECT_EQ(ui::EVENT_REWRITE_CONTINUE, |
| rewriter.RewriteEvent(keyevent, &new_event)); |
| EXPECT_FALSE(new_event); |
| } |
| } |
| |
| TEST_F(EventRewriterTest, TestRewriteNonNativeEvent) { |
| // Remap Control to Alt. |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| IntegerPrefMember control; |
| control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); |
| control.SetValue(chromeos::input_method::kAltKey); |
| |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| |
| const int kTouchId = 2; |
| gfx::Point location(0, 0); |
| ui::TouchEvent press( |
| ui::ET_TOUCH_PRESSED, location, kTouchId, base::TimeDelta()); |
| press.set_flags(ui::EF_CONTROL_DOWN); |
| |
| scoped_ptr<ui::Event> new_event; |
| rewriter.RewriteEvent(press, &new_event); |
| EXPECT_TRUE(new_event); |
| // Control should be remapped to Alt. |
| EXPECT_EQ(ui::EF_ALT_DOWN, |
| new_event->flags() & (ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN)); |
| } |
| |
| // Tests of event rewriting that depend on the Ash window manager. |
| class EventRewriterAshTest : public ash::test::AshTestBase { |
| public: |
| EventRewriterAshTest() |
| : mock_user_manager_(new chromeos::MockUserManager), |
| user_manager_enabler_(mock_user_manager_) {} |
| virtual ~EventRewriterAshTest() {} |
| |
| bool RewriteFunctionKeys(const ui::Event& event, |
| scoped_ptr<ui::Event>* rewritten_event) { |
| return rewriter_->RewriteEvent(event, rewritten_event); |
| } |
| |
| protected: |
| virtual void SetUp() OVERRIDE { |
| AshTestBase::SetUp(); |
| rewriter_.reset(new EventRewriter()); |
| chromeos::Preferences::RegisterProfilePrefs(prefs_.registry()); |
| rewriter_->set_pref_service_for_testing(&prefs_); |
| } |
| |
| virtual void TearDown() OVERRIDE { |
| rewriter_.reset(); |
| AshTestBase::TearDown(); |
| } |
| |
| TestingPrefServiceSyncable prefs_; |
| |
| private: |
| scoped_ptr<EventRewriter> rewriter_; |
| |
| chromeos::MockUserManager* mock_user_manager_; // Not owned. |
| chromeos::ScopedUserManagerEnabler user_manager_enabler_; |
| |
| DISALLOW_COPY_AND_ASSIGN(EventRewriterAshTest); |
| }; |
| |
| TEST_F(EventRewriterAshTest, TopRowKeysAreFunctionKeys) { |
| scoped_ptr<aura::Window> window(CreateTestWindowInShellWithId(1)); |
| ash::wm::WindowState* window_state = ash::wm::GetWindowState(window.get()); |
| window_state->Activate(); |
| |
| // Create a simulated keypress of F1 targetted at the window. |
| ui::KeyEvent press_f1(ui::ET_KEY_PRESSED, ui::VKEY_F1, 0, false); |
| |
| // Simulate an apps v2 window that has requested top row keys as function |
| // keys. The event should not be rewritten. |
| window_state->set_top_row_keys_are_function_keys(true); |
| scoped_ptr<ui::Event> rewritten_event; |
| ASSERT_FALSE(RewriteFunctionKeys(press_f1, &rewritten_event)); |
| ASSERT_FALSE(rewritten_event); |
| EXPECT_EQ( |
| GetExpectedResultAsString(ui::VKEY_F1, ui::EF_NONE, ui::ET_KEY_PRESSED), |
| GetKeyEventAsString(press_f1)); |
| |
| // The event should also not be rewritten if the send-function-keys pref is |
| // additionally set, for both apps v2 and regular windows. |
| BooleanPrefMember send_function_keys_pref; |
| send_function_keys_pref.Init(prefs::kLanguageSendFunctionKeys, &prefs_); |
| send_function_keys_pref.SetValue(true); |
| window_state->set_top_row_keys_are_function_keys(false); |
| ASSERT_FALSE(RewriteFunctionKeys(press_f1, &rewritten_event)); |
| ASSERT_FALSE(rewritten_event); |
| EXPECT_EQ( |
| GetExpectedResultAsString(ui::VKEY_F1, ui::EF_NONE, ui::ET_KEY_PRESSED), |
| GetKeyEventAsString(press_f1)); |
| |
| // If the pref isn't set when an event is sent to a regular window, F1 is |
| // rewritten to the back key. |
| send_function_keys_pref.SetValue(false); |
| ASSERT_TRUE(RewriteFunctionKeys(press_f1, &rewritten_event)); |
| ASSERT_TRUE(rewritten_event); |
| EXPECT_EQ(GetExpectedResultAsString( |
| ui::VKEY_BROWSER_BACK, ui::EF_NONE, ui::ET_KEY_PRESSED), |
| GetKeyEventAsString( |
| *static_cast<const ui::KeyEvent*>(rewritten_event.get()))); |
| } |
| |
| TEST_F(EventRewriterTest, TestRewrittenModifierClick) { |
| std::vector<unsigned int> device_list; |
| device_list.push_back(10); |
| ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list); |
| |
| // Remap Control to Alt. |
| TestingPrefServiceSyncable prefs; |
| chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); |
| IntegerPrefMember control; |
| control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); |
| control.SetValue(chromeos::input_method::kAltKey); |
| |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| |
| // Check that Control + Left Button is converted (via Alt + Left Button) |
| // to Right Button. |
| ui::ScopedXI2Event xev; |
| xev.InitGenericButtonEvent(10, |
| ui::ET_MOUSE_PRESSED, |
| gfx::Point(), |
| ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN); |
| ui::MouseEvent press(xev); |
| // Sanity check. |
| EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type()); |
| EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN, press.flags()); |
| int flags = RewriteMouseEvent(&rewriter, press); |
| EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & flags); |
| EXPECT_FALSE(ui::EF_CONTROL_DOWN & flags); |
| EXPECT_FALSE(ui::EF_ALT_DOWN & flags); |
| } |
| |
| |
| TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) { |
| std::vector<unsigned int> device_list; |
| device_list.push_back(10); |
| device_list.push_back(11); |
| ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list); |
| TestingPrefServiceSyncable prefs; |
| EventRewriter rewriter; |
| rewriter.set_pref_service_for_testing(&prefs); |
| const int kLeftAndAltFlag = ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN; |
| { |
| ui::ScopedXI2Event xev; |
| xev.InitGenericButtonEvent( |
| 10, ui::ET_MOUSE_PRESSED, gfx::Point(), kLeftAndAltFlag); |
| ui::MouseEvent press(xev); |
| // Sanity check. |
| EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type()); |
| EXPECT_EQ(kLeftAndAltFlag, press.flags()); |
| int flags = RewriteMouseEvent(&rewriter, press); |
| EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & flags); |
| } |
| { |
| ui::ScopedXI2Event xev; |
| xev.InitGenericButtonEvent( |
| 10, ui::ET_MOUSE_RELEASED, gfx::Point(), kLeftAndAltFlag); |
| ui::MouseEvent release(xev); |
| int flags = RewriteMouseEvent(&rewriter, release); |
| EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & flags); |
| } |
| |
| // No ALT in frst click. |
| { |
| ui::ScopedXI2Event xev; |
| xev.InitGenericButtonEvent( |
| 10, ui::ET_MOUSE_PRESSED, gfx::Point(), ui::EF_LEFT_MOUSE_BUTTON); |
| ui::MouseEvent press(xev); |
| int flags = RewriteMouseEvent(&rewriter, press); |
| EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & flags); |
| } |
| { |
| ui::ScopedXI2Event xev; |
| xev.InitGenericButtonEvent( |
| 10, ui::ET_MOUSE_RELEASED, gfx::Point(), kLeftAndAltFlag); |
| ui::MouseEvent release(xev); |
| int flags = RewriteMouseEvent(&rewriter, release); |
| EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & flags); |
| } |
| |
| // ALT on different device. |
| { |
| ui::ScopedXI2Event xev; |
| xev.InitGenericButtonEvent( |
| 11, ui::ET_MOUSE_PRESSED, gfx::Point(), kLeftAndAltFlag); |
| ui::MouseEvent press(xev); |
| int flags = RewriteMouseEvent(&rewriter, press); |
| EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & flags); |
| } |
| { |
| ui::ScopedXI2Event xev; |
| xev.InitGenericButtonEvent( |
| 10, ui::ET_MOUSE_RELEASED, gfx::Point(), kLeftAndAltFlag); |
| ui::MouseEvent release(xev); |
| int flags = RewriteMouseEvent(&rewriter, release); |
| EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & flags); |
| } |
| { |
| ui::ScopedXI2Event xev; |
| xev.InitGenericButtonEvent( |
| 11, ui::ET_MOUSE_RELEASED, gfx::Point(), kLeftAndAltFlag); |
| ui::MouseEvent release(xev); |
| int flags = RewriteMouseEvent(&rewriter, release); |
| EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & flags); |
| } |
| } |
| |
| } // namespace chromeos |
