OLD | NEW |
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" | |
6 | |
7 #include <vector> | 5 #include <vector> |
8 | 6 |
9 #include "ash/common/wm/window_state.h" | 7 #include "ash/common/wm/window_state.h" |
10 #include "ash/shell.h" | 8 #include "ash/shell.h" |
11 #include "ash/sticky_keys/sticky_keys_controller.h" | 9 #include "ash/sticky_keys/sticky_keys_controller.h" |
12 #include "ash/sticky_keys/sticky_keys_overlay.h" | 10 #include "ash/sticky_keys/sticky_keys_overlay.h" |
13 #include "ash/test/ash_test_base.h" | 11 #include "ash/test/ash_test_base.h" |
14 #include "ash/wm/window_state_aura.h" | 12 #include "ash/wm/window_state_aura.h" |
15 #include "base/command_line.h" | 13 #include "base/command_line.h" |
16 #include "base/macros.h" | 14 #include "base/macros.h" |
17 #include "base/memory/ptr_util.h" | 15 #include "base/memory/ptr_util.h" |
18 #include "base/strings/stringprintf.h" | 16 #include "base/strings/stringprintf.h" |
| 17 #include "chrome/browser/chromeos/events/event_rewriter_delegate_impl.h" |
19 #include "chrome/browser/chromeos/input_method/input_method_configuration.h" | 18 #include "chrome/browser/chromeos/input_method/input_method_configuration.h" |
20 #include "chrome/browser/chromeos/input_method/mock_input_method_manager_impl.h" | 19 #include "chrome/browser/chromeos/input_method/mock_input_method_manager_impl.h" |
21 #include "chrome/browser/chromeos/login/users/fake_chrome_user_manager.h" | 20 #include "chrome/browser/chromeos/login/users/fake_chrome_user_manager.h" |
22 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h" | 21 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h" |
23 #include "chrome/browser/chromeos/preferences.h" | 22 #include "chrome/browser/chromeos/preferences.h" |
24 #include "chrome/common/pref_names.h" | 23 #include "chrome/common/pref_names.h" |
25 #include "chromeos/chromeos_switches.h" | 24 #include "chromeos/chromeos_switches.h" |
26 #include "components/prefs/pref_member.h" | 25 #include "components/prefs/pref_member.h" |
27 #include "components/sync_preferences/testing_pref_service_syncable.h" | 26 #include "components/sync_preferences/testing_pref_service_syncable.h" |
28 #include "testing/gtest/include/gtest/gtest.h" | 27 #include "testing/gtest/include/gtest/gtest.h" |
29 #include "ui/aura/window.h" | 28 #include "ui/aura/window.h" |
30 #include "ui/aura/window_tree_host.h" | 29 #include "ui/aura/window_tree_host.h" |
31 #include "ui/base/ime/chromeos/fake_ime_keyboard.h" | 30 #include "ui/base/ime/chromeos/fake_ime_keyboard.h" |
| 31 #include "ui/chromeos/events/event_rewriter_chromeos.h" |
| 32 #include "ui/chromeos/events/pref_names.h" |
32 #include "ui/events/event.h" | 33 #include "ui/events/event.h" |
33 #include "ui/events/event_rewriter.h" | 34 #include "ui/events/event_rewriter.h" |
34 #include "ui/events/event_utils.h" | 35 #include "ui/events/event_utils.h" |
35 #include "ui/events/keycodes/dom/dom_code.h" | 36 #include "ui/events/keycodes/dom/dom_code.h" |
36 #include "ui/events/keycodes/dom/dom_key.h" | 37 #include "ui/events/keycodes/dom/dom_key.h" |
37 #include "ui/events/keycodes/dom/keycode_converter.h" | 38 #include "ui/events/keycodes/dom/keycode_converter.h" |
38 #include "ui/events/test/events_test_utils.h" | 39 #include "ui/events/test/events_test_utils.h" |
39 #include "ui/events/test/test_event_processor.h" | 40 #include "ui/events/test/test_event_processor.h" |
40 | 41 |
41 #if defined(USE_X11) | 42 #if defined(USE_X11) |
(...skipping 23 matching lines...) Expand all Loading... |
65 static_cast<unsigned int>(code), ui_flags & ~ui::EF_IS_REPEAT, ui_keycode, | 66 static_cast<unsigned int>(code), ui_flags & ~ui::EF_IS_REPEAT, ui_keycode, |
66 static_cast<unsigned int>(key)); | 67 static_cast<unsigned int>(key)); |
67 } | 68 } |
68 | 69 |
69 std::string GetKeyEventAsString(const ui::KeyEvent& keyevent) { | 70 std::string GetKeyEventAsString(const ui::KeyEvent& keyevent) { |
70 return GetExpectedResultAsString(keyevent.type(), keyevent.key_code(), | 71 return GetExpectedResultAsString(keyevent.type(), keyevent.key_code(), |
71 keyevent.code(), keyevent.flags(), | 72 keyevent.code(), keyevent.flags(), |
72 keyevent.GetDomKey()); | 73 keyevent.GetDomKey()); |
73 } | 74 } |
74 | 75 |
75 std::string GetRewrittenEventAsString(chromeos::EventRewriter* rewriter, | 76 std::string GetRewrittenEventAsString( |
76 ui::EventType ui_type, | 77 const std::unique_ptr<ui::EventRewriterChromeOS>& rewriter, |
77 ui::KeyboardCode ui_keycode, | 78 ui::EventType ui_type, |
78 ui::DomCode code, | 79 ui::KeyboardCode ui_keycode, |
79 int ui_flags, // ui::EventFlags | 80 ui::DomCode code, |
80 ui::DomKey key) { | 81 int ui_flags, // ui::EventFlags |
| 82 ui::DomKey key) { |
81 const ui::KeyEvent event(ui_type, ui_keycode, code, ui_flags, key, | 83 const ui::KeyEvent event(ui_type, ui_keycode, code, ui_flags, key, |
82 ui::EventTimeForNow()); | 84 ui::EventTimeForNow()); |
83 std::unique_ptr<ui::Event> new_event; | 85 std::unique_ptr<ui::Event> new_event; |
84 rewriter->RewriteEvent(event, &new_event); | 86 rewriter->RewriteEvent(event, &new_event); |
85 if (new_event) | 87 if (new_event) |
86 return GetKeyEventAsString(*new_event->AsKeyEvent()); | 88 return GetKeyEventAsString(*new_event->AsKeyEvent()); |
87 return GetKeyEventAsString(event); | 89 return GetKeyEventAsString(event); |
88 } | 90 } |
89 | 91 |
90 // Table entry for simple single key event rewriting tests. | 92 // Table entry for simple single key event rewriting tests. |
91 struct KeyTestCase { | 93 struct KeyTestCase { |
92 ui::EventType type; | 94 ui::EventType type; |
93 struct Event { | 95 struct Event { |
94 ui::KeyboardCode key_code; | 96 ui::KeyboardCode key_code; |
95 ui::DomCode code; | 97 ui::DomCode code; |
96 int flags; // ui::EventFlags | 98 int flags; // ui::EventFlags |
97 ui::DomKey::Base key; | 99 ui::DomKey::Base key; |
98 } input, expected; | 100 } input, expected; |
99 }; | 101 }; |
100 | 102 |
101 std::string GetTestCaseAsString(ui::EventType ui_type, | 103 std::string GetTestCaseAsString(ui::EventType ui_type, |
102 const KeyTestCase::Event& test) { | 104 const KeyTestCase::Event& test) { |
103 return GetExpectedResultAsString(ui_type, test.key_code, test.code, | 105 return GetExpectedResultAsString(ui_type, test.key_code, test.code, |
104 test.flags, test.key); | 106 test.flags, test.key); |
105 } | 107 } |
106 | 108 |
107 // Tests a single stateless key rewrite operation. | 109 // Tests a single stateless key rewrite operation. |
108 void CheckKeyTestCase(chromeos::EventRewriter* rewriter, | 110 void CheckKeyTestCase( |
109 const KeyTestCase& test) { | 111 const std::unique_ptr<ui::EventRewriterChromeOS>& rewriter, |
| 112 const KeyTestCase& test) { |
110 SCOPED_TRACE("\nSource: " + GetTestCaseAsString(test.type, test.input)); | 113 SCOPED_TRACE("\nSource: " + GetTestCaseAsString(test.type, test.input)); |
111 std::string expected = GetTestCaseAsString(test.type, test.expected); | 114 std::string expected = GetTestCaseAsString(test.type, test.expected); |
112 EXPECT_EQ(expected, GetRewrittenEventAsString( | 115 EXPECT_EQ(expected, GetRewrittenEventAsString( |
113 rewriter, test.type, test.input.key_code, | 116 rewriter, test.type, test.input.key_code, |
114 test.input.code, test.input.flags, test.input.key)); | 117 test.input.code, test.input.flags, test.input.key)); |
115 } | 118 } |
116 | 119 |
117 } // namespace | 120 } // namespace |
118 | 121 |
119 namespace chromeos { | 122 namespace chromeos { |
120 | 123 |
121 class EventRewriterTest : public ash::test::AshTestBase { | 124 class EventRewriterTest : public ash::test::AshTestBase { |
122 public: | 125 public: |
123 EventRewriterTest() | 126 EventRewriterTest() |
124 : fake_user_manager_(new chromeos::FakeChromeUserManager), | 127 : fake_user_manager_(new chromeos::FakeChromeUserManager), |
125 user_manager_enabler_(fake_user_manager_) {} | 128 user_manager_enabler_(fake_user_manager_) {} |
126 ~EventRewriterTest() override {} | 129 ~EventRewriterTest() override {} |
127 | 130 |
128 void SetUp() override { | 131 void SetUp() override { |
129 input_method_manager_mock_ = new input_method::MockInputMethodManagerImpl; | 132 input_method_manager_mock_ = new input_method::MockInputMethodManagerImpl; |
130 chromeos::input_method::InitializeForTesting( | 133 chromeos::input_method::InitializeForTesting( |
131 input_method_manager_mock_); // pass ownership | 134 input_method_manager_mock_); // pass ownership |
132 | 135 delegate_ = base::MakeUnique<EventRewriterDelegateImpl>(); |
| 136 delegate_->set_pref_service_for_testing(prefs()); |
| 137 rewriter_ = |
| 138 base::MakeUnique<ui::EventRewriterChromeOS>(delegate_.get(), nullptr); |
133 AshTestBase::SetUp(); | 139 AshTestBase::SetUp(); |
134 } | 140 } |
135 | 141 |
136 void TearDown() override { | 142 void TearDown() override { |
137 AshTestBase::TearDown(); | 143 AshTestBase::TearDown(); |
138 // Shutdown() deletes the IME mock object. | 144 // Shutdown() deletes the IME mock object. |
139 chromeos::input_method::Shutdown(); | 145 chromeos::input_method::Shutdown(); |
140 } | 146 } |
141 | 147 |
142 protected: | 148 protected: |
143 void TestRewriteNumPadKeys(); | 149 void TestRewriteNumPadKeys(); |
144 void TestRewriteNumPadKeysOnAppleKeyboard(); | 150 void TestRewriteNumPadKeysOnAppleKeyboard(); |
145 | 151 |
146 const ui::MouseEvent* RewriteMouseButtonEvent( | 152 const ui::MouseEvent* RewriteMouseButtonEvent( |
147 chromeos::EventRewriter* rewriter, | |
148 const ui::MouseEvent& event, | 153 const ui::MouseEvent& event, |
149 std::unique_ptr<ui::Event>* new_event) { | 154 std::unique_ptr<ui::Event>* new_event) { |
150 rewriter->RewriteMouseButtonEventForTesting(event, new_event); | 155 rewriter_->RewriteMouseButtonEventForTesting(event, new_event); |
151 return *new_event ? new_event->get()->AsMouseEvent() : &event; | 156 return *new_event ? new_event->get()->AsMouseEvent() : &event; |
152 } | 157 } |
153 | 158 |
| 159 sync_preferences::TestingPrefServiceSyncable* prefs() { return &prefs_; } |
| 160 |
154 FakeChromeUserManager* fake_user_manager_; // Not owned. | 161 FakeChromeUserManager* fake_user_manager_; // Not owned. |
155 ScopedUserManagerEnabler user_manager_enabler_; | 162 ScopedUserManagerEnabler user_manager_enabler_; |
156 input_method::MockInputMethodManagerImpl* input_method_manager_mock_; | 163 input_method::MockInputMethodManagerImpl* input_method_manager_mock_; |
| 164 |
| 165 sync_preferences::TestingPrefServiceSyncable prefs_; |
| 166 std::unique_ptr<EventRewriterDelegateImpl> delegate_; |
| 167 std::unique_ptr<ui::EventRewriterChromeOS> rewriter_; |
157 }; | 168 }; |
158 | 169 |
159 TEST_F(EventRewriterTest, TestRewriteCommandToControl) { | 170 TEST_F(EventRewriterTest, TestRewriteCommandToControl) { |
160 // First, test with a PC keyboard. | 171 // First, test with a PC keyboard. |
161 sync_preferences::TestingPrefServiceSyncable prefs; | 172 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
162 EventRewriter rewriter(NULL); | 173 rewriter_->set_last_keyboard_device_id_for_testing(kKeyboardDeviceId); |
163 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
164 rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId); | |
165 rewriter.set_pref_service_for_testing(&prefs); | |
166 | 174 |
167 KeyTestCase pc_keyboard_tests[] = { | 175 KeyTestCase pc_keyboard_tests[] = { |
168 // VKEY_A, Alt modifier. | 176 // VKEY_A, Alt modifier. |
169 {ui::ET_KEY_PRESSED, | 177 {ui::ET_KEY_PRESSED, |
170 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN, | 178 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN, |
171 ui::DomKey::UNIDENTIFIED}, | 179 ui::DomKey::UNIDENTIFIED}, |
172 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN, | 180 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN, |
173 ui::DomKey::UNIDENTIFIED}}, | 181 ui::DomKey::UNIDENTIFIED}}, |
174 | 182 |
175 // VKEY_A, Win modifier. | 183 // VKEY_A, Win modifier. |
(...skipping 18 matching lines...) Expand all Loading... |
194 ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::DomKey::META}}, | 202 ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::DomKey::META}}, |
195 | 203 |
196 // VKEY_RWIN (right Windows key), Alt modifier. | 204 // VKEY_RWIN (right Windows key), Alt modifier. |
197 {ui::ET_KEY_PRESSED, | 205 {ui::ET_KEY_PRESSED, |
198 {ui::VKEY_RWIN, ui::DomCode::META_RIGHT, | 206 {ui::VKEY_RWIN, ui::DomCode::META_RIGHT, |
199 ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::DomKey::META}, | 207 ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::DomKey::META}, |
200 {ui::VKEY_RWIN, ui::DomCode::META_RIGHT, | 208 {ui::VKEY_RWIN, ui::DomCode::META_RIGHT, |
201 ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::DomKey::META}}, | 209 ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::DomKey::META}}, |
202 }; | 210 }; |
203 | 211 |
204 for (const auto& test : pc_keyboard_tests) { | 212 for (const auto& test : pc_keyboard_tests) |
205 CheckKeyTestCase(&rewriter, test); | 213 CheckKeyTestCase(rewriter_, test); |
206 } | |
207 | 214 |
208 // An Apple keyboard reusing the ID, zero. | 215 // An Apple keyboard reusing the ID, zero. |
209 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "Apple Keyboard"); | 216 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "Apple Keyboard"); |
210 rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId); | 217 rewriter_->set_last_keyboard_device_id_for_testing(kKeyboardDeviceId); |
211 | 218 |
212 KeyTestCase apple_keyboard_tests[] = { | 219 KeyTestCase apple_keyboard_tests[] = { |
213 // VKEY_A, Alt modifier. | 220 // VKEY_A, Alt modifier. |
214 {ui::ET_KEY_PRESSED, | 221 {ui::ET_KEY_PRESSED, |
215 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN, | 222 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN, |
216 ui::DomKey::UNIDENTIFIED}, | 223 ui::DomKey::UNIDENTIFIED}, |
217 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN, | 224 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN, |
218 ui::DomKey::UNIDENTIFIED}}, | 225 ui::DomKey::UNIDENTIFIED}}, |
219 | 226 |
220 // VKEY_A, Win modifier. | 227 // VKEY_A, Win modifier. |
(...skipping 18 matching lines...) Expand all Loading... |
239 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, ui::DomKey::CONTROL}}, | 246 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, ui::DomKey::CONTROL}}, |
240 | 247 |
241 // VKEY_RWIN (right Windows key), Alt modifier. | 248 // VKEY_RWIN (right Windows key), Alt modifier. |
242 {ui::ET_KEY_PRESSED, | 249 {ui::ET_KEY_PRESSED, |
243 {ui::VKEY_RWIN, ui::DomCode::META_RIGHT, | 250 {ui::VKEY_RWIN, ui::DomCode::META_RIGHT, |
244 ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN, ui::DomKey::META}, | 251 ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN, ui::DomKey::META}, |
245 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_RIGHT, | 252 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_RIGHT, |
246 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, ui::DomKey::CONTROL}}, | 253 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, ui::DomKey::CONTROL}}, |
247 }; | 254 }; |
248 | 255 |
249 for (const auto& test : apple_keyboard_tests) { | 256 for (const auto& test : apple_keyboard_tests) |
250 CheckKeyTestCase(&rewriter, test); | 257 CheckKeyTestCase(rewriter_, test); |
251 } | |
252 } | 258 } |
253 | 259 |
254 // For crbug.com/133896. | 260 // For crbug.com/133896. |
255 TEST_F(EventRewriterTest, TestRewriteCommandToControlWithControlRemapped) { | 261 TEST_F(EventRewriterTest, TestRewriteCommandToControlWithControlRemapped) { |
256 // Remap Control to Alt. | 262 // Remap Control to Alt. |
257 sync_preferences::TestingPrefServiceSyncable prefs; | 263 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
258 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | |
259 IntegerPrefMember control; | 264 IntegerPrefMember control; |
260 control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); | 265 control.Init(prefs::kLanguageRemapControlKeyTo, prefs()); |
261 control.SetValue(chromeos::input_method::kAltKey); | 266 control.SetValue(chromeos::input_method::kAltKey); |
262 | 267 |
263 EventRewriter rewriter(NULL); | 268 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
264 rewriter.set_pref_service_for_testing(&prefs); | 269 rewriter_->set_last_keyboard_device_id_for_testing(kKeyboardDeviceId); |
265 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
266 rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId); | |
267 | 270 |
268 KeyTestCase pc_keyboard_tests[] = { | 271 KeyTestCase pc_keyboard_tests[] = { |
269 // Control should be remapped to Alt. | 272 // Control should be remapped to Alt. |
270 {ui::ET_KEY_PRESSED, | 273 {ui::ET_KEY_PRESSED, |
271 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN, | 274 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN, |
272 ui::DomKey::CONTROL}, | 275 ui::DomKey::CONTROL}, |
273 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, | 276 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, |
274 ui::DomKey::ALT}}, | 277 ui::DomKey::ALT}}, |
275 }; | 278 }; |
276 | 279 |
277 for (const auto& test : pc_keyboard_tests) { | 280 for (const auto& test : pc_keyboard_tests) |
278 CheckKeyTestCase(&rewriter, test); | 281 CheckKeyTestCase(rewriter_, test); |
279 } | |
280 | 282 |
281 // An Apple keyboard reusing the ID, zero. | 283 // An Apple keyboard reusing the ID, zero. |
282 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "Apple Keyboard"); | 284 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "Apple Keyboard"); |
283 rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId); | 285 rewriter_->set_last_keyboard_device_id_for_testing(kKeyboardDeviceId); |
284 | 286 |
285 KeyTestCase apple_keyboard_tests[] = { | 287 KeyTestCase apple_keyboard_tests[] = { |
286 // VKEY_LWIN (left Command key) with Alt modifier. The remapped Command | 288 // VKEY_LWIN (left Command key) with Alt modifier. The remapped Command |
287 // key should never be re-remapped to Alt. | 289 // key should never be re-remapped to Alt. |
288 {ui::ET_KEY_PRESSED, | 290 {ui::ET_KEY_PRESSED, |
289 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, | 291 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, |
290 ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN, ui::DomKey::META}, | 292 ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN, ui::DomKey::META}, |
291 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, | 293 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, |
292 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, ui::DomKey::CONTROL}}, | 294 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, ui::DomKey::CONTROL}}, |
293 | 295 |
294 // VKEY_RWIN (right Command key) with Alt modifier. The remapped Command | 296 // VKEY_RWIN (right Command key) with Alt modifier. The remapped Command |
295 // key should never be re-remapped to Alt. | 297 // key should never be re-remapped to Alt. |
296 {ui::ET_KEY_PRESSED, | 298 {ui::ET_KEY_PRESSED, |
297 {ui::VKEY_RWIN, ui::DomCode::META_RIGHT, | 299 {ui::VKEY_RWIN, ui::DomCode::META_RIGHT, |
298 ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN, ui::DomKey::META}, | 300 ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN, ui::DomKey::META}, |
299 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_RIGHT, | 301 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_RIGHT, |
300 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, ui::DomKey::CONTROL}}, | 302 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, ui::DomKey::CONTROL}}, |
301 }; | 303 }; |
302 | 304 |
303 for (const auto& test : apple_keyboard_tests) { | 305 for (const auto& test : apple_keyboard_tests) |
304 CheckKeyTestCase(&rewriter, test); | 306 CheckKeyTestCase(rewriter_, test); |
305 } | |
306 } | 307 } |
307 | 308 |
308 void EventRewriterTest::TestRewriteNumPadKeys() { | 309 void EventRewriterTest::TestRewriteNumPadKeys() { |
309 sync_preferences::TestingPrefServiceSyncable prefs; | 310 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
310 EventRewriter rewriter(NULL); | 311 rewriter_->set_last_keyboard_device_id_for_testing(kKeyboardDeviceId); |
311 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
312 rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId); | |
313 rewriter.set_pref_service_for_testing(&prefs); | |
314 | 312 |
315 KeyTestCase tests[] = { | 313 KeyTestCase tests[] = { |
316 // XK_KP_Insert (= NumPad 0 without Num Lock), no modifier. | 314 // XK_KP_Insert (= NumPad 0 without Num Lock), no modifier. |
317 {ui::ET_KEY_PRESSED, | 315 {ui::ET_KEY_PRESSED, |
318 {ui::VKEY_INSERT, ui::DomCode::NUMPAD0, ui::EF_NONE, ui::DomKey::INSERT}, | 316 {ui::VKEY_INSERT, ui::DomCode::NUMPAD0, ui::EF_NONE, ui::DomKey::INSERT}, |
319 {ui::VKEY_NUMPAD0, ui::DomCode::NUMPAD0, ui::EF_NONE, | 317 {ui::VKEY_NUMPAD0, ui::DomCode::NUMPAD0, ui::EF_NONE, |
320 ui::DomKey::Constant<'0'>::Character}}, | 318 ui::DomKey::Constant<'0'>::Character}}, |
321 | 319 |
322 // XK_KP_Insert (= NumPad 0 without Num Lock), Alt modifier. | 320 // XK_KP_Insert (= NumPad 0 without Num Lock), Alt modifier. |
323 {ui::ET_KEY_PRESSED, | 321 {ui::ET_KEY_PRESSED, |
(...skipping 146 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
470 | 468 |
471 // XK_KP_9 (= NumPad 9 with Num Lock), Num Lock | 469 // XK_KP_9 (= NumPad 9 with Num Lock), Num Lock |
472 // modifier. | 470 // modifier. |
473 {ui::ET_KEY_PRESSED, | 471 {ui::ET_KEY_PRESSED, |
474 {ui::VKEY_NUMPAD9, ui::DomCode::NUMPAD9, ui::EF_NONE, | 472 {ui::VKEY_NUMPAD9, ui::DomCode::NUMPAD9, ui::EF_NONE, |
475 ui::DomKey::Constant<'9'>::Character}, | 473 ui::DomKey::Constant<'9'>::Character}, |
476 {ui::VKEY_NUMPAD9, ui::DomCode::NUMPAD9, ui::EF_NONE, | 474 {ui::VKEY_NUMPAD9, ui::DomCode::NUMPAD9, ui::EF_NONE, |
477 ui::DomKey::Constant<'9'>::Character}}, | 475 ui::DomKey::Constant<'9'>::Character}}, |
478 }; | 476 }; |
479 | 477 |
480 for (const auto& test : tests) { | 478 for (const auto& test : tests) |
481 CheckKeyTestCase(&rewriter, test); | 479 CheckKeyTestCase(rewriter_, test); |
482 } | |
483 } | 480 } |
484 | 481 |
485 TEST_F(EventRewriterTest, TestRewriteNumPadKeys) { | 482 TEST_F(EventRewriterTest, TestRewriteNumPadKeys) { |
486 TestRewriteNumPadKeys(); | 483 TestRewriteNumPadKeys(); |
487 } | 484 } |
488 | 485 |
489 TEST_F(EventRewriterTest, TestRewriteNumPadKeysWithDiamondKeyFlag) { | 486 TEST_F(EventRewriterTest, TestRewriteNumPadKeysWithDiamondKeyFlag) { |
490 // Make sure the num lock works correctly even when Diamond key exists. | 487 // Make sure the num lock works correctly even when Diamond key exists. |
491 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( | 488 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
492 chromeos::switches::kHasChromeOSDiamondKey, ""); | 489 chromeos::switches::kHasChromeOSDiamondKey, ""); |
493 TestRewriteNumPadKeys(); | 490 TestRewriteNumPadKeys(); |
494 } | 491 } |
495 | 492 |
496 // Tests if the rewriter can handle a Command + Num Pad event. | 493 // Tests if the rewriter can handle a Command + Num Pad event. |
497 void EventRewriterTest::TestRewriteNumPadKeysOnAppleKeyboard() { | 494 void EventRewriterTest::TestRewriteNumPadKeysOnAppleKeyboard() { |
498 sync_preferences::TestingPrefServiceSyncable prefs; | 495 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "Apple Keyboard"); |
499 EventRewriter rewriter(NULL); | 496 rewriter_->set_last_keyboard_device_id_for_testing(kKeyboardDeviceId); |
500 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "Apple Keyboard"); | |
501 rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId); | |
502 rewriter.set_pref_service_for_testing(&prefs); | |
503 | 497 |
504 KeyTestCase tests[] = { | 498 KeyTestCase tests[] = { |
505 // XK_KP_End (= NumPad 1 without Num Lock), Win modifier. | 499 // XK_KP_End (= NumPad 1 without Num Lock), Win modifier. |
506 // The result should be "Num Pad 1 with Control + Num Lock modifiers". | 500 // The result should be "Num Pad 1 with Control + Num Lock modifiers". |
507 {ui::ET_KEY_PRESSED, | 501 {ui::ET_KEY_PRESSED, |
508 {ui::VKEY_END, ui::DomCode::NUMPAD1, ui::EF_COMMAND_DOWN, | 502 {ui::VKEY_END, ui::DomCode::NUMPAD1, ui::EF_COMMAND_DOWN, |
509 ui::DomKey::END}, | 503 ui::DomKey::END}, |
510 {ui::VKEY_NUMPAD1, ui::DomCode::NUMPAD1, ui::EF_CONTROL_DOWN, | 504 {ui::VKEY_NUMPAD1, ui::DomCode::NUMPAD1, ui::EF_CONTROL_DOWN, |
511 ui::DomKey::Constant<'1'>::Character}}, | 505 ui::DomKey::Constant<'1'>::Character}}, |
512 | 506 |
513 // XK_KP_1 (= NumPad 1 with Num Lock), Win modifier. | 507 // XK_KP_1 (= NumPad 1 with Num Lock), Win modifier. |
514 // The result should also be "Num Pad 1 with Control + Num Lock | 508 // The result should also be "Num Pad 1 with Control + Num Lock |
515 // modifiers". | 509 // modifiers". |
516 {ui::ET_KEY_PRESSED, | 510 {ui::ET_KEY_PRESSED, |
517 {ui::VKEY_NUMPAD1, ui::DomCode::NUMPAD1, ui::EF_COMMAND_DOWN, | 511 {ui::VKEY_NUMPAD1, ui::DomCode::NUMPAD1, ui::EF_COMMAND_DOWN, |
518 ui::DomKey::Constant<'1'>::Character}, | 512 ui::DomKey::Constant<'1'>::Character}, |
519 {ui::VKEY_NUMPAD1, ui::DomCode::NUMPAD1, ui::EF_CONTROL_DOWN, | 513 {ui::VKEY_NUMPAD1, ui::DomCode::NUMPAD1, ui::EF_CONTROL_DOWN, |
520 ui::DomKey::Constant<'1'>::Character}}}; | 514 ui::DomKey::Constant<'1'>::Character}}}; |
521 | 515 |
522 for (const auto& test : tests) { | 516 for (const auto& test : tests) |
523 CheckKeyTestCase(&rewriter, test); | 517 CheckKeyTestCase(rewriter_, test); |
524 } | |
525 } | 518 } |
526 | 519 |
527 TEST_F(EventRewriterTest, TestRewriteNumPadKeysOnAppleKeyboard) { | 520 TEST_F(EventRewriterTest, TestRewriteNumPadKeysOnAppleKeyboard) { |
528 TestRewriteNumPadKeysOnAppleKeyboard(); | 521 TestRewriteNumPadKeysOnAppleKeyboard(); |
529 } | 522 } |
530 | 523 |
531 TEST_F(EventRewriterTest, | 524 TEST_F(EventRewriterTest, |
532 TestRewriteNumPadKeysOnAppleKeyboardWithDiamondKeyFlag) { | 525 TestRewriteNumPadKeysOnAppleKeyboardWithDiamondKeyFlag) { |
533 // Makes sure the num lock works correctly even when Diamond key exists. | 526 // Makes sure the num lock works correctly even when Diamond key exists. |
534 const base::CommandLine original_cl(*base::CommandLine::ForCurrentProcess()); | 527 const base::CommandLine original_cl(*base::CommandLine::ForCurrentProcess()); |
535 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( | 528 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
536 chromeos::switches::kHasChromeOSDiamondKey, ""); | 529 chromeos::switches::kHasChromeOSDiamondKey, ""); |
537 | 530 |
538 TestRewriteNumPadKeysOnAppleKeyboard(); | 531 TestRewriteNumPadKeysOnAppleKeyboard(); |
539 *base::CommandLine::ForCurrentProcess() = original_cl; | 532 *base::CommandLine::ForCurrentProcess() = original_cl; |
540 } | 533 } |
541 | 534 |
542 TEST_F(EventRewriterTest, TestRewriteModifiersNoRemap) { | 535 TEST_F(EventRewriterTest, TestRewriteModifiersNoRemap) { |
543 sync_preferences::TestingPrefServiceSyncable prefs; | 536 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
544 EventRewriter rewriter(NULL); | |
545 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
546 rewriter.set_pref_service_for_testing(&prefs); | |
547 | 537 |
548 KeyTestCase tests[] = { | 538 KeyTestCase tests[] = { |
549 // Press Search. Confirm the event is not rewritten. | 539 // Press Search. Confirm the event is not rewritten. |
550 {ui::ET_KEY_PRESSED, | 540 {ui::ET_KEY_PRESSED, |
551 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_NONE, ui::DomKey::META}, | 541 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_NONE, ui::DomKey::META}, |
552 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_COMMAND_DOWN, | 542 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_COMMAND_DOWN, |
553 ui::DomKey::META}}, | 543 ui::DomKey::META}}, |
554 | 544 |
555 // Press left Control. Confirm the event is not rewritten. | 545 // Press left Control. Confirm the event is not rewritten. |
556 {ui::ET_KEY_PRESSED, | 546 {ui::ET_KEY_PRESSED, |
(...skipping 21 matching lines...) Expand all Loading... |
578 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, | 568 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, |
579 ui::DomKey::ALT}}, | 569 ui::DomKey::ALT}}, |
580 | 570 |
581 // Test KeyRelease event, just in case. | 571 // Test KeyRelease event, just in case. |
582 // Release Search. Confirm the release event is not rewritten. | 572 // Release Search. Confirm the release event is not rewritten. |
583 {ui::ET_KEY_RELEASED, | 573 {ui::ET_KEY_RELEASED, |
584 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_NONE, ui::DomKey::META}, | 574 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_NONE, ui::DomKey::META}, |
585 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_NONE, ui::DomKey::META}}, | 575 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_NONE, ui::DomKey::META}}, |
586 }; | 576 }; |
587 | 577 |
588 for (const auto& test : tests) { | 578 for (const auto& test : tests) |
589 CheckKeyTestCase(&rewriter, test); | 579 CheckKeyTestCase(rewriter_, test); |
590 } | |
591 } | 580 } |
592 | 581 |
593 TEST_F(EventRewriterTest, TestRewriteModifiersNoRemapMultipleKeys) { | 582 TEST_F(EventRewriterTest, TestRewriteModifiersNoRemapMultipleKeys) { |
594 sync_preferences::TestingPrefServiceSyncable prefs; | 583 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
595 EventRewriter rewriter(NULL); | |
596 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
597 rewriter.set_pref_service_for_testing(&prefs); | |
598 | 584 |
599 KeyTestCase tests[] = { | 585 KeyTestCase tests[] = { |
600 // Press Alt with Shift. Confirm the event is not rewritten. | 586 // Press Alt with Shift. Confirm the event is not rewritten. |
601 {ui::ET_KEY_PRESSED, | 587 {ui::ET_KEY_PRESSED, |
602 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, | 588 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, |
603 ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, ui::DomKey::ALT}, | 589 ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, ui::DomKey::ALT}, |
604 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, | 590 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, |
605 ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, ui::DomKey::ALT}}, | 591 ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, ui::DomKey::ALT}}, |
606 | 592 |
607 // Press Escape with Alt and Shift. Confirm the event is not rewritten. | 593 // Press Escape with Alt and Shift. Confirm the event is not rewritten. |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
641 {ui::VKEY_B, ui::DomCode::US_B, | 627 {ui::VKEY_B, ui::DomCode::US_B, |
642 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | | 628 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | |
643 ui::EF_COMMAND_DOWN, | 629 ui::EF_COMMAND_DOWN, |
644 ui::DomKey::Constant<'B'>::Character}, | 630 ui::DomKey::Constant<'B'>::Character}, |
645 {ui::VKEY_B, ui::DomCode::US_B, | 631 {ui::VKEY_B, ui::DomCode::US_B, |
646 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | | 632 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | |
647 ui::EF_COMMAND_DOWN, | 633 ui::EF_COMMAND_DOWN, |
648 ui::DomKey::Constant<'B'>::Character}}, | 634 ui::DomKey::Constant<'B'>::Character}}, |
649 }; | 635 }; |
650 | 636 |
651 for (const auto& test : tests) { | 637 for (const auto& test : tests) |
652 CheckKeyTestCase(&rewriter, test); | 638 CheckKeyTestCase(rewriter_, test); |
653 } | |
654 } | 639 } |
655 | 640 |
656 TEST_F(EventRewriterTest, TestRewriteModifiersDisableSome) { | 641 TEST_F(EventRewriterTest, TestRewriteModifiersDisableSome) { |
657 // Disable Search, Control and Escape keys. | 642 // Disable Search, Control and Escape keys. |
658 sync_preferences::TestingPrefServiceSyncable prefs; | 643 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
659 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | |
660 IntegerPrefMember search; | 644 IntegerPrefMember search; |
661 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); | 645 search.Init(prefs::kLanguageRemapSearchKeyTo, prefs()); |
662 search.SetValue(chromeos::input_method::kVoidKey); | 646 search.SetValue(chromeos::input_method::kVoidKey); |
663 IntegerPrefMember control; | 647 IntegerPrefMember control; |
664 control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); | 648 control.Init(prefs::kLanguageRemapControlKeyTo, prefs()); |
665 control.SetValue(chromeos::input_method::kVoidKey); | 649 control.SetValue(chromeos::input_method::kVoidKey); |
666 IntegerPrefMember escape; | 650 IntegerPrefMember escape; |
667 escape.Init(prefs::kLanguageRemapEscapeKeyTo, &prefs); | 651 escape.Init(prefs::kLanguageRemapEscapeKeyTo, prefs()); |
668 escape.SetValue(chromeos::input_method::kVoidKey); | 652 escape.SetValue(chromeos::input_method::kVoidKey); |
669 | 653 |
670 EventRewriter rewriter(NULL); | 654 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
671 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
672 rewriter.set_pref_service_for_testing(&prefs); | |
673 | 655 |
674 KeyTestCase disabled_modifier_tests[] = { | 656 KeyTestCase disabled_modifier_tests[] = { |
675 // Press Alt with Shift. This key press shouldn't be affected by the | 657 // Press Alt with Shift. This key press shouldn't be affected by the |
676 // pref. Confirm the event is not rewritten. | 658 // pref. Confirm the event is not rewritten. |
677 {ui::ET_KEY_PRESSED, | 659 {ui::ET_KEY_PRESSED, |
678 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, | 660 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, |
679 ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, ui::DomKey::ALT}, | 661 ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, ui::DomKey::ALT}, |
680 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, | 662 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, |
681 ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, ui::DomKey::ALT}}, | 663 ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, ui::DomKey::ALT}}, |
682 | 664 |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
717 | 699 |
718 // Press Control+Search+Alt+a. Confirm the event is now VKEY_A only with | 700 // Press Control+Search+Alt+a. Confirm the event is now VKEY_A only with |
719 // the Alt modifier. | 701 // the Alt modifier. |
720 {ui::ET_KEY_PRESSED, | 702 {ui::ET_KEY_PRESSED, |
721 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, | 703 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, |
722 ui::DomKey::Constant<'a'>::Character}, | 704 ui::DomKey::Constant<'a'>::Character}, |
723 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN, | 705 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN, |
724 ui::DomKey::Constant<'a'>::Character}}, | 706 ui::DomKey::Constant<'a'>::Character}}, |
725 }; | 707 }; |
726 | 708 |
727 for (const auto& test : disabled_modifier_tests) { | 709 for (const auto& test : disabled_modifier_tests) |
728 CheckKeyTestCase(&rewriter, test); | 710 CheckKeyTestCase(rewriter_, test); |
729 } | |
730 | 711 |
731 // Remap Alt to Control. | 712 // Remap Alt to Control. |
732 IntegerPrefMember alt; | 713 IntegerPrefMember alt; |
733 alt.Init(prefs::kLanguageRemapAltKeyTo, &prefs); | 714 alt.Init(prefs::kLanguageRemapAltKeyTo, prefs()); |
734 alt.SetValue(chromeos::input_method::kControlKey); | 715 alt.SetValue(chromeos::input_method::kControlKey); |
735 | 716 |
736 KeyTestCase tests[] = { | 717 KeyTestCase tests[] = { |
737 // Press left Alt. Confirm the event is now VKEY_CONTROL | 718 // Press left Alt. Confirm the event is now VKEY_CONTROL |
738 // even though the Control key itself is disabled. | 719 // even though the Control key itself is disabled. |
739 {ui::ET_KEY_PRESSED, | 720 {ui::ET_KEY_PRESSED, |
740 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, ui::DomKey::ALT}, | 721 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, ui::DomKey::ALT}, |
741 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN, | 722 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN, |
742 ui::DomKey::CONTROL}}, | 723 ui::DomKey::CONTROL}}, |
743 | 724 |
744 // Press Alt+a. Confirm the event is now Control+a even though the Control | 725 // Press Alt+a. Confirm the event is now Control+a even though the Control |
745 // key itself is disabled. | 726 // key itself is disabled. |
746 {ui::ET_KEY_PRESSED, | 727 {ui::ET_KEY_PRESSED, |
747 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN, | 728 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN, |
748 ui::DomKey::Constant<'a'>::Character}, | 729 ui::DomKey::Constant<'a'>::Character}, |
749 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_CONTROL_DOWN, | 730 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_CONTROL_DOWN, |
750 ui::DomKey::Constant<'a'>::Character}}, | 731 ui::DomKey::Constant<'a'>::Character}}, |
751 }; | 732 }; |
752 | 733 |
753 for (const auto& test : tests) { | 734 for (const auto& test : tests) |
754 CheckKeyTestCase(&rewriter, test); | 735 CheckKeyTestCase(rewriter_, test); |
755 } | |
756 } | 736 } |
757 | 737 |
758 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToControl) { | 738 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToControl) { |
759 // Remap Search to Control. | 739 // Remap Search to Control. |
760 sync_preferences::TestingPrefServiceSyncable prefs; | 740 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
761 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | |
762 IntegerPrefMember search; | 741 IntegerPrefMember search; |
763 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); | 742 search.Init(prefs::kLanguageRemapSearchKeyTo, prefs()); |
764 search.SetValue(chromeos::input_method::kControlKey); | 743 search.SetValue(chromeos::input_method::kControlKey); |
765 | 744 |
766 EventRewriter rewriter(NULL); | 745 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
767 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
768 rewriter.set_pref_service_for_testing(&prefs); | |
769 | 746 |
770 KeyTestCase s_tests[] = { | 747 KeyTestCase s_tests[] = { |
771 // Press Search. Confirm the event is now VKEY_CONTROL. | 748 // Press Search. Confirm the event is now VKEY_CONTROL. |
772 {ui::ET_KEY_PRESSED, | 749 {ui::ET_KEY_PRESSED, |
773 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_COMMAND_DOWN, | 750 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_COMMAND_DOWN, |
774 ui::DomKey::META}, | 751 ui::DomKey::META}, |
775 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN, | 752 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN, |
776 ui::DomKey::CONTROL}}, | 753 ui::DomKey::CONTROL}}, |
777 }; | 754 }; |
778 | 755 |
779 for (const auto& test : s_tests) { | 756 for (const auto& test : s_tests) |
780 CheckKeyTestCase(&rewriter, test); | 757 CheckKeyTestCase(rewriter_, test); |
781 } | |
782 | 758 |
783 // Remap Alt to Control too. | 759 // Remap Alt to Control too. |
784 IntegerPrefMember alt; | 760 IntegerPrefMember alt; |
785 alt.Init(prefs::kLanguageRemapAltKeyTo, &prefs); | 761 alt.Init(prefs::kLanguageRemapAltKeyTo, prefs()); |
786 alt.SetValue(chromeos::input_method::kControlKey); | 762 alt.SetValue(chromeos::input_method::kControlKey); |
787 | 763 |
788 KeyTestCase sa_tests[] = { | 764 KeyTestCase sa_tests[] = { |
789 // Press Alt. Confirm the event is now VKEY_CONTROL. | 765 // Press Alt. Confirm the event is now VKEY_CONTROL. |
790 {ui::ET_KEY_PRESSED, | 766 {ui::ET_KEY_PRESSED, |
791 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, ui::DomKey::ALT}, | 767 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, ui::DomKey::ALT}, |
792 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN, | 768 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN, |
793 ui::DomKey::CONTROL}}, | 769 ui::DomKey::CONTROL}}, |
794 | 770 |
795 // Press Alt+Search. Confirm the event is now VKEY_CONTROL. | 771 // Press Alt+Search. Confirm the event is now VKEY_CONTROL. |
(...skipping 25 matching lines...) Expand all Loading... |
821 // and Control modifiers. | 797 // and Control modifiers. |
822 {ui::ET_KEY_PRESSED, | 798 {ui::ET_KEY_PRESSED, |
823 {ui::VKEY_B, ui::DomCode::US_B, | 799 {ui::VKEY_B, ui::DomCode::US_B, |
824 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | | 800 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | |
825 ui::EF_COMMAND_DOWN, | 801 ui::EF_COMMAND_DOWN, |
826 ui::DomKey::Constant<'B'>::Character}, | 802 ui::DomKey::Constant<'B'>::Character}, |
827 {ui::VKEY_B, ui::DomCode::US_B, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN, | 803 {ui::VKEY_B, ui::DomCode::US_B, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN, |
828 ui::DomKey::Constant<'B'>::Character}}, | 804 ui::DomKey::Constant<'B'>::Character}}, |
829 }; | 805 }; |
830 | 806 |
831 for (const auto& test : sa_tests) { | 807 for (const auto& test : sa_tests) |
832 CheckKeyTestCase(&rewriter, test); | 808 CheckKeyTestCase(rewriter_, test); |
833 } | |
834 } | 809 } |
835 | 810 |
836 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToEscape) { | 811 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToEscape) { |
837 // Remap Search to Escape. | 812 // Remap Search to Escape. |
838 sync_preferences::TestingPrefServiceSyncable prefs; | 813 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
839 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | |
840 IntegerPrefMember search; | 814 IntegerPrefMember search; |
841 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); | 815 search.Init(prefs::kLanguageRemapSearchKeyTo, prefs()); |
842 search.SetValue(chromeos::input_method::kEscapeKey); | 816 search.SetValue(chromeos::input_method::kEscapeKey); |
843 | 817 |
844 EventRewriter rewriter(NULL); | 818 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
845 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
846 rewriter.set_pref_service_for_testing(&prefs); | |
847 | 819 |
848 KeyTestCase tests[] = { | 820 KeyTestCase tests[] = { |
849 // Press Search. Confirm the event is now VKEY_ESCAPE. | 821 // Press Search. Confirm the event is now VKEY_ESCAPE. |
850 {ui::ET_KEY_PRESSED, | 822 {ui::ET_KEY_PRESSED, |
851 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_COMMAND_DOWN, | 823 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_COMMAND_DOWN, |
852 ui::DomKey::META}, | 824 ui::DomKey::META}, |
853 {ui::VKEY_ESCAPE, ui::DomCode::ESCAPE, ui::EF_NONE, ui::DomKey::ESCAPE}}, | 825 {ui::VKEY_ESCAPE, ui::DomCode::ESCAPE, ui::EF_NONE, ui::DomKey::ESCAPE}}, |
854 }; | 826 }; |
855 | 827 |
856 for (const auto& test : tests) { | 828 for (const auto& test : tests) |
857 CheckKeyTestCase(&rewriter, test); | 829 CheckKeyTestCase(rewriter_, test); |
858 } | |
859 } | 830 } |
860 | 831 |
861 TEST_F(EventRewriterTest, TestRewriteModifiersRemapMany) { | 832 TEST_F(EventRewriterTest, TestRewriteModifiersRemapMany) { |
862 // Remap Escape to Alt. | 833 // Remap Escape to Alt. |
863 sync_preferences::TestingPrefServiceSyncable prefs; | 834 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
864 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | |
865 IntegerPrefMember escape; | 835 IntegerPrefMember escape; |
866 escape.Init(prefs::kLanguageRemapEscapeKeyTo, &prefs); | 836 escape.Init(prefs::kLanguageRemapEscapeKeyTo, prefs()); |
867 escape.SetValue(chromeos::input_method::kAltKey); | 837 escape.SetValue(chromeos::input_method::kAltKey); |
868 | 838 |
869 EventRewriter rewriter(NULL); | 839 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
870 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
871 rewriter.set_pref_service_for_testing(&prefs); | |
872 | 840 |
873 KeyTestCase e2a_tests[] = { | 841 KeyTestCase e2a_tests[] = { |
874 // Press Escape. Confirm the event is now VKEY_MENU. | 842 // Press Escape. Confirm the event is now VKEY_MENU. |
875 {ui::ET_KEY_PRESSED, | 843 {ui::ET_KEY_PRESSED, |
876 {ui::VKEY_ESCAPE, ui::DomCode::ESCAPE, ui::EF_NONE, ui::DomKey::ESCAPE}, | 844 {ui::VKEY_ESCAPE, ui::DomCode::ESCAPE, ui::EF_NONE, ui::DomKey::ESCAPE}, |
877 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, | 845 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, |
878 ui::DomKey::ALT}}, | 846 ui::DomKey::ALT}}, |
879 // Release Escape to clear flags. | 847 // Release Escape to clear flags. |
880 {ui::ET_KEY_RELEASED, | 848 {ui::ET_KEY_RELEASED, |
881 {ui::VKEY_ESCAPE, ui::DomCode::ESCAPE, ui::EF_NONE, ui::DomKey::ESCAPE}, | 849 {ui::VKEY_ESCAPE, ui::DomCode::ESCAPE, ui::EF_NONE, ui::DomKey::ESCAPE}, |
882 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_NONE, ui::DomKey::ALT}}, | 850 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_NONE, ui::DomKey::ALT}}, |
883 }; | 851 }; |
884 | 852 |
885 for (const auto& test : e2a_tests) { | 853 for (const auto& test : e2a_tests) |
886 CheckKeyTestCase(&rewriter, test); | 854 CheckKeyTestCase(rewriter_, test); |
887 } | |
888 | 855 |
889 // Remap Alt to Control. | 856 // Remap Alt to Control. |
890 IntegerPrefMember alt; | 857 IntegerPrefMember alt; |
891 alt.Init(prefs::kLanguageRemapAltKeyTo, &prefs); | 858 alt.Init(prefs::kLanguageRemapAltKeyTo, prefs()); |
892 alt.SetValue(chromeos::input_method::kControlKey); | 859 alt.SetValue(chromeos::input_method::kControlKey); |
893 | 860 |
894 KeyTestCase a2c_tests[] = { | 861 KeyTestCase a2c_tests[] = { |
895 // Press left Alt. Confirm the event is now VKEY_CONTROL. | 862 // Press left Alt. Confirm the event is now VKEY_CONTROL. |
896 {ui::ET_KEY_PRESSED, | 863 {ui::ET_KEY_PRESSED, |
897 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, ui::DomKey::ALT}, | 864 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, ui::DomKey::ALT}, |
898 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN, | 865 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN, |
899 ui::DomKey::CONTROL}}, | 866 ui::DomKey::CONTROL}}, |
900 // Press Shift+comma. Verify that only the flags are changed. | 867 // Press Shift+comma. Verify that only the flags are changed. |
901 {ui::ET_KEY_PRESSED, | 868 {ui::ET_KEY_PRESSED, |
902 {ui::VKEY_OEM_COMMA, ui::DomCode::COMMA, | 869 {ui::VKEY_OEM_COMMA, ui::DomCode::COMMA, |
903 ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, ui::DomKey::UNIDENTIFIED}, | 870 ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, ui::DomKey::UNIDENTIFIED}, |
904 {ui::VKEY_OEM_COMMA, ui::DomCode::COMMA, | 871 {ui::VKEY_OEM_COMMA, ui::DomCode::COMMA, |
905 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN, | 872 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN, |
906 ui::DomKey::Constant<'<'>::Character}}, | 873 ui::DomKey::Constant<'<'>::Character}}, |
907 // Press Shift+9. Verify that only the flags are changed. | 874 // Press Shift+9. Verify that only the flags are changed. |
908 {ui::ET_KEY_PRESSED, | 875 {ui::ET_KEY_PRESSED, |
909 {ui::VKEY_9, ui::DomCode::DIGIT9, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, | 876 {ui::VKEY_9, ui::DomCode::DIGIT9, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN, |
910 ui::DomKey::UNIDENTIFIED}, | 877 ui::DomKey::UNIDENTIFIED}, |
911 {ui::VKEY_9, ui::DomCode::DIGIT9, | 878 {ui::VKEY_9, ui::DomCode::DIGIT9, |
912 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN, | 879 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN, |
913 ui::DomKey::Constant<'('>::Character}}, | 880 ui::DomKey::Constant<'('>::Character}}, |
914 }; | 881 }; |
915 | 882 |
916 for (const auto& test : a2c_tests) { | 883 for (const auto& test : a2c_tests) |
917 CheckKeyTestCase(&rewriter, test); | 884 CheckKeyTestCase(rewriter_, test); |
918 } | |
919 | 885 |
920 // Remap Control to Search. | 886 // Remap Control to Search. |
921 IntegerPrefMember control; | 887 IntegerPrefMember control; |
922 control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); | 888 control.Init(prefs::kLanguageRemapControlKeyTo, prefs()); |
923 control.SetValue(chromeos::input_method::kSearchKey); | 889 control.SetValue(chromeos::input_method::kSearchKey); |
924 | 890 |
925 KeyTestCase c2s_tests[] = { | 891 KeyTestCase c2s_tests[] = { |
926 // Press left Control. Confirm the event is now VKEY_LWIN. | 892 // Press left Control. Confirm the event is now VKEY_LWIN. |
927 {ui::ET_KEY_PRESSED, | 893 {ui::ET_KEY_PRESSED, |
928 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN, | 894 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN, |
929 ui::DomKey::CONTROL}, | 895 ui::DomKey::CONTROL}, |
930 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_COMMAND_DOWN, | 896 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_COMMAND_DOWN, |
931 ui::DomKey::META}}, | 897 ui::DomKey::META}}, |
932 | 898 |
(...skipping 19 matching lines...) Expand all Loading... |
952 {ui::ET_KEY_PRESSED, | 918 {ui::ET_KEY_PRESSED, |
953 {ui::VKEY_B, ui::DomCode::US_B, | 919 {ui::VKEY_B, ui::DomCode::US_B, |
954 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, | 920 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN, |
955 ui::DomKey::Constant<'B'>::Character}, | 921 ui::DomKey::Constant<'B'>::Character}, |
956 {ui::VKEY_B, ui::DomCode::US_B, | 922 {ui::VKEY_B, ui::DomCode::US_B, |
957 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | | 923 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | |
958 ui::EF_COMMAND_DOWN, | 924 ui::EF_COMMAND_DOWN, |
959 ui::DomKey::Constant<'B'>::Character}}, | 925 ui::DomKey::Constant<'B'>::Character}}, |
960 }; | 926 }; |
961 | 927 |
962 for (const auto& test : c2s_tests) { | 928 for (const auto& test : c2s_tests) |
963 CheckKeyTestCase(&rewriter, test); | 929 CheckKeyTestCase(rewriter_, test); |
964 } | |
965 | 930 |
966 // Remap Search to Backspace. | 931 // Remap Search to Backspace. |
967 IntegerPrefMember search; | 932 IntegerPrefMember search; |
968 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); | 933 search.Init(prefs::kLanguageRemapSearchKeyTo, prefs()); |
969 search.SetValue(chromeos::input_method::kBackspaceKey); | 934 search.SetValue(chromeos::input_method::kBackspaceKey); |
970 | 935 |
971 KeyTestCase s2b_tests[] = { | 936 KeyTestCase s2b_tests[] = { |
972 // Release Control and Escape, as Search and Alt would transform Backspace | 937 // Release Control and Escape, as Search and Alt would transform Backspace |
973 // to Delete. | 938 // to Delete. |
974 {ui::ET_KEY_RELEASED, | 939 {ui::ET_KEY_RELEASED, |
975 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_NONE, | 940 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_NONE, |
976 ui::DomKey::CONTROL}, | 941 ui::DomKey::CONTROL}, |
977 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_ALT_DOWN, | 942 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_ALT_DOWN, |
978 ui::DomKey::META}}, | 943 ui::DomKey::META}}, |
979 {ui::ET_KEY_RELEASED, | 944 {ui::ET_KEY_RELEASED, |
980 {ui::VKEY_ESCAPE, ui::DomCode::ESCAPE, ui::EF_NONE, ui::DomKey::ESCAPE}, | 945 {ui::VKEY_ESCAPE, ui::DomCode::ESCAPE, ui::EF_NONE, ui::DomKey::ESCAPE}, |
981 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_NONE, ui::DomKey::ALT}}, | 946 {ui::VKEY_MENU, ui::DomCode::ALT_LEFT, ui::EF_NONE, ui::DomKey::ALT}}, |
982 // Press Search. Confirm the event is now VKEY_BACK. | 947 // Press Search. Confirm the event is now VKEY_BACK. |
983 {ui::ET_KEY_PRESSED, | 948 {ui::ET_KEY_PRESSED, |
984 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_COMMAND_DOWN, | 949 {ui::VKEY_LWIN, ui::DomCode::META_LEFT, ui::EF_COMMAND_DOWN, |
985 ui::DomKey::META}, | 950 ui::DomKey::META}, |
986 {ui::VKEY_BACK, ui::DomCode::BACKSPACE, ui::EF_NONE, | 951 {ui::VKEY_BACK, ui::DomCode::BACKSPACE, ui::EF_NONE, |
987 ui::DomKey::BACKSPACE}}, | 952 ui::DomKey::BACKSPACE}}, |
988 }; | 953 }; |
989 | 954 |
990 for (const auto& test : s2b_tests) { | 955 for (const auto& test : s2b_tests) |
991 CheckKeyTestCase(&rewriter, test); | 956 CheckKeyTestCase(rewriter_, test); |
992 } | |
993 | 957 |
994 // Remap Backspace to Escape. | 958 // Remap Backspace to Escape. |
995 IntegerPrefMember backspace; | 959 IntegerPrefMember backspace; |
996 backspace.Init(prefs::kLanguageRemapBackspaceKeyTo, &prefs); | 960 backspace.Init(prefs::kLanguageRemapBackspaceKeyTo, prefs()); |
997 backspace.SetValue(chromeos::input_method::kEscapeKey); | 961 backspace.SetValue(chromeos::input_method::kEscapeKey); |
998 | 962 |
999 KeyTestCase b2e_tests[] = { | 963 KeyTestCase b2e_tests[] = { |
1000 // Press Backspace. Confirm the event is now VKEY_ESCAPE. | 964 // Press Backspace. Confirm the event is now VKEY_ESCAPE. |
1001 {ui::ET_KEY_PRESSED, | 965 {ui::ET_KEY_PRESSED, |
1002 {ui::VKEY_BACK, ui::DomCode::BACKSPACE, ui::EF_NONE, | 966 {ui::VKEY_BACK, ui::DomCode::BACKSPACE, ui::EF_NONE, |
1003 ui::DomKey::BACKSPACE}, | 967 ui::DomKey::BACKSPACE}, |
1004 {ui::VKEY_ESCAPE, ui::DomCode::ESCAPE, ui::EF_NONE, ui::DomKey::ESCAPE}}, | 968 {ui::VKEY_ESCAPE, ui::DomCode::ESCAPE, ui::EF_NONE, ui::DomKey::ESCAPE}}, |
1005 }; | 969 }; |
1006 | 970 |
1007 for (const auto& test : b2e_tests) { | 971 for (const auto& test : b2e_tests) |
1008 CheckKeyTestCase(&rewriter, test); | 972 CheckKeyTestCase(rewriter_, test); |
1009 } | |
1010 } | 973 } |
1011 | 974 |
1012 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToCapsLock) { | 975 TEST_F(EventRewriterTest, TestRewriteModifiersRemapToCapsLock) { |
1013 // Remap Search to Caps Lock. | 976 // Remap Search to Caps Lock. |
1014 sync_preferences::TestingPrefServiceSyncable prefs; | 977 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
1015 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | |
1016 IntegerPrefMember search; | 978 IntegerPrefMember search; |
1017 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); | 979 search.Init(prefs::kLanguageRemapSearchKeyTo, prefs()); |
1018 search.SetValue(chromeos::input_method::kCapsLockKey); | 980 search.SetValue(chromeos::input_method::kCapsLockKey); |
1019 | 981 |
1020 chromeos::input_method::FakeImeKeyboard ime_keyboard; | 982 chromeos::input_method::FakeImeKeyboard ime_keyboard; |
1021 EventRewriter rewriter(NULL); | 983 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
1022 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | 984 rewriter_->set_ime_keyboard_for_testing(&ime_keyboard); |
1023 rewriter.set_pref_service_for_testing(&prefs); | |
1024 rewriter.set_ime_keyboard_for_testing(&ime_keyboard); | |
1025 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); | 985 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); |
1026 | 986 |
1027 // Press Search. | 987 // Press Search. |
1028 EXPECT_EQ(GetExpectedResultAsString( | 988 EXPECT_EQ(GetExpectedResultAsString( |
1029 ui::ET_KEY_PRESSED, ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK, | 989 ui::ET_KEY_PRESSED, ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK, |
1030 ui::EF_MOD3_DOWN | ui::EF_CAPS_LOCK_ON, ui::DomKey::CAPS_LOCK), | 990 ui::EF_MOD3_DOWN | ui::EF_CAPS_LOCK_ON, ui::DomKey::CAPS_LOCK), |
1031 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, | 991 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, |
1032 ui::VKEY_LWIN, ui::DomCode::META_LEFT, | 992 ui::VKEY_LWIN, ui::DomCode::META_LEFT, |
1033 ui::EF_COMMAND_DOWN, ui::DomKey::META)); | 993 ui::EF_COMMAND_DOWN, ui::DomKey::META)); |
1034 // Confirm that the Caps Lock status is changed. | 994 // Confirm that the Caps Lock status is changed. |
1035 EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_); | 995 EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_); |
1036 | 996 |
1037 // Release Search. | 997 // Release Search. |
1038 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CAPITAL, | 998 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CAPITAL, |
1039 ui::DomCode::CAPS_LOCK, ui::EF_NONE, | 999 ui::DomCode::CAPS_LOCK, ui::EF_NONE, |
1040 ui::DomKey::CAPS_LOCK), | 1000 ui::DomKey::CAPS_LOCK), |
1041 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_RELEASED, | 1001 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_RELEASED, |
1042 ui::VKEY_LWIN, ui::DomCode::META_LEFT, | 1002 ui::VKEY_LWIN, ui::DomCode::META_LEFT, |
1043 ui::EF_NONE, ui::DomKey::META)); | 1003 ui::EF_NONE, ui::DomKey::META)); |
1044 // Confirm that the Caps Lock status is not changed. | 1004 // Confirm that the Caps Lock status is not changed. |
1045 EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_); | 1005 EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_); |
1046 | 1006 |
1047 // Press Search. | 1007 // Press Search. |
1048 EXPECT_EQ(GetExpectedResultAsString( | 1008 EXPECT_EQ(GetExpectedResultAsString( |
1049 ui::ET_KEY_PRESSED, ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK, | 1009 ui::ET_KEY_PRESSED, ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK, |
1050 ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN, ui::DomKey::CAPS_LOCK), | 1010 ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN, ui::DomKey::CAPS_LOCK), |
1051 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, | 1011 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, |
1052 ui::VKEY_LWIN, ui::DomCode::META_LEFT, | 1012 ui::VKEY_LWIN, ui::DomCode::META_LEFT, |
1053 ui::EF_COMMAND_DOWN | ui::EF_CAPS_LOCK_ON, | 1013 ui::EF_COMMAND_DOWN | ui::EF_CAPS_LOCK_ON, |
1054 ui::DomKey::META)); | 1014 ui::DomKey::META)); |
1055 // Confirm that the Caps Lock status is changed. | 1015 // Confirm that the Caps Lock status is changed. |
1056 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); | 1016 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); |
1057 | 1017 |
1058 // Release Search. | 1018 // Release Search. |
1059 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CAPITAL, | 1019 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CAPITAL, |
1060 ui::DomCode::CAPS_LOCK, ui::EF_NONE, | 1020 ui::DomCode::CAPS_LOCK, ui::EF_NONE, |
1061 ui::DomKey::CAPS_LOCK), | 1021 ui::DomKey::CAPS_LOCK), |
1062 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_RELEASED, | 1022 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_RELEASED, |
1063 ui::VKEY_LWIN, ui::DomCode::META_LEFT, | 1023 ui::VKEY_LWIN, ui::DomCode::META_LEFT, |
1064 ui::EF_NONE, ui::DomKey::META)); | 1024 ui::EF_NONE, ui::DomKey::META)); |
1065 // Confirm that the Caps Lock status is not changed. | 1025 // Confirm that the Caps Lock status is not changed. |
1066 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); | 1026 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); |
1067 | 1027 |
1068 // Press Caps Lock (on an external keyboard). | 1028 // Press Caps Lock (on an external keyboard). |
1069 EXPECT_EQ(GetExpectedResultAsString( | 1029 EXPECT_EQ(GetExpectedResultAsString( |
1070 ui::ET_KEY_PRESSED, ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK, | 1030 ui::ET_KEY_PRESSED, ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK, |
1071 ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN, ui::DomKey::CAPS_LOCK), | 1031 ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN, ui::DomKey::CAPS_LOCK), |
1072 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, | 1032 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, |
1073 ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK, | 1033 ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK, |
1074 ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN, | 1034 ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN, |
1075 ui::DomKey::CAPS_LOCK)); | 1035 ui::DomKey::CAPS_LOCK)); |
1076 | 1036 |
1077 #if defined(USE_X11) | 1037 #if defined(USE_X11) |
1078 // Confirm that calling RewriteForTesting() does not change the state of | 1038 // Confirm that calling RewriteForTesting() does not change the state of |
1079 // |ime_keyboard|. In this case, X Window system itself should change the | 1039 // |ime_keyboard|. In this case, X Window system itself should change the |
1080 // Caps Lock state, not ash::EventRewriter. | 1040 // Caps Lock state, not ash::EventRewriter. |
1081 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); | 1041 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); |
1082 #elif defined(USE_OZONE) | 1042 #elif defined(USE_OZONE) |
1083 // Under Ozone the rewriter is responsible for changing the caps lock | 1043 // Under Ozone the rewriter is responsible for changing the caps lock |
1084 // state when the final key is Caps Lock, regardless of whether the | 1044 // state when the final key is Caps Lock, regardless of whether the |
1085 // initial key is Caps Lock. | 1045 // initial key is Caps Lock. |
1086 EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_); | 1046 EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_); |
1087 #endif | 1047 #endif |
1088 | 1048 |
1089 // Release Caps Lock (on an external keyboard). | 1049 // Release Caps Lock (on an external keyboard). |
1090 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CAPITAL, | 1050 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CAPITAL, |
1091 ui::DomCode::CAPS_LOCK, ui::EF_NONE, | 1051 ui::DomCode::CAPS_LOCK, ui::EF_NONE, |
1092 ui::DomKey::CAPS_LOCK), | 1052 ui::DomKey::CAPS_LOCK), |
1093 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_RELEASED, | 1053 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_RELEASED, |
1094 ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK, | 1054 ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK, |
1095 ui::EF_NONE, ui::DomKey::CAPS_LOCK)); | 1055 ui::EF_NONE, ui::DomKey::CAPS_LOCK)); |
1096 #if defined(USE_X11) | 1056 #if defined(USE_X11) |
1097 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); | 1057 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); |
1098 #elif defined(USE_OZONE) | 1058 #elif defined(USE_OZONE) |
1099 EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_); | 1059 EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_); |
1100 #endif | 1060 #endif |
1101 } | 1061 } |
1102 | 1062 |
1103 TEST_F(EventRewriterTest, TestRewriteCapsLock) { | 1063 TEST_F(EventRewriterTest, TestRewriteCapsLock) { |
1104 sync_preferences::TestingPrefServiceSyncable prefs; | 1064 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
1105 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | |
1106 | 1065 |
1107 chromeos::input_method::FakeImeKeyboard ime_keyboard; | 1066 chromeos::input_method::FakeImeKeyboard ime_keyboard; |
1108 EventRewriter rewriter(NULL); | 1067 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
1109 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | 1068 rewriter_->set_ime_keyboard_for_testing(&ime_keyboard); |
1110 rewriter.set_pref_service_for_testing(&prefs); | |
1111 rewriter.set_ime_keyboard_for_testing(&ime_keyboard); | |
1112 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); | 1069 EXPECT_FALSE(ime_keyboard.caps_lock_is_enabled_); |
1113 | 1070 |
1114 // On Chrome OS, CapsLock is mapped to F16 with Mod3Mask. | 1071 // On Chrome OS, CapsLock is mapped to F16 with Mod3Mask. |
1115 EXPECT_EQ(GetExpectedResultAsString( | 1072 EXPECT_EQ(GetExpectedResultAsString( |
1116 ui::ET_KEY_PRESSED, ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK, | 1073 ui::ET_KEY_PRESSED, ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK, |
1117 ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN, ui::DomKey::CAPS_LOCK), | 1074 ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN, ui::DomKey::CAPS_LOCK), |
1118 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, | 1075 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, |
1119 ui::VKEY_F16, ui::DomCode::F16, | 1076 ui::VKEY_F16, ui::DomCode::F16, |
1120 ui::EF_MOD3_DOWN, ui::DomKey::F16)); | 1077 ui::EF_MOD3_DOWN, ui::DomKey::F16)); |
1121 EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_); | 1078 EXPECT_TRUE(ime_keyboard.caps_lock_is_enabled_); |
1122 } | 1079 } |
1123 | 1080 |
1124 TEST_F(EventRewriterTest, TestRewriteDiamondKey) { | 1081 TEST_F(EventRewriterTest, TestRewriteDiamondKey) { |
1125 sync_preferences::TestingPrefServiceSyncable prefs; | 1082 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
1126 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | |
1127 | 1083 |
1128 chromeos::input_method::FakeImeKeyboard ime_keyboard; | 1084 chromeos::input_method::FakeImeKeyboard ime_keyboard; |
1129 EventRewriter rewriter(NULL); | 1085 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
1130 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | 1086 rewriter_->set_ime_keyboard_for_testing(&ime_keyboard); |
1131 rewriter.set_pref_service_for_testing(&prefs); | |
1132 rewriter.set_ime_keyboard_for_testing(&ime_keyboard); | |
1133 | 1087 |
1134 KeyTestCase tests[] = { | 1088 KeyTestCase tests[] = { |
1135 // F15 should work as Ctrl when --has-chromeos-diamond-key is not | 1089 // F15 should work as Ctrl when --has-chromeos-diamond-key is not |
1136 // specified. | 1090 // specified. |
1137 {ui::ET_KEY_PRESSED, | 1091 {ui::ET_KEY_PRESSED, |
1138 {ui::VKEY_F15, ui::DomCode::F15, ui::EF_NONE, ui::DomKey::F15}, | 1092 {ui::VKEY_F15, ui::DomCode::F15, ui::EF_NONE, ui::DomKey::F15}, |
1139 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN, | 1093 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN, |
1140 ui::DomKey::CONTROL}}, | 1094 ui::DomKey::CONTROL}}, |
1141 | 1095 |
1142 {ui::ET_KEY_RELEASED, | 1096 {ui::ET_KEY_RELEASED, |
1143 {ui::VKEY_F15, ui::DomCode::F15, ui::EF_NONE, ui::DomKey::F15}, | 1097 {ui::VKEY_F15, ui::DomCode::F15, ui::EF_NONE, ui::DomKey::F15}, |
1144 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_NONE, | 1098 {ui::VKEY_CONTROL, ui::DomCode::CONTROL_LEFT, ui::EF_NONE, |
1145 ui::DomKey::CONTROL}}, | 1099 ui::DomKey::CONTROL}}, |
1146 | 1100 |
1147 // However, Mod2Mask should not be rewritten to CtrlMask when | 1101 // However, Mod2Mask should not be rewritten to CtrlMask when |
1148 // --has-chromeos-diamond-key is not specified. | 1102 // --has-chromeos-diamond-key is not specified. |
1149 {ui::ET_KEY_PRESSED, | 1103 {ui::ET_KEY_PRESSED, |
1150 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_NONE, | 1104 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_NONE, |
1151 ui::DomKey::Constant<'a'>::Character}, | 1105 ui::DomKey::Constant<'a'>::Character}, |
1152 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_NONE, | 1106 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_NONE, |
1153 ui::DomKey::Constant<'a'>::Character}}, | 1107 ui::DomKey::Constant<'a'>::Character}}, |
1154 }; | 1108 }; |
1155 | 1109 |
1156 for (const auto& test : tests) { | 1110 for (const auto& test : tests) |
1157 CheckKeyTestCase(&rewriter, test); | 1111 CheckKeyTestCase(rewriter_, test); |
1158 } | |
1159 } | 1112 } |
1160 | 1113 |
1161 TEST_F(EventRewriterTest, TestRewriteDiamondKeyWithFlag) { | 1114 TEST_F(EventRewriterTest, TestRewriteDiamondKeyWithFlag) { |
1162 const base::CommandLine original_cl(*base::CommandLine::ForCurrentProcess()); | 1115 const base::CommandLine original_cl(*base::CommandLine::ForCurrentProcess()); |
1163 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( | 1116 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( |
1164 chromeos::switches::kHasChromeOSDiamondKey, ""); | 1117 chromeos::switches::kHasChromeOSDiamondKey, ""); |
1165 | 1118 |
1166 sync_preferences::TestingPrefServiceSyncable prefs; | 1119 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
1167 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | |
1168 | 1120 |
1169 chromeos::input_method::FakeImeKeyboard ime_keyboard; | 1121 chromeos::input_method::FakeImeKeyboard ime_keyboard; |
1170 EventRewriter rewriter(NULL); | 1122 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
1171 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | 1123 rewriter_->set_ime_keyboard_for_testing(&ime_keyboard); |
1172 rewriter.set_pref_service_for_testing(&prefs); | |
1173 rewriter.set_ime_keyboard_for_testing(&ime_keyboard); | |
1174 | 1124 |
1175 // By default, F15 should work as Control. | 1125 // By default, F15 should work as Control. |
1176 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, | 1126 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, |
1177 ui::DomCode::CONTROL_LEFT, | 1127 ui::DomCode::CONTROL_LEFT, |
1178 ui::EF_CONTROL_DOWN, ui::DomKey::CONTROL), | 1128 ui::EF_CONTROL_DOWN, ui::DomKey::CONTROL), |
1179 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, | 1129 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, |
1180 ui::VKEY_F15, ui::DomCode::F15, | 1130 ui::VKEY_F15, ui::DomCode::F15, |
1181 ui::EF_NONE, ui::DomKey::F15)); | 1131 ui::EF_NONE, ui::DomKey::F15)); |
1182 // Check that Control is applied to a subsequent key press. | 1132 // Check that Control is applied to a subsequent key press. |
1183 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, | 1133 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, |
1184 ui::DomCode::US_A, ui::EF_CONTROL_DOWN, | 1134 ui::DomCode::US_A, ui::EF_CONTROL_DOWN, |
1185 ui::DomKey::Constant<'a'>::Character), | 1135 ui::DomKey::Constant<'a'>::Character), |
1186 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A, | 1136 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A, |
1187 ui::DomCode::US_A, ui::EF_NONE, | 1137 ui::DomCode::US_A, ui::EF_NONE, |
1188 ui::DomKey::Constant<'a'>::Character)); | 1138 ui::DomKey::Constant<'a'>::Character)); |
1189 // Release F15 | 1139 // Release F15 |
1190 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CONTROL, | 1140 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CONTROL, |
1191 ui::DomCode::CONTROL_LEFT, ui::EF_NONE, | 1141 ui::DomCode::CONTROL_LEFT, ui::EF_NONE, |
1192 ui::DomKey::CONTROL), | 1142 ui::DomKey::CONTROL), |
1193 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_RELEASED, | 1143 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_RELEASED, |
1194 ui::VKEY_F15, ui::DomCode::F15, | 1144 ui::VKEY_F15, ui::DomCode::F15, |
1195 ui::EF_NONE, ui::DomKey::F15)); | 1145 ui::EF_NONE, ui::DomKey::F15)); |
1196 // Check that Control is no longer applied to a subsequent key press. | 1146 // Check that Control is no longer applied to a subsequent key press. |
1197 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, | 1147 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, |
1198 ui::DomCode::US_A, ui::EF_NONE, | 1148 ui::DomCode::US_A, ui::EF_NONE, |
1199 ui::DomKey::Constant<'a'>::Character), | 1149 ui::DomKey::Constant<'a'>::Character), |
1200 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A, | 1150 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A, |
1201 ui::DomCode::US_A, ui::EF_NONE, | 1151 ui::DomCode::US_A, ui::EF_NONE, |
1202 ui::DomKey::Constant<'a'>::Character)); | 1152 ui::DomKey::Constant<'a'>::Character)); |
1203 | 1153 |
1204 IntegerPrefMember diamond; | 1154 IntegerPrefMember diamond; |
1205 diamond.Init(prefs::kLanguageRemapDiamondKeyTo, &prefs); | 1155 diamond.Init(prefs::kLanguageRemapDiamondKeyTo, prefs()); |
1206 diamond.SetValue(chromeos::input_method::kVoidKey); | 1156 diamond.SetValue(chromeos::input_method::kVoidKey); |
1207 | 1157 |
1208 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_UNKNOWN, | 1158 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_UNKNOWN, |
1209 ui::DomCode::NONE, ui::EF_NONE, | 1159 ui::DomCode::NONE, ui::EF_NONE, |
1210 ui::DomKey::UNIDENTIFIED), | 1160 ui::DomKey::UNIDENTIFIED), |
1211 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, | 1161 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, |
1212 ui::VKEY_F15, ui::DomCode::F15, | 1162 ui::VKEY_F15, ui::DomCode::F15, |
1213 ui::EF_NONE, ui::DomKey::F15)); | 1163 ui::EF_NONE, ui::DomKey::F15)); |
1214 // Check that no modifier is applied to another key. | 1164 // Check that no modifier is applied to another key. |
1215 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, | 1165 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, |
1216 ui::DomCode::US_A, ui::EF_NONE, | 1166 ui::DomCode::US_A, ui::EF_NONE, |
1217 ui::DomKey::Constant<'a'>::Character), | 1167 ui::DomKey::Constant<'a'>::Character), |
1218 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A, | 1168 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A, |
1219 ui::DomCode::US_A, ui::EF_NONE, | 1169 ui::DomCode::US_A, ui::EF_NONE, |
1220 ui::DomKey::Constant<'a'>::Character)); | 1170 ui::DomKey::Constant<'a'>::Character)); |
1221 | 1171 |
1222 diamond.SetValue(chromeos::input_method::kControlKey); | 1172 diamond.SetValue(chromeos::input_method::kControlKey); |
1223 | 1173 |
1224 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, | 1174 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, |
1225 ui::DomCode::CONTROL_LEFT, | 1175 ui::DomCode::CONTROL_LEFT, |
1226 ui::EF_CONTROL_DOWN, ui::DomKey::CONTROL), | 1176 ui::EF_CONTROL_DOWN, ui::DomKey::CONTROL), |
1227 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, | 1177 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, |
1228 ui::VKEY_F15, ui::DomCode::F15, | 1178 ui::VKEY_F15, ui::DomCode::F15, |
1229 ui::EF_NONE, ui::DomKey::F15)); | 1179 ui::EF_NONE, ui::DomKey::F15)); |
1230 // Check that Control is applied to a subsequent key press. | 1180 // Check that Control is applied to a subsequent key press. |
1231 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, | 1181 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, |
1232 ui::DomCode::US_A, ui::EF_CONTROL_DOWN, | 1182 ui::DomCode::US_A, ui::EF_CONTROL_DOWN, |
1233 ui::DomKey::Constant<'a'>::Character), | 1183 ui::DomKey::Constant<'a'>::Character), |
1234 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A, | 1184 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A, |
1235 ui::DomCode::US_A, ui::EF_NONE, | 1185 ui::DomCode::US_A, ui::EF_NONE, |
1236 ui::DomKey::Constant<'a'>::Character)); | 1186 ui::DomKey::Constant<'a'>::Character)); |
1237 // Release F15 | 1187 // Release F15 |
1238 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CONTROL, | 1188 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CONTROL, |
1239 ui::DomCode::CONTROL_LEFT, ui::EF_NONE, | 1189 ui::DomCode::CONTROL_LEFT, ui::EF_NONE, |
1240 ui::DomKey::CONTROL), | 1190 ui::DomKey::CONTROL), |
1241 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_RELEASED, | 1191 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_RELEASED, |
1242 ui::VKEY_F15, ui::DomCode::F15, | 1192 ui::VKEY_F15, ui::DomCode::F15, |
1243 ui::EF_NONE, ui::DomKey::F15)); | 1193 ui::EF_NONE, ui::DomKey::F15)); |
1244 // Check that Control is no longer applied to a subsequent key press. | 1194 // Check that Control is no longer applied to a subsequent key press. |
1245 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, | 1195 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, |
1246 ui::DomCode::US_A, ui::EF_NONE, | 1196 ui::DomCode::US_A, ui::EF_NONE, |
1247 ui::DomKey::Constant<'a'>::Character), | 1197 ui::DomKey::Constant<'a'>::Character), |
1248 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A, | 1198 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A, |
1249 ui::DomCode::US_A, ui::EF_NONE, | 1199 ui::DomCode::US_A, ui::EF_NONE, |
1250 ui::DomKey::Constant<'a'>::Character)); | 1200 ui::DomKey::Constant<'a'>::Character)); |
1251 | 1201 |
1252 diamond.SetValue(chromeos::input_method::kAltKey); | 1202 diamond.SetValue(chromeos::input_method::kAltKey); |
1253 | 1203 |
1254 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_MENU, | 1204 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_MENU, |
1255 ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, | 1205 ui::DomCode::ALT_LEFT, ui::EF_ALT_DOWN, |
1256 ui::DomKey::ALT), | 1206 ui::DomKey::ALT), |
1257 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, | 1207 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, |
1258 ui::VKEY_F15, ui::DomCode::F15, | 1208 ui::VKEY_F15, ui::DomCode::F15, |
1259 ui::EF_NONE, ui::DomKey::F15)); | 1209 ui::EF_NONE, ui::DomKey::F15)); |
1260 // Check that Alt is applied to a subsequent key press. | 1210 // Check that Alt is applied to a subsequent key press. |
1261 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, | 1211 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, |
1262 ui::DomCode::US_A, ui::EF_ALT_DOWN, | 1212 ui::DomCode::US_A, ui::EF_ALT_DOWN, |
1263 ui::DomKey::Constant<'a'>::Character), | 1213 ui::DomKey::Constant<'a'>::Character), |
1264 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A, | 1214 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A, |
1265 ui::DomCode::US_A, ui::EF_NONE, | 1215 ui::DomCode::US_A, ui::EF_NONE, |
1266 ui::DomKey::Constant<'a'>::Character)); | 1216 ui::DomKey::Constant<'a'>::Character)); |
1267 // Release F15 | 1217 // Release F15 |
1268 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_MENU, | 1218 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_MENU, |
1269 ui::DomCode::ALT_LEFT, ui::EF_NONE, | 1219 ui::DomCode::ALT_LEFT, ui::EF_NONE, |
1270 ui::DomKey::ALT), | 1220 ui::DomKey::ALT), |
1271 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_RELEASED, | 1221 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_RELEASED, |
1272 ui::VKEY_F15, ui::DomCode::F15, | 1222 ui::VKEY_F15, ui::DomCode::F15, |
1273 ui::EF_NONE, ui::DomKey::F15)); | 1223 ui::EF_NONE, ui::DomKey::F15)); |
1274 // Check that Alt is no longer applied to a subsequent key press. | 1224 // Check that Alt is no longer applied to a subsequent key press. |
1275 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, | 1225 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, |
1276 ui::DomCode::US_A, ui::EF_NONE, | 1226 ui::DomCode::US_A, ui::EF_NONE, |
1277 ui::DomKey::Constant<'a'>::Character), | 1227 ui::DomKey::Constant<'a'>::Character), |
1278 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A, | 1228 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A, |
1279 ui::DomCode::US_A, ui::EF_NONE, | 1229 ui::DomCode::US_A, ui::EF_NONE, |
1280 ui::DomKey::Constant<'a'>::Character)); | 1230 ui::DomKey::Constant<'a'>::Character)); |
1281 | 1231 |
1282 diamond.SetValue(chromeos::input_method::kCapsLockKey); | 1232 diamond.SetValue(chromeos::input_method::kCapsLockKey); |
1283 | 1233 |
1284 EXPECT_EQ(GetExpectedResultAsString( | 1234 EXPECT_EQ(GetExpectedResultAsString( |
1285 ui::ET_KEY_PRESSED, ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK, | 1235 ui::ET_KEY_PRESSED, ui::VKEY_CAPITAL, ui::DomCode::CAPS_LOCK, |
1286 ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN, ui::DomKey::CAPS_LOCK), | 1236 ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN, ui::DomKey::CAPS_LOCK), |
1287 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, | 1237 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, |
1288 ui::VKEY_F15, ui::DomCode::F15, | 1238 ui::VKEY_F15, ui::DomCode::F15, |
1289 ui::EF_NONE, ui::DomKey::F15)); | 1239 ui::EF_NONE, ui::DomKey::F15)); |
1290 // Check that Caps is applied to a subsequent key press. | 1240 // Check that Caps is applied to a subsequent key press. |
1291 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, | 1241 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, |
1292 ui::DomCode::US_A, | 1242 ui::DomCode::US_A, |
1293 ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN, | 1243 ui::EF_CAPS_LOCK_ON | ui::EF_MOD3_DOWN, |
1294 ui::DomKey::Constant<'A'>::Character), | 1244 ui::DomKey::Constant<'A'>::Character), |
1295 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A, | 1245 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A, |
1296 ui::DomCode::US_A, ui::EF_NONE, | 1246 ui::DomCode::US_A, ui::EF_NONE, |
1297 ui::DomKey::Constant<'a'>::Character)); | 1247 ui::DomKey::Constant<'a'>::Character)); |
1298 // Release F15 | 1248 // Release F15 |
1299 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CAPITAL, | 1249 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_RELEASED, ui::VKEY_CAPITAL, |
1300 ui::DomCode::CAPS_LOCK, ui::EF_NONE, | 1250 ui::DomCode::CAPS_LOCK, ui::EF_NONE, |
1301 ui::DomKey::CAPS_LOCK), | 1251 ui::DomKey::CAPS_LOCK), |
1302 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_RELEASED, | 1252 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_RELEASED, |
1303 ui::VKEY_F15, ui::DomCode::F15, | 1253 ui::VKEY_F15, ui::DomCode::F15, |
1304 ui::EF_NONE, ui::DomKey::F15)); | 1254 ui::EF_NONE, ui::DomKey::F15)); |
1305 // Check that Control is no longer applied to a subsequent key press. | 1255 // Check that Control is no longer applied to a subsequent key press. |
1306 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, | 1256 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, |
1307 ui::DomCode::US_A, ui::EF_NONE, | 1257 ui::DomCode::US_A, ui::EF_NONE, |
1308 ui::DomKey::Constant<'a'>::Character), | 1258 ui::DomKey::Constant<'a'>::Character), |
1309 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A, | 1259 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A, |
1310 ui::DomCode::US_A, ui::EF_NONE, | 1260 ui::DomCode::US_A, ui::EF_NONE, |
1311 ui::DomKey::Constant<'a'>::Character)); | 1261 ui::DomKey::Constant<'a'>::Character)); |
1312 | 1262 |
1313 *base::CommandLine::ForCurrentProcess() = original_cl; | 1263 *base::CommandLine::ForCurrentProcess() = original_cl; |
1314 } | 1264 } |
1315 | 1265 |
1316 TEST_F(EventRewriterTest, TestRewriteCapsLockToControl) { | 1266 TEST_F(EventRewriterTest, TestRewriteCapsLockToControl) { |
1317 // Remap CapsLock to Control. | 1267 // Remap CapsLock to Control. |
1318 sync_preferences::TestingPrefServiceSyncable prefs; | 1268 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
1319 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | |
1320 IntegerPrefMember control; | 1269 IntegerPrefMember control; |
1321 control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs); | 1270 control.Init(prefs::kLanguageRemapCapsLockKeyTo, prefs()); |
1322 control.SetValue(chromeos::input_method::kControlKey); | 1271 control.SetValue(chromeos::input_method::kControlKey); |
1323 | 1272 |
1324 EventRewriter rewriter(NULL); | 1273 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
1325 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
1326 rewriter.set_pref_service_for_testing(&prefs); | |
1327 | 1274 |
1328 KeyTestCase tests[] = { | 1275 KeyTestCase tests[] = { |
1329 // Press CapsLock+a. Confirm that Mod3Mask is rewritten to ControlMask. | 1276 // Press CapsLock+a. Confirm that Mod3Mask is rewritten to ControlMask. |
1330 // On Chrome OS, CapsLock works as a Mod3 modifier. | 1277 // On Chrome OS, CapsLock works as a Mod3 modifier. |
1331 {ui::ET_KEY_PRESSED, | 1278 {ui::ET_KEY_PRESSED, |
1332 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_MOD3_DOWN, | 1279 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_MOD3_DOWN, |
1333 ui::DomKey::Constant<'a'>::Character}, | 1280 ui::DomKey::Constant<'a'>::Character}, |
1334 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_CONTROL_DOWN, | 1281 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_CONTROL_DOWN, |
1335 ui::DomKey::Constant<'a'>::Character}}, | 1282 ui::DomKey::Constant<'a'>::Character}}, |
1336 | 1283 |
1337 // Press Control+CapsLock+a. Confirm that Mod3Mask is rewritten to | 1284 // Press Control+CapsLock+a. Confirm that Mod3Mask is rewritten to |
1338 // ControlMask | 1285 // ControlMask |
1339 {ui::ET_KEY_PRESSED, | 1286 {ui::ET_KEY_PRESSED, |
1340 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_CONTROL_DOWN | ui::EF_MOD3_DOWN, | 1287 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_CONTROL_DOWN | ui::EF_MOD3_DOWN, |
1341 ui::DomKey::Constant<'a'>::Character}, | 1288 ui::DomKey::Constant<'a'>::Character}, |
1342 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_CONTROL_DOWN, | 1289 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_CONTROL_DOWN, |
1343 ui::DomKey::Constant<'a'>::Character}}, | 1290 ui::DomKey::Constant<'a'>::Character}}, |
1344 | 1291 |
1345 // Press Alt+CapsLock+a. Confirm that Mod3Mask is rewritten to | 1292 // Press Alt+CapsLock+a. Confirm that Mod3Mask is rewritten to |
1346 // ControlMask. | 1293 // ControlMask. |
1347 {ui::ET_KEY_PRESSED, | 1294 {ui::ET_KEY_PRESSED, |
1348 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN | ui::EF_MOD3_DOWN, | 1295 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN | ui::EF_MOD3_DOWN, |
1349 ui::DomKey::Constant<'a'>::Character}, | 1296 ui::DomKey::Constant<'a'>::Character}, |
1350 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, | 1297 {ui::VKEY_A, ui::DomCode::US_A, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, |
1351 ui::DomKey::Constant<'a'>::Character}}, | 1298 ui::DomKey::Constant<'a'>::Character}}, |
1352 }; | 1299 }; |
1353 | 1300 |
1354 for (const auto& test : tests) { | 1301 for (const auto& test : tests) |
1355 CheckKeyTestCase(&rewriter, test); | 1302 CheckKeyTestCase(rewriter_, test); |
1356 } | |
1357 } | 1303 } |
1358 | 1304 |
1359 TEST_F(EventRewriterTest, TestRewriteCapsLockMod3InUse) { | 1305 TEST_F(EventRewriterTest, TestRewriteCapsLockMod3InUse) { |
1360 // Remap CapsLock to Control. | 1306 // Remap CapsLock to Control. |
1361 sync_preferences::TestingPrefServiceSyncable prefs; | 1307 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
1362 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | |
1363 IntegerPrefMember control; | 1308 IntegerPrefMember control; |
1364 control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs); | 1309 control.Init(prefs::kLanguageRemapCapsLockKeyTo, prefs()); |
1365 control.SetValue(chromeos::input_method::kControlKey); | 1310 control.SetValue(chromeos::input_method::kControlKey); |
1366 | 1311 |
1367 EventRewriter rewriter(NULL); | 1312 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
1368 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
1369 rewriter.set_pref_service_for_testing(&prefs); | |
1370 input_method_manager_mock_->set_mod3_used(true); | 1313 input_method_manager_mock_->set_mod3_used(true); |
1371 | 1314 |
1372 // Press CapsLock+a. Confirm that Mod3Mask is NOT rewritten to ControlMask | 1315 // Press CapsLock+a. Confirm that Mod3Mask is NOT rewritten to ControlMask |
1373 // when Mod3Mask is already in use by the current XKB layout. | 1316 // when Mod3Mask is already in use by the current XKB layout. |
1374 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, | 1317 EXPECT_EQ(GetExpectedResultAsString(ui::ET_KEY_PRESSED, ui::VKEY_A, |
1375 ui::DomCode::US_A, ui::EF_NONE, | 1318 ui::DomCode::US_A, ui::EF_NONE, |
1376 ui::DomKey::Constant<'a'>::Character), | 1319 ui::DomKey::Constant<'a'>::Character), |
1377 GetRewrittenEventAsString(&rewriter, ui::ET_KEY_PRESSED, ui::VKEY_A, | 1320 GetRewrittenEventAsString(rewriter_, ui::ET_KEY_PRESSED, ui::VKEY_A, |
1378 ui::DomCode::US_A, ui::EF_NONE, | 1321 ui::DomCode::US_A, ui::EF_NONE, |
1379 ui::DomKey::Constant<'a'>::Character)); | 1322 ui::DomKey::Constant<'a'>::Character)); |
1380 | 1323 |
1381 input_method_manager_mock_->set_mod3_used(false); | 1324 input_method_manager_mock_->set_mod3_used(false); |
1382 } | 1325 } |
1383 | 1326 |
1384 TEST_F(EventRewriterTest, TestRewriteExtendedKeys) { | 1327 TEST_F(EventRewriterTest, TestRewriteExtendedKeys) { |
1385 sync_preferences::TestingPrefServiceSyncable prefs; | 1328 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
1386 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | 1329 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
1387 EventRewriter rewriter(NULL); | 1330 rewriter_->set_last_keyboard_device_id_for_testing(kKeyboardDeviceId); |
1388 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
1389 rewriter.set_last_keyboard_device_id_for_testing(kKeyboardDeviceId); | |
1390 rewriter.set_pref_service_for_testing(&prefs); | |
1391 | 1331 |
1392 KeyTestCase tests[] = { | 1332 KeyTestCase tests[] = { |
1393 // Alt+Backspace -> Delete | 1333 // Alt+Backspace -> Delete |
1394 {ui::ET_KEY_PRESSED, | 1334 {ui::ET_KEY_PRESSED, |
1395 {ui::VKEY_BACK, ui::DomCode::BACKSPACE, ui::EF_ALT_DOWN, | 1335 {ui::VKEY_BACK, ui::DomCode::BACKSPACE, ui::EF_ALT_DOWN, |
1396 ui::DomKey::BACKSPACE}, | 1336 ui::DomKey::BACKSPACE}, |
1397 {ui::VKEY_DELETE, ui::DomCode::DEL, ui::EF_NONE, ui::DomKey::DEL}}, | 1337 {ui::VKEY_DELETE, ui::DomCode::DEL, ui::EF_NONE, ui::DomKey::DEL}}, |
1398 // Control+Alt+Backspace -> Control+Delete | 1338 // Control+Alt+Backspace -> Control+Delete |
1399 {ui::ET_KEY_PRESSED, | 1339 {ui::ET_KEY_PRESSED, |
1400 {ui::VKEY_BACK, ui::DomCode::BACKSPACE, | 1340 {ui::VKEY_BACK, ui::DomCode::BACKSPACE, |
(...skipping 114 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1515 ui::DomKey::Constant<'.'>::Character}, | 1455 ui::DomKey::Constant<'.'>::Character}, |
1516 {ui::VKEY_INSERT, ui::DomCode::INSERT, ui::EF_NONE, ui::DomKey::INSERT}}, | 1456 {ui::VKEY_INSERT, ui::DomCode::INSERT, ui::EF_NONE, ui::DomKey::INSERT}}, |
1517 // Control+Search+Period -> Control+Insert | 1457 // Control+Search+Period -> Control+Insert |
1518 {ui::ET_KEY_PRESSED, | 1458 {ui::ET_KEY_PRESSED, |
1519 {ui::VKEY_OEM_PERIOD, ui::DomCode::PERIOD, | 1459 {ui::VKEY_OEM_PERIOD, ui::DomCode::PERIOD, |
1520 ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN, | 1460 ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN, |
1521 ui::DomKey::Constant<'.'>::Character}, | 1461 ui::DomKey::Constant<'.'>::Character}, |
1522 {ui::VKEY_INSERT, ui::DomCode::INSERT, ui::EF_CONTROL_DOWN, | 1462 {ui::VKEY_INSERT, ui::DomCode::INSERT, ui::EF_CONTROL_DOWN, |
1523 ui::DomKey::INSERT}}}; | 1463 ui::DomKey::INSERT}}}; |
1524 | 1464 |
1525 for (const auto& test : tests) { | 1465 for (const auto& test : tests) |
1526 CheckKeyTestCase(&rewriter, test); | 1466 CheckKeyTestCase(rewriter_, test); |
1527 } | |
1528 } | 1467 } |
1529 | 1468 |
1530 TEST_F(EventRewriterTest, TestRewriteFunctionKeys) { | 1469 TEST_F(EventRewriterTest, TestRewriteFunctionKeys) { |
1531 sync_preferences::TestingPrefServiceSyncable prefs; | 1470 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
1532 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | 1471 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
1533 EventRewriter rewriter(NULL); | |
1534 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
1535 rewriter.set_pref_service_for_testing(&prefs); | |
1536 | 1472 |
1537 KeyTestCase tests[] = { | 1473 KeyTestCase tests[] = { |
1538 // F1 -> Back | 1474 // F1 -> Back |
1539 {ui::ET_KEY_PRESSED, | 1475 {ui::ET_KEY_PRESSED, |
1540 {ui::VKEY_F1, ui::DomCode::F1, ui::EF_NONE, ui::DomKey::F1}, | 1476 {ui::VKEY_F1, ui::DomCode::F1, ui::EF_NONE, ui::DomKey::F1}, |
1541 {ui::VKEY_BROWSER_BACK, ui::DomCode::BROWSER_BACK, ui::EF_NONE, | 1477 {ui::VKEY_BROWSER_BACK, ui::DomCode::BROWSER_BACK, ui::EF_NONE, |
1542 ui::DomKey::BROWSER_BACK}}, | 1478 ui::DomKey::BROWSER_BACK}}, |
1543 {ui::ET_KEY_PRESSED, | 1479 {ui::ET_KEY_PRESSED, |
1544 {ui::VKEY_F1, ui::DomCode::F1, ui::EF_CONTROL_DOWN, ui::DomKey::F1}, | 1480 {ui::VKEY_F1, ui::DomCode::F1, ui::EF_CONTROL_DOWN, ui::DomKey::F1}, |
1545 {ui::VKEY_BROWSER_BACK, ui::DomCode::BROWSER_BACK, ui::EF_CONTROL_DOWN, | 1481 {ui::VKEY_BROWSER_BACK, ui::DomCode::BROWSER_BACK, ui::EF_CONTROL_DOWN, |
(...skipping 284 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1830 {ui::ET_KEY_PRESSED, | 1766 {ui::ET_KEY_PRESSED, |
1831 {ui::VKEY_F10, ui::DomCode::F10, ui::EF_COMMAND_DOWN, ui::DomKey::F10}, | 1767 {ui::VKEY_F10, ui::DomCode::F10, ui::EF_COMMAND_DOWN, ui::DomKey::F10}, |
1832 {ui::VKEY_F10, ui::DomCode::F10, ui::EF_NONE, ui::DomKey::F10}}, | 1768 {ui::VKEY_F10, ui::DomCode::F10, ui::EF_NONE, ui::DomKey::F10}}, |
1833 {ui::ET_KEY_PRESSED, | 1769 {ui::ET_KEY_PRESSED, |
1834 {ui::VKEY_F11, ui::DomCode::F11, ui::EF_COMMAND_DOWN, ui::DomKey::F11}, | 1770 {ui::VKEY_F11, ui::DomCode::F11, ui::EF_COMMAND_DOWN, ui::DomKey::F11}, |
1835 {ui::VKEY_F11, ui::DomCode::F11, ui::EF_NONE, ui::DomKey::F11}}, | 1771 {ui::VKEY_F11, ui::DomCode::F11, ui::EF_NONE, ui::DomKey::F11}}, |
1836 {ui::ET_KEY_PRESSED, | 1772 {ui::ET_KEY_PRESSED, |
1837 {ui::VKEY_F12, ui::DomCode::F12, ui::EF_COMMAND_DOWN, ui::DomKey::F12}, | 1773 {ui::VKEY_F12, ui::DomCode::F12, ui::EF_COMMAND_DOWN, ui::DomKey::F12}, |
1838 {ui::VKEY_F12, ui::DomCode::F12, ui::EF_NONE, ui::DomKey::F12}}}; | 1774 {ui::VKEY_F12, ui::DomCode::F12, ui::EF_NONE, ui::DomKey::F12}}}; |
1839 | 1775 |
1840 for (const auto& test : tests) { | 1776 for (const auto& test : tests) |
1841 CheckKeyTestCase(&rewriter, test); | 1777 CheckKeyTestCase(rewriter_, test); |
1842 } | |
1843 } | 1778 } |
1844 | 1779 |
1845 TEST_F(EventRewriterTest, TestRewriteExtendedKeysWithSearchRemapped) { | 1780 TEST_F(EventRewriterTest, TestRewriteExtendedKeysWithSearchRemapped) { |
1846 // Remap Search to Control. | 1781 // Remap Search to Control. |
1847 sync_preferences::TestingPrefServiceSyncable prefs; | 1782 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
1848 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | |
1849 IntegerPrefMember search; | 1783 IntegerPrefMember search; |
1850 search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs); | 1784 search.Init(prefs::kLanguageRemapSearchKeyTo, prefs()); |
1851 search.SetValue(chromeos::input_method::kControlKey); | 1785 search.SetValue(chromeos::input_method::kControlKey); |
1852 | 1786 |
1853 EventRewriter rewriter(NULL); | 1787 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
1854 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
1855 rewriter.set_pref_service_for_testing(&prefs); | |
1856 | 1788 |
1857 KeyTestCase tests[] = { | 1789 KeyTestCase tests[] = { |
1858 // Alt+Search+Down -> End | 1790 // Alt+Search+Down -> End |
1859 {ui::ET_KEY_PRESSED, | 1791 {ui::ET_KEY_PRESSED, |
1860 {ui::VKEY_DOWN, ui::DomCode::ARROW_DOWN, | 1792 {ui::VKEY_DOWN, ui::DomCode::ARROW_DOWN, |
1861 ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::DomKey::ARROW_DOWN}, | 1793 ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::DomKey::ARROW_DOWN}, |
1862 {ui::VKEY_END, ui::DomCode::END, ui::EF_NONE, ui::DomKey::END}}, | 1794 {ui::VKEY_END, ui::DomCode::END, ui::EF_NONE, ui::DomKey::END}}, |
1863 | 1795 |
1864 // Shift+Alt+Search+Down -> Shift+End | 1796 // Shift+Alt+Search+Down -> Shift+End |
1865 {ui::ET_KEY_PRESSED, | 1797 {ui::ET_KEY_PRESSED, |
1866 {ui::VKEY_DOWN, ui::DomCode::ARROW_DOWN, | 1798 {ui::VKEY_DOWN, ui::DomCode::ARROW_DOWN, |
1867 ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, | 1799 ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, |
1868 ui::DomKey::ARROW_DOWN}, | 1800 ui::DomKey::ARROW_DOWN}, |
1869 {ui::VKEY_END, ui::DomCode::END, ui::EF_SHIFT_DOWN, ui::DomKey::END}}, | 1801 {ui::VKEY_END, ui::DomCode::END, ui::EF_SHIFT_DOWN, ui::DomKey::END}}, |
1870 }; | 1802 }; |
1871 | 1803 |
1872 for (const auto& test : tests) { | 1804 for (const auto& test : tests) |
1873 CheckKeyTestCase(&rewriter, test); | 1805 CheckKeyTestCase(rewriter_, test); |
1874 } | |
1875 } | 1806 } |
1876 | 1807 |
1877 TEST_F(EventRewriterTest, TestRewriteKeyEventSentByXSendEvent) { | 1808 TEST_F(EventRewriterTest, TestRewriteKeyEventSentByXSendEvent) { |
1878 // Remap Control to Alt. | 1809 // Remap Control to Alt. |
1879 sync_preferences::TestingPrefServiceSyncable prefs; | 1810 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
1880 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | |
1881 IntegerPrefMember control; | 1811 IntegerPrefMember control; |
1882 control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); | 1812 control.Init(prefs::kLanguageRemapControlKeyTo, prefs()); |
1883 control.SetValue(chromeos::input_method::kAltKey); | 1813 control.SetValue(chromeos::input_method::kAltKey); |
1884 | 1814 |
1885 EventRewriter rewriter(NULL); | 1815 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
1886 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
1887 rewriter.set_pref_service_for_testing(&prefs); | |
1888 | 1816 |
1889 // Send left control press. | 1817 // Send left control press. |
1890 { | 1818 { |
1891 ui::KeyEvent keyevent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, | 1819 ui::KeyEvent keyevent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, |
1892 ui::DomCode::CONTROL_LEFT, ui::EF_FINAL, | 1820 ui::DomCode::CONTROL_LEFT, ui::EF_FINAL, |
1893 ui::DomKey::CONTROL, ui::EventTimeForNow()); | 1821 ui::DomKey::CONTROL, ui::EventTimeForNow()); |
1894 std::unique_ptr<ui::Event> new_event; | 1822 std::unique_ptr<ui::Event> new_event; |
1895 // Control should NOT be remapped to Alt if EF_FINAL is set. | 1823 // Control should NOT be remapped to Alt if EF_FINAL is set. |
1896 EXPECT_EQ(ui::EVENT_REWRITE_CONTINUE, | 1824 EXPECT_EQ(ui::EVENT_REWRITE_CONTINUE, |
1897 rewriter.RewriteEvent(keyevent, &new_event)); | 1825 rewriter_->RewriteEvent(keyevent, &new_event)); |
1898 EXPECT_FALSE(new_event); | 1826 EXPECT_FALSE(new_event); |
1899 } | 1827 } |
1900 #if defined(USE_X11) | 1828 #if defined(USE_X11) |
1901 // Send left control press, using XI2 native events. | 1829 // Send left control press, using XI2 native events. |
1902 { | 1830 { |
1903 ui::ScopedXI2Event xev; | 1831 ui::ScopedXI2Event xev; |
1904 xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0); | 1832 xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0); |
1905 XEvent* xevent = xev; | 1833 XEvent* xevent = xev; |
1906 xevent->xkey.keycode = XKeysymToKeycode(gfx::GetXDisplay(), XK_Control_L); | 1834 xevent->xkey.keycode = XKeysymToKeycode(gfx::GetXDisplay(), XK_Control_L); |
1907 xevent->xkey.send_event = True; // XSendEvent() always does this. | 1835 xevent->xkey.send_event = True; // XSendEvent() always does this. |
1908 ui::KeyEvent keyevent(xev); | 1836 ui::KeyEvent keyevent(xev); |
1909 std::unique_ptr<ui::Event> new_event; | 1837 std::unique_ptr<ui::Event> new_event; |
1910 // Control should NOT be remapped to Alt if send_event | 1838 // Control should NOT be remapped to Alt if send_event |
1911 // flag in the event is True. | 1839 // flag in the event is True. |
1912 EXPECT_EQ(ui::EVENT_REWRITE_CONTINUE, | 1840 EXPECT_EQ(ui::EVENT_REWRITE_CONTINUE, |
1913 rewriter.RewriteEvent(keyevent, &new_event)); | 1841 rewriter_->RewriteEvent(keyevent, &new_event)); |
1914 EXPECT_FALSE(new_event); | 1842 EXPECT_FALSE(new_event); |
1915 } | 1843 } |
1916 #endif | 1844 #endif |
1917 } | 1845 } |
1918 | 1846 |
1919 TEST_F(EventRewriterTest, TestRewriteNonNativeEvent) { | 1847 TEST_F(EventRewriterTest, TestRewriteNonNativeEvent) { |
1920 // Remap Control to Alt. | 1848 // Remap Control to Alt. |
1921 sync_preferences::TestingPrefServiceSyncable prefs; | 1849 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
1922 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | |
1923 IntegerPrefMember control; | 1850 IntegerPrefMember control; |
1924 control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); | 1851 control.Init(prefs::kLanguageRemapControlKeyTo, prefs()); |
1925 control.SetValue(chromeos::input_method::kAltKey); | 1852 control.SetValue(chromeos::input_method::kAltKey); |
1926 | 1853 |
1927 EventRewriter rewriter(NULL); | 1854 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
1928 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
1929 rewriter.set_pref_service_for_testing(&prefs); | |
1930 | 1855 |
1931 const int kTouchId = 2; | 1856 const int kTouchId = 2; |
1932 gfx::Point location(0, 0); | 1857 gfx::Point location(0, 0); |
1933 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, location, kTouchId, | 1858 ui::TouchEvent press(ui::ET_TOUCH_PRESSED, location, kTouchId, |
1934 base::TimeTicks()); | 1859 base::TimeTicks()); |
1935 press.set_flags(ui::EF_CONTROL_DOWN); | 1860 press.set_flags(ui::EF_CONTROL_DOWN); |
1936 #if defined(USE_X11) | 1861 #if defined(USE_X11) |
1937 ui::UpdateX11EventForFlags(&press); | 1862 ui::UpdateX11EventForFlags(&press); |
1938 #endif | 1863 #endif |
1939 | 1864 |
1940 std::unique_ptr<ui::Event> new_event; | 1865 std::unique_ptr<ui::Event> new_event; |
1941 rewriter.RewriteEvent(press, &new_event); | 1866 rewriter_->RewriteEvent(press, &new_event); |
1942 EXPECT_TRUE(new_event); | 1867 EXPECT_TRUE(new_event); |
1943 // Control should be remapped to Alt. | 1868 // Control should be remapped to Alt. |
1944 EXPECT_EQ(ui::EF_ALT_DOWN, | 1869 EXPECT_EQ(ui::EF_ALT_DOWN, |
1945 new_event->flags() & (ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN)); | 1870 new_event->flags() & (ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN)); |
1946 } | 1871 } |
1947 | 1872 |
1948 // Keeps a buffer of handled events. | 1873 // Keeps a buffer of handled events. |
1949 class EventBuffer : public ui::test::TestEventProcessor { | 1874 class EventBuffer : public ui::test::TestEventProcessor { |
1950 public: | 1875 public: |
1951 EventBuffer() {} | 1876 EventBuffer() {} |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2021 sync_preferences::TestingPrefServiceSyncable* prefs() { return &prefs_; } | 1946 sync_preferences::TestingPrefServiceSyncable* prefs() { return &prefs_; } |
2022 | 1947 |
2023 void PopEvents(std::vector<std::unique_ptr<ui::Event>>* events) { | 1948 void PopEvents(std::vector<std::unique_ptr<ui::Event>>* events) { |
2024 buffer_.PopEvents(events); | 1949 buffer_.PopEvents(events); |
2025 } | 1950 } |
2026 | 1951 |
2027 void SetUp() override { | 1952 void SetUp() override { |
2028 AshTestBase::SetUp(); | 1953 AshTestBase::SetUp(); |
2029 sticky_keys_controller_ = | 1954 sticky_keys_controller_ = |
2030 ash::Shell::GetInstance()->sticky_keys_controller(); | 1955 ash::Shell::GetInstance()->sticky_keys_controller(); |
2031 rewriter_.reset(new EventRewriter(sticky_keys_controller_)); | 1956 delegate_ = base::MakeUnique<EventRewriterDelegateImpl>(); |
| 1957 delegate_->set_pref_service_for_testing(prefs()); |
| 1958 rewriter_ = base::MakeUnique<ui::EventRewriterChromeOS>( |
| 1959 delegate_.get(), sticky_keys_controller_); |
2032 chromeos::Preferences::RegisterProfilePrefs(prefs_.registry()); | 1960 chromeos::Preferences::RegisterProfilePrefs(prefs_.registry()); |
2033 rewriter_->set_pref_service_for_testing(&prefs_); | |
2034 #if defined(USE_X11) | 1961 #if defined(USE_X11) |
2035 ui::SetUpTouchPadForTest(kTouchPadDeviceId); | 1962 ui::SetUpTouchPadForTest(kTouchPadDeviceId); |
2036 #endif | 1963 #endif |
2037 source_.AddEventRewriter(rewriter_.get()); | 1964 source_.AddEventRewriter(rewriter_.get()); |
2038 sticky_keys_controller_->Enable(true); | 1965 sticky_keys_controller_->Enable(true); |
2039 } | 1966 } |
2040 | 1967 |
2041 void TearDown() override { | 1968 void TearDown() override { |
2042 rewriter_.reset(); | 1969 rewriter_.reset(); |
2043 AshTestBase::TearDown(); | 1970 AshTestBase::TearDown(); |
2044 } | 1971 } |
2045 | 1972 |
2046 protected: | 1973 protected: |
2047 ash::StickyKeysController* sticky_keys_controller_; | 1974 ash::StickyKeysController* sticky_keys_controller_; |
2048 | 1975 |
2049 private: | 1976 private: |
2050 std::unique_ptr<EventRewriter> rewriter_; | 1977 std::unique_ptr<EventRewriterDelegateImpl> delegate_; |
| 1978 std::unique_ptr<ui::EventRewriterChromeOS> rewriter_; |
2051 | 1979 |
2052 EventBuffer buffer_; | 1980 EventBuffer buffer_; |
2053 TestEventSource source_; | 1981 TestEventSource source_; |
2054 | 1982 |
2055 chromeos::FakeChromeUserManager* fake_user_manager_; // Not owned. | 1983 chromeos::FakeChromeUserManager* fake_user_manager_; // Not owned. |
2056 chromeos::ScopedUserManagerEnabler user_manager_enabler_; | 1984 chromeos::ScopedUserManagerEnabler user_manager_enabler_; |
2057 sync_preferences::TestingPrefServiceSyncable prefs_; | 1985 sync_preferences::TestingPrefServiceSyncable prefs_; |
2058 | 1986 |
2059 DISALLOW_COPY_AND_ASSIGN(EventRewriterAshTest); | 1987 DISALLOW_COPY_AND_ASSIGN(EventRewriterAshTest); |
2060 }; | 1988 }; |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2096 GetKeyEventAsString(*static_cast<ui::KeyEvent*>(events[0].get()))); | 2024 GetKeyEventAsString(*static_cast<ui::KeyEvent*>(events[0].get()))); |
2097 } | 2025 } |
2098 | 2026 |
2099 TEST_F(EventRewriterTest, TestRewrittenModifierClick) { | 2027 TEST_F(EventRewriterTest, TestRewrittenModifierClick) { |
2100 #if defined(USE_X11) | 2028 #if defined(USE_X11) |
2101 std::vector<int> device_list; | 2029 std::vector<int> device_list; |
2102 device_list.push_back(10); | 2030 device_list.push_back(10); |
2103 ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list); | 2031 ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list); |
2104 | 2032 |
2105 // Remap Control to Alt. | 2033 // Remap Control to Alt. |
2106 sync_preferences::TestingPrefServiceSyncable prefs; | 2034 chromeos::Preferences::RegisterProfilePrefs(prefs()->registry()); |
2107 chromeos::Preferences::RegisterProfilePrefs(prefs.registry()); | |
2108 IntegerPrefMember control; | 2035 IntegerPrefMember control; |
2109 control.Init(prefs::kLanguageRemapControlKeyTo, &prefs); | 2036 control.Init(prefs::kLanguageRemapControlKeyTo, prefs()); |
2110 control.SetValue(chromeos::input_method::kAltKey); | 2037 control.SetValue(chromeos::input_method::kAltKey); |
2111 | 2038 |
2112 EventRewriter rewriter(NULL); | 2039 rewriter_->KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); |
2113 rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard"); | |
2114 rewriter.set_pref_service_for_testing(&prefs); | |
2115 | 2040 |
2116 // Check that Control + Left Button is converted (via Alt + Left Button) | 2041 // Check that Control + Left Button is converted (via Alt + Left Button) |
2117 // to Right Button. | 2042 // to Right Button. |
2118 ui::ScopedXI2Event xev; | 2043 ui::ScopedXI2Event xev; |
2119 xev.InitGenericButtonEvent(10, ui::ET_MOUSE_PRESSED, gfx::Point(), | 2044 xev.InitGenericButtonEvent(10, ui::ET_MOUSE_PRESSED, gfx::Point(), |
2120 ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN); | 2045 ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN); |
2121 ui::MouseEvent press(xev); | 2046 ui::MouseEvent press(xev); |
2122 // Sanity check. | 2047 // Sanity check. |
2123 EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type()); | 2048 EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type()); |
2124 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN, press.flags()); | 2049 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN, press.flags()); |
2125 std::unique_ptr<ui::Event> new_event; | 2050 std::unique_ptr<ui::Event> new_event; |
2126 const ui::MouseEvent* result = | 2051 const ui::MouseEvent* result = RewriteMouseButtonEvent(press, &new_event); |
2127 RewriteMouseButtonEvent(&rewriter, press, &new_event); | |
2128 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); | 2052 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); |
2129 EXPECT_FALSE(ui::EF_LEFT_MOUSE_BUTTON & result->flags()); | 2053 EXPECT_FALSE(ui::EF_LEFT_MOUSE_BUTTON & result->flags()); |
2130 EXPECT_FALSE(ui::EF_CONTROL_DOWN & result->flags()); | 2054 EXPECT_FALSE(ui::EF_CONTROL_DOWN & result->flags()); |
2131 EXPECT_FALSE(ui::EF_ALT_DOWN & result->flags()); | 2055 EXPECT_FALSE(ui::EF_ALT_DOWN & result->flags()); |
2132 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); | 2056 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); |
2133 #endif | 2057 #endif |
2134 } | 2058 } |
2135 | 2059 |
2136 TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) { | 2060 TEST_F(EventRewriterTest, DontRewriteIfNotRewritten) { |
2137 // TODO(kpschoedel): pending changes for crbug.com/360377 | 2061 // TODO(kpschoedel): pending changes for crbug.com/360377 |
2138 // to |chromeos::EventRewriter::RewriteLocatedEvent() | 2062 // to |ui::EventRewriterChromeOS::RewriteLocatedEvent() |
2139 #if defined(USE_X11) | 2063 #if defined(USE_X11) |
2140 std::vector<int> device_list; | 2064 std::vector<int> device_list; |
2141 device_list.push_back(10); | 2065 device_list.push_back(10); |
2142 device_list.push_back(11); | 2066 device_list.push_back(11); |
2143 ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list); | 2067 ui::TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list); |
2144 #endif | 2068 #endif |
2145 sync_preferences::TestingPrefServiceSyncable prefs; | |
2146 EventRewriter rewriter(NULL); | |
2147 rewriter.set_pref_service_for_testing(&prefs); | |
2148 const int kLeftAndAltFlag = ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN; | 2069 const int kLeftAndAltFlag = ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN; |
2149 | 2070 |
2150 // Test Alt + Left click. | 2071 // Test Alt + Left click. |
2151 { | 2072 { |
2152 ui::MouseEvent press(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(), | 2073 ui::MouseEvent press(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(), |
2153 ui::EventTimeForNow(), kLeftAndAltFlag, | 2074 ui::EventTimeForNow(), kLeftAndAltFlag, |
2154 ui::EF_LEFT_MOUSE_BUTTON); | 2075 ui::EF_LEFT_MOUSE_BUTTON); |
2155 ui::EventTestApi test_press(&press); | 2076 ui::EventTestApi test_press(&press); |
2156 test_press.set_source_device_id(10); | 2077 test_press.set_source_device_id(10); |
2157 // Sanity check. | 2078 // Sanity check. |
2158 EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type()); | 2079 EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type()); |
2159 EXPECT_EQ(kLeftAndAltFlag, press.flags()); | 2080 EXPECT_EQ(kLeftAndAltFlag, press.flags()); |
2160 std::unique_ptr<ui::Event> new_event; | 2081 std::unique_ptr<ui::Event> new_event; |
2161 const ui::MouseEvent* result = | 2082 const ui::MouseEvent* result = RewriteMouseButtonEvent(press, &new_event); |
2162 RewriteMouseButtonEvent(&rewriter, press, &new_event); | |
2163 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); | 2083 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); |
2164 EXPECT_FALSE(kLeftAndAltFlag & result->flags()); | 2084 EXPECT_FALSE(kLeftAndAltFlag & result->flags()); |
2165 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags()); | 2085 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags()); |
2166 } | 2086 } |
2167 { | 2087 { |
2168 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(), | 2088 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(), |
2169 ui::EventTimeForNow(), kLeftAndAltFlag, | 2089 ui::EventTimeForNow(), kLeftAndAltFlag, |
2170 ui::EF_LEFT_MOUSE_BUTTON); | 2090 ui::EF_LEFT_MOUSE_BUTTON); |
2171 ui::EventTestApi test_release(&release); | 2091 ui::EventTestApi test_release(&release); |
2172 test_release.set_source_device_id(10); | 2092 test_release.set_source_device_id(10); |
2173 std::unique_ptr<ui::Event> new_event; | 2093 std::unique_ptr<ui::Event> new_event; |
2174 const ui::MouseEvent* result = | 2094 const ui::MouseEvent* result = RewriteMouseButtonEvent(release, &new_event); |
2175 RewriteMouseButtonEvent(&rewriter, release, &new_event); | |
2176 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); | 2095 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); |
2177 EXPECT_FALSE(kLeftAndAltFlag & result->flags()); | 2096 EXPECT_FALSE(kLeftAndAltFlag & result->flags()); |
2178 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags()); | 2097 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags()); |
2179 } | 2098 } |
2180 #if defined(USE_X11) | 2099 #if defined(USE_X11) |
2181 // Test Alt + Left click, using XI2 native events. | 2100 // Test Alt + Left click, using XI2 native events. |
2182 { | 2101 { |
2183 ui::ScopedXI2Event xev; | 2102 ui::ScopedXI2Event xev; |
2184 xev.InitGenericButtonEvent(10, ui::ET_MOUSE_PRESSED, gfx::Point(), | 2103 xev.InitGenericButtonEvent(10, ui::ET_MOUSE_PRESSED, gfx::Point(), |
2185 kLeftAndAltFlag); | 2104 kLeftAndAltFlag); |
2186 ui::MouseEvent press(xev); | 2105 ui::MouseEvent press(xev); |
2187 // Sanity check. | 2106 // Sanity check. |
2188 EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type()); | 2107 EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type()); |
2189 EXPECT_EQ(kLeftAndAltFlag, press.flags()); | 2108 EXPECT_EQ(kLeftAndAltFlag, press.flags()); |
2190 std::unique_ptr<ui::Event> new_event; | 2109 std::unique_ptr<ui::Event> new_event; |
2191 const ui::MouseEvent* result = | 2110 const ui::MouseEvent* result = RewriteMouseButtonEvent(press, &new_event); |
2192 RewriteMouseButtonEvent(&rewriter, press, &new_event); | |
2193 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); | 2111 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); |
2194 EXPECT_FALSE(kLeftAndAltFlag & result->flags()); | 2112 EXPECT_FALSE(kLeftAndAltFlag & result->flags()); |
2195 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags()); | 2113 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags()); |
2196 } | 2114 } |
2197 { | 2115 { |
2198 ui::ScopedXI2Event xev; | 2116 ui::ScopedXI2Event xev; |
2199 xev.InitGenericButtonEvent(10, ui::ET_MOUSE_RELEASED, gfx::Point(), | 2117 xev.InitGenericButtonEvent(10, ui::ET_MOUSE_RELEASED, gfx::Point(), |
2200 kLeftAndAltFlag); | 2118 kLeftAndAltFlag); |
2201 ui::MouseEvent release(xev); | 2119 ui::MouseEvent release(xev); |
2202 std::unique_ptr<ui::Event> new_event; | 2120 std::unique_ptr<ui::Event> new_event; |
2203 const ui::MouseEvent* result = | 2121 const ui::MouseEvent* result = RewriteMouseButtonEvent(release, &new_event); |
2204 RewriteMouseButtonEvent(&rewriter, release, &new_event); | |
2205 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); | 2122 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); |
2206 EXPECT_FALSE(kLeftAndAltFlag & result->flags()); | 2123 EXPECT_FALSE(kLeftAndAltFlag & result->flags()); |
2207 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags()); | 2124 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags()); |
2208 } | 2125 } |
2209 #endif | 2126 #endif |
2210 | 2127 |
2211 // No ALT in frst click. | 2128 // No ALT in frst click. |
2212 { | 2129 { |
2213 ui::MouseEvent press(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(), | 2130 ui::MouseEvent press(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(), |
2214 ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON, | 2131 ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON, |
2215 ui::EF_LEFT_MOUSE_BUTTON); | 2132 ui::EF_LEFT_MOUSE_BUTTON); |
2216 ui::EventTestApi test_press(&press); | 2133 ui::EventTestApi test_press(&press); |
2217 test_press.set_source_device_id(10); | 2134 test_press.set_source_device_id(10); |
2218 std::unique_ptr<ui::Event> new_event; | 2135 std::unique_ptr<ui::Event> new_event; |
2219 const ui::MouseEvent* result = | 2136 const ui::MouseEvent* result = RewriteMouseButtonEvent(press, &new_event); |
2220 RewriteMouseButtonEvent(&rewriter, press, &new_event); | |
2221 EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & result->flags()); | 2137 EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & result->flags()); |
2222 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags()); | 2138 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags()); |
2223 } | 2139 } |
2224 { | 2140 { |
2225 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(), | 2141 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(), |
2226 ui::EventTimeForNow(), kLeftAndAltFlag, | 2142 ui::EventTimeForNow(), kLeftAndAltFlag, |
2227 ui::EF_LEFT_MOUSE_BUTTON); | 2143 ui::EF_LEFT_MOUSE_BUTTON); |
2228 ui::EventTestApi test_release(&release); | 2144 ui::EventTestApi test_release(&release); |
2229 test_release.set_source_device_id(10); | 2145 test_release.set_source_device_id(10); |
2230 std::unique_ptr<ui::Event> new_event; | 2146 std::unique_ptr<ui::Event> new_event; |
2231 const ui::MouseEvent* result = | 2147 const ui::MouseEvent* result = RewriteMouseButtonEvent(release, &new_event); |
2232 RewriteMouseButtonEvent(&rewriter, release, &new_event); | |
2233 EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & result->flags()); | 2148 EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & result->flags()); |
2234 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags()); | 2149 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags()); |
2235 } | 2150 } |
2236 #if defined(USE_X11) | 2151 #if defined(USE_X11) |
2237 // No ALT in frst click, using XI2 native events. | 2152 // No ALT in frst click, using XI2 native events. |
2238 { | 2153 { |
2239 ui::ScopedXI2Event xev; | 2154 ui::ScopedXI2Event xev; |
2240 xev.InitGenericButtonEvent(10, ui::ET_MOUSE_PRESSED, gfx::Point(), | 2155 xev.InitGenericButtonEvent(10, ui::ET_MOUSE_PRESSED, gfx::Point(), |
2241 ui::EF_LEFT_MOUSE_BUTTON); | 2156 ui::EF_LEFT_MOUSE_BUTTON); |
2242 ui::MouseEvent press(xev); | 2157 ui::MouseEvent press(xev); |
2243 std::unique_ptr<ui::Event> new_event; | 2158 std::unique_ptr<ui::Event> new_event; |
2244 const ui::MouseEvent* result = | 2159 const ui::MouseEvent* result = RewriteMouseButtonEvent(press, &new_event); |
2245 RewriteMouseButtonEvent(&rewriter, press, &new_event); | |
2246 EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & result->flags()); | 2160 EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & result->flags()); |
2247 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags()); | 2161 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags()); |
2248 } | 2162 } |
2249 { | 2163 { |
2250 ui::ScopedXI2Event xev; | 2164 ui::ScopedXI2Event xev; |
2251 xev.InitGenericButtonEvent(10, ui::ET_MOUSE_RELEASED, gfx::Point(), | 2165 xev.InitGenericButtonEvent(10, ui::ET_MOUSE_RELEASED, gfx::Point(), |
2252 kLeftAndAltFlag); | 2166 kLeftAndAltFlag); |
2253 ui::MouseEvent release(xev); | 2167 ui::MouseEvent release(xev); |
2254 std::unique_ptr<ui::Event> new_event; | 2168 std::unique_ptr<ui::Event> new_event; |
2255 const ui::MouseEvent* result = | 2169 const ui::MouseEvent* result = RewriteMouseButtonEvent(release, &new_event); |
2256 RewriteMouseButtonEvent(&rewriter, release, &new_event); | |
2257 EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & result->flags()); | 2170 EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & result->flags()); |
2258 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags()); | 2171 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags()); |
2259 } | 2172 } |
2260 #endif | 2173 #endif |
2261 | 2174 |
2262 // ALT on different device. | 2175 // ALT on different device. |
2263 { | 2176 { |
2264 ui::MouseEvent press(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(), | 2177 ui::MouseEvent press(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(), |
2265 ui::EventTimeForNow(), kLeftAndAltFlag, | 2178 ui::EventTimeForNow(), kLeftAndAltFlag, |
2266 ui::EF_LEFT_MOUSE_BUTTON); | 2179 ui::EF_LEFT_MOUSE_BUTTON); |
2267 ui::EventTestApi test_press(&press); | 2180 ui::EventTestApi test_press(&press); |
2268 test_press.set_source_device_id(11); | 2181 test_press.set_source_device_id(11); |
2269 std::unique_ptr<ui::Event> new_event; | 2182 std::unique_ptr<ui::Event> new_event; |
2270 const ui::MouseEvent* result = | 2183 const ui::MouseEvent* result = RewriteMouseButtonEvent(press, &new_event); |
2271 RewriteMouseButtonEvent(&rewriter, press, &new_event); | |
2272 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); | 2184 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); |
2273 EXPECT_FALSE(kLeftAndAltFlag & result->flags()); | 2185 EXPECT_FALSE(kLeftAndAltFlag & result->flags()); |
2274 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags()); | 2186 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags()); |
2275 } | 2187 } |
2276 { | 2188 { |
2277 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(), | 2189 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(), |
2278 ui::EventTimeForNow(), kLeftAndAltFlag, | 2190 ui::EventTimeForNow(), kLeftAndAltFlag, |
2279 ui::EF_LEFT_MOUSE_BUTTON); | 2191 ui::EF_LEFT_MOUSE_BUTTON); |
2280 ui::EventTestApi test_release(&release); | 2192 ui::EventTestApi test_release(&release); |
2281 test_release.set_source_device_id(10); | 2193 test_release.set_source_device_id(10); |
2282 std::unique_ptr<ui::Event> new_event; | 2194 std::unique_ptr<ui::Event> new_event; |
2283 const ui::MouseEvent* result = | 2195 const ui::MouseEvent* result = RewriteMouseButtonEvent(release, &new_event); |
2284 RewriteMouseButtonEvent(&rewriter, release, &new_event); | |
2285 EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & result->flags()); | 2196 EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & result->flags()); |
2286 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags()); | 2197 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags()); |
2287 } | 2198 } |
2288 { | 2199 { |
2289 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(), | 2200 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(), |
2290 ui::EventTimeForNow(), kLeftAndAltFlag, | 2201 ui::EventTimeForNow(), kLeftAndAltFlag, |
2291 ui::EF_LEFT_MOUSE_BUTTON); | 2202 ui::EF_LEFT_MOUSE_BUTTON); |
2292 ui::EventTestApi test_release(&release); | 2203 ui::EventTestApi test_release(&release); |
2293 test_release.set_source_device_id(11); | 2204 test_release.set_source_device_id(11); |
2294 std::unique_ptr<ui::Event> new_event; | 2205 std::unique_ptr<ui::Event> new_event; |
2295 const ui::MouseEvent* result = | 2206 const ui::MouseEvent* result = RewriteMouseButtonEvent(release, &new_event); |
2296 RewriteMouseButtonEvent(&rewriter, release, &new_event); | |
2297 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); | 2207 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); |
2298 EXPECT_FALSE(kLeftAndAltFlag & result->flags()); | 2208 EXPECT_FALSE(kLeftAndAltFlag & result->flags()); |
2299 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags()); | 2209 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags()); |
2300 } | 2210 } |
2301 #if defined(USE_X11) | 2211 #if defined(USE_X11) |
2302 // ALT on different device, using XI2 native events. | 2212 // ALT on different device, using XI2 native events. |
2303 { | 2213 { |
2304 ui::ScopedXI2Event xev; | 2214 ui::ScopedXI2Event xev; |
2305 xev.InitGenericButtonEvent(11, ui::ET_MOUSE_PRESSED, gfx::Point(), | 2215 xev.InitGenericButtonEvent(11, ui::ET_MOUSE_PRESSED, gfx::Point(), |
2306 kLeftAndAltFlag); | 2216 kLeftAndAltFlag); |
2307 ui::MouseEvent press(xev); | 2217 ui::MouseEvent press(xev); |
2308 std::unique_ptr<ui::Event> new_event; | 2218 std::unique_ptr<ui::Event> new_event; |
2309 const ui::MouseEvent* result = | 2219 const ui::MouseEvent* result = RewriteMouseButtonEvent(press, &new_event); |
2310 RewriteMouseButtonEvent(&rewriter, press, &new_event); | |
2311 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); | 2220 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); |
2312 EXPECT_FALSE(kLeftAndAltFlag & result->flags()); | 2221 EXPECT_FALSE(kLeftAndAltFlag & result->flags()); |
2313 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags()); | 2222 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags()); |
2314 } | 2223 } |
2315 { | 2224 { |
2316 ui::ScopedXI2Event xev; | 2225 ui::ScopedXI2Event xev; |
2317 xev.InitGenericButtonEvent(10, ui::ET_MOUSE_RELEASED, gfx::Point(), | 2226 xev.InitGenericButtonEvent(10, ui::ET_MOUSE_RELEASED, gfx::Point(), |
2318 kLeftAndAltFlag); | 2227 kLeftAndAltFlag); |
2319 ui::MouseEvent release(xev); | 2228 ui::MouseEvent release(xev); |
2320 std::unique_ptr<ui::Event> new_event; | 2229 std::unique_ptr<ui::Event> new_event; |
2321 const ui::MouseEvent* result = | 2230 const ui::MouseEvent* result = RewriteMouseButtonEvent(release, &new_event); |
2322 RewriteMouseButtonEvent(&rewriter, release, &new_event); | |
2323 EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & result->flags()); | 2231 EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & result->flags()); |
2324 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags()); | 2232 EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags()); |
2325 } | 2233 } |
2326 { | 2234 { |
2327 ui::ScopedXI2Event xev; | 2235 ui::ScopedXI2Event xev; |
2328 xev.InitGenericButtonEvent(11, ui::ET_MOUSE_RELEASED, gfx::Point(), | 2236 xev.InitGenericButtonEvent(11, ui::ET_MOUSE_RELEASED, gfx::Point(), |
2329 kLeftAndAltFlag); | 2237 kLeftAndAltFlag); |
2330 ui::MouseEvent release(xev); | 2238 ui::MouseEvent release(xev); |
2331 std::unique_ptr<ui::Event> new_event; | 2239 std::unique_ptr<ui::Event> new_event; |
2332 const ui::MouseEvent* result = | 2240 const ui::MouseEvent* result = RewriteMouseButtonEvent(release, &new_event); |
2333 RewriteMouseButtonEvent(&rewriter, release, &new_event); | |
2334 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); | 2241 EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags()); |
2335 EXPECT_FALSE(kLeftAndAltFlag & result->flags()); | 2242 EXPECT_FALSE(kLeftAndAltFlag & result->flags()); |
2336 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags()); | 2243 EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags()); |
2337 } | 2244 } |
2338 #endif | 2245 #endif |
2339 } | 2246 } |
2340 | 2247 |
2341 TEST_F(EventRewriterAshTest, StickyKeyEventDispatchImpl) { | 2248 TEST_F(EventRewriterAshTest, StickyKeyEventDispatchImpl) { |
2342 // Test the actual key event dispatch implementation. | 2249 // Test the actual key event dispatch implementation. |
2343 std::vector<std::unique_ptr<ui::Event>> events; | 2250 std::vector<std::unique_ptr<ui::Event>> events; |
(...skipping 347 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2691 EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN)); | 2598 EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN)); |
2692 EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN)); | 2599 EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN)); |
2693 | 2600 |
2694 // Turn off AltGr and Mod3. | 2601 // Turn off AltGr and Mod3. |
2695 sticky_keys_controller_->SetModifiersEnabled(false, false); | 2602 sticky_keys_controller_->SetModifiersEnabled(false, false); |
2696 EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN)); | 2603 EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN)); |
2697 EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN)); | 2604 EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN)); |
2698 } | 2605 } |
2699 | 2606 |
2700 } // namespace chromeos | 2607 } // namespace chromeos |
OLD | NEW |