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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: chrome/browser/ui/views/ash/key_rewriter_unittest.cc

Issue 10383301: Move modifier remapping code from X to Ash (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: reverted ui/base/keycodes/keyboard_code_conversion_x.cc (this was just for debugging) Created 8 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « chrome/browser/ui/views/ash/key_rewriter.cc ('k') | chrome/chrome_browser.gypi » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 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 "base/basictypes.h" 5 #include "base/basictypes.h"
6 #include "base/stringprintf.h"
7 #include "chrome/browser/prefs/pref_member.h"
6 #include "chrome/browser/ui/views/ash/key_rewriter.h" 8 #include "chrome/browser/ui/views/ash/key_rewriter.h"
9 #include "chrome/common/pref_names.h"
10 #include "chrome/test/base/testing_pref_service.h"
7 #include "testing/gtest/include/gtest/gtest.h" 11 #include "testing/gtest/include/gtest/gtest.h"
8 #include "ui/aura/event.h" 12 #include "ui/aura/event.h"
9 13
10 #if defined(OS_CHROMEOS) 14 #if defined(OS_CHROMEOS)
11 #include <X11/keysym.h> 15 #include <X11/keysym.h>
12 #include <X11/Xlib.h> 16 #include <X11/Xlib.h>
13 17
18 #include "chrome/browser/chromeos/input_method/mock_xkeyboard.h"
19 #include "chrome/browser/chromeos/preferences.h"
14 #include "ui/base/x/x11_util.h" 20 #include "ui/base/x/x11_util.h"
15 21
16 namespace { 22 namespace {
17 23
18 void InitXKeyEvent(ui::KeyboardCode ui_keycode, 24 void InitXKeyEvent(ui::KeyboardCode ui_keycode,
19 int ui_flags, 25 int ui_flags,
20 unsigned int x_keycode, 26 ui::EventType ui_type,
27 KeyCode x_keycode,
21 unsigned int x_state, 28 unsigned int x_state,
22 XEvent* event) { 29 XEvent* event) {
23 ui::InitXKeyEventForTesting(ui::ET_KEY_PRESSED, 30 ui::InitXKeyEventForTesting(ui_type,
24 ui_keycode, 31 ui_keycode,
25 ui_flags, 32 ui_flags,
26 event); 33 event);
27 event->xkey.keycode = x_keycode; 34 event->xkey.keycode = x_keycode;
28 event->xkey.state = x_state; 35 event->xkey.state = x_state;
29 } 36 }
30 37
38 std::string GetRewrittenEventAsString(KeyRewriter* rewriter,
39 ui::KeyboardCode ui_keycode,
40 int ui_flags,
41 ui::EventType ui_type,
42 KeyCode x_keycode,
43 unsigned int x_state) {
44 XEvent xev;
45 InitXKeyEvent(ui_keycode, ui_flags, ui_type, x_keycode, x_state, &xev);
46 aura::KeyEvent keyevent(&xev, false /* is_char */);
47 rewriter->RewriteForTesting(&keyevent);
48 return StringPrintf(
49 "ui_keycode=%d ui_flags=%d ui_type=%d x_keycode=%u x_state=%u x_type=%d",
50 keyevent.key_code(), keyevent.flags(), keyevent.type(),
51 xev.xkey.keycode, xev.xkey.state, xev.xkey.type);
52 }
53
54 std::string GetExpectedResultAsString(ui::KeyboardCode ui_keycode,
55 int ui_flags,
56 ui::EventType ui_type,
57 KeyCode x_keycode,
58 unsigned int x_state,
59 int x_type) {
60 return StringPrintf(
61 "ui_keycode=%d ui_flags=%d ui_type=%d x_keycode=%u x_state=%u x_type=%d",
62 ui_keycode, ui_flags, ui_type, x_keycode, x_state, x_type);
63 }
64
65 class KeyRewriterTest : public testing::Test {
66 public:
67 KeyRewriterTest()
68 : display_(ui::GetXDisplay()),
69 keycode_a_(XKeysymToKeycode(display_, XK_a)),
70 keycode_alt_l_(XKeysymToKeycode(display_, XK_Alt_L)),
71 keycode_alt_r_(XKeysymToKeycode(display_, XK_Alt_R)),
72 keycode_b_(XKeysymToKeycode(display_, XK_B)),
73 keycode_caps_lock_(XKeysymToKeycode(display_, XK_Caps_Lock)),
74 keycode_control_l_(XKeysymToKeycode(display_, XK_Control_L)),
75 keycode_control_r_(XKeysymToKeycode(display_, XK_Control_R)),
76 keycode_meta_l_(XKeysymToKeycode(display_, XK_Meta_L)),
77 keycode_meta_r_(XKeysymToKeycode(display_, XK_Meta_R)),
78 keycode_num_pad_0_(XKeysymToKeycode(display_, XK_KP_0)),
79 keycode_num_pad_1_(XKeysymToKeycode(display_, XK_KP_1)),
80 keycode_num_pad_2_(XKeysymToKeycode(display_, XK_KP_2)),
81 keycode_num_pad_3_(XKeysymToKeycode(display_, XK_KP_3)),
82 keycode_num_pad_4_(XKeysymToKeycode(display_, XK_KP_4)),
83 keycode_num_pad_5_(XKeysymToKeycode(display_, XK_KP_5)),
84 keycode_num_pad_6_(XKeysymToKeycode(display_, XK_KP_6)),
85 keycode_num_pad_7_(XKeysymToKeycode(display_, XK_KP_7)),
86 keycode_num_pad_8_(XKeysymToKeycode(display_, XK_KP_8)),
87 keycode_num_pad_9_(XKeysymToKeycode(display_, XK_KP_9)),
88 keycode_num_pad_begin_(XKeysymToKeycode(display_, XK_KP_Begin)),
89 keycode_num_pad_decimal_(XKeysymToKeycode(display_, XK_KP_Decimal)),
90 keycode_num_pad_delete_(XKeysymToKeycode(display_, XK_KP_Delete)),
91 keycode_num_pad_down_(XKeysymToKeycode(display_, XK_KP_Down)),
92 keycode_num_pad_end_(XKeysymToKeycode(display_, XK_KP_End)),
93 keycode_num_pad_home_(XKeysymToKeycode(display_, XK_KP_Home)),
94 keycode_num_pad_insert_(XKeysymToKeycode(display_, XK_KP_Insert)),
95 keycode_num_pad_left_(XKeysymToKeycode(display_, XK_KP_Left)),
96 keycode_num_pad_next_(XKeysymToKeycode(display_, XK_KP_Next)),
97 keycode_num_pad_prior_(XKeysymToKeycode(display_, XK_KP_Prior)),
98 keycode_num_pad_right_(XKeysymToKeycode(display_, XK_KP_Right)),
99 keycode_num_pad_up_(XKeysymToKeycode(display_, XK_KP_Up)),
100 keycode_super_l_(XKeysymToKeycode(display_, XK_Super_L)),
101 keycode_super_r_(XKeysymToKeycode(display_, XK_Super_R)),
102 keycode_void_symbol_(XKeysymToKeycode(display_, XK_VoidSymbol)) {
103 }
104 virtual ~KeyRewriterTest() {}
105
106 protected:
107 Display* display_;
108 const KeyCode keycode_a_;
109 const KeyCode keycode_alt_l_;
110 const KeyCode keycode_alt_r_;
111 const KeyCode keycode_b_;
112 const KeyCode keycode_caps_lock_;
113 const KeyCode keycode_control_l_;
114 const KeyCode keycode_control_r_;
115 const KeyCode keycode_meta_l_;
116 const KeyCode keycode_meta_r_;
117 const KeyCode keycode_num_pad_0_;
118 const KeyCode keycode_num_pad_1_;
119 const KeyCode keycode_num_pad_2_;
120 const KeyCode keycode_num_pad_3_;
121 const KeyCode keycode_num_pad_4_;
122 const KeyCode keycode_num_pad_5_;
123 const KeyCode keycode_num_pad_6_;
124 const KeyCode keycode_num_pad_7_;
125 const KeyCode keycode_num_pad_8_;
126 const KeyCode keycode_num_pad_9_;
127 const KeyCode keycode_num_pad_begin_;
128 const KeyCode keycode_num_pad_decimal_;
129 const KeyCode keycode_num_pad_delete_;
130 const KeyCode keycode_num_pad_down_;
131 const KeyCode keycode_num_pad_end_;
132 const KeyCode keycode_num_pad_home_;
133 const KeyCode keycode_num_pad_insert_;
134 const KeyCode keycode_num_pad_left_;
135 const KeyCode keycode_num_pad_next_;
136 const KeyCode keycode_num_pad_prior_;
137 const KeyCode keycode_num_pad_right_;
138 const KeyCode keycode_num_pad_up_;
139 const KeyCode keycode_super_l_;
140 const KeyCode keycode_super_r_;
141 const KeyCode keycode_void_symbol_;
142 };
143
31 } // namespace 144 } // namespace
32 #endif 145 #endif
33 146
34 TEST(KeyRewriterTest, TestGetDeviceType) { 147 TEST_F(KeyRewriterTest, TestGetDeviceType) {
35 // This is the typical string which an Apple keyboard sends. 148 // This is the typical string which an Apple keyboard sends.
36 EXPECT_EQ(KeyRewriter::kDeviceAppleKeyboard, 149 EXPECT_EQ(KeyRewriter::kDeviceAppleKeyboard,
37 KeyRewriter::GetDeviceType("Apple Inc. Apple Keyboard")); 150 KeyRewriter::GetDeviceType("Apple Inc. Apple Keyboard"));
38 151
39 // Other cases we accept. 152 // Other cases we accept.
40 EXPECT_EQ(KeyRewriter::kDeviceAppleKeyboard, 153 EXPECT_EQ(KeyRewriter::kDeviceAppleKeyboard,
41 KeyRewriter::GetDeviceType("Apple Keyboard")); 154 KeyRewriter::GetDeviceType("Apple Keyboard"));
42 EXPECT_EQ(KeyRewriter::kDeviceAppleKeyboard, 155 EXPECT_EQ(KeyRewriter::kDeviceAppleKeyboard,
43 KeyRewriter::GetDeviceType("apple keyboard")); 156 KeyRewriter::GetDeviceType("apple keyboard"));
44 EXPECT_EQ(KeyRewriter::kDeviceAppleKeyboard, 157 EXPECT_EQ(KeyRewriter::kDeviceAppleKeyboard,
(...skipping 16 matching lines...) Expand all
61 EXPECT_EQ(KeyRewriter::kDeviceUnknown, 174 EXPECT_EQ(KeyRewriter::kDeviceUnknown,
62 KeyRewriter::GetDeviceType(".")); 175 KeyRewriter::GetDeviceType("."));
63 EXPECT_EQ(KeyRewriter::kDeviceUnknown, 176 EXPECT_EQ(KeyRewriter::kDeviceUnknown,
64 KeyRewriter::GetDeviceType(". ")); 177 KeyRewriter::GetDeviceType(". "));
65 EXPECT_EQ(KeyRewriter::kDeviceUnknown, 178 EXPECT_EQ(KeyRewriter::kDeviceUnknown,
66 KeyRewriter::GetDeviceType(" .")); 179 KeyRewriter::GetDeviceType(" ."));
67 EXPECT_EQ(KeyRewriter::kDeviceUnknown, 180 EXPECT_EQ(KeyRewriter::kDeviceUnknown,
68 KeyRewriter::GetDeviceType("not-an-apple keyboard")); 181 KeyRewriter::GetDeviceType("not-an-apple keyboard"));
69 } 182 }
70 183
71 TEST(KeyRewriterTest, TestDeviceAddedOrRemoved) { 184 TEST_F(KeyRewriterTest, TestDeviceAddedOrRemoved) {
72 KeyRewriter rewriter; 185 KeyRewriter rewriter;
73 EXPECT_TRUE(rewriter.device_id_to_type_for_testing().empty()); 186 EXPECT_TRUE(rewriter.device_id_to_type_for_testing().empty());
74 EXPECT_EQ(KeyRewriter::kDeviceUnknown, 187 EXPECT_EQ(KeyRewriter::kDeviceUnknown,
75 rewriter.DeviceAddedForTesting(0, "PC Keyboard")); 188 rewriter.DeviceAddedForTesting(0, "PC Keyboard"));
76 EXPECT_EQ(1U, rewriter.device_id_to_type_for_testing().size()); 189 EXPECT_EQ(1U, rewriter.device_id_to_type_for_testing().size());
77 EXPECT_EQ(KeyRewriter::kDeviceAppleKeyboard, 190 EXPECT_EQ(KeyRewriter::kDeviceAppleKeyboard,
78 rewriter.DeviceAddedForTesting(1, "Apple Keyboard")); 191 rewriter.DeviceAddedForTesting(1, "Apple Keyboard"));
79 EXPECT_EQ(2U, rewriter.device_id_to_type_for_testing().size()); 192 EXPECT_EQ(2U, rewriter.device_id_to_type_for_testing().size());
80 // Try to reuse the first ID. 193 // Try to reuse the first ID.
81 EXPECT_EQ(KeyRewriter::kDeviceAppleKeyboard, 194 EXPECT_EQ(KeyRewriter::kDeviceAppleKeyboard,
82 rewriter.DeviceAddedForTesting(0, "Apple Keyboard")); 195 rewriter.DeviceAddedForTesting(0, "Apple Keyboard"));
83 EXPECT_EQ(2U, rewriter.device_id_to_type_for_testing().size()); 196 EXPECT_EQ(2U, rewriter.device_id_to_type_for_testing().size());
84 } 197 }
85 198
86 #if defined(OS_CHROMEOS) 199 #if defined(OS_CHROMEOS)
87 TEST(KeyRewriterTest, TestRewriteCommandToControl) { 200 TEST_F(KeyRewriterTest, TestRewriteCommandToControl) {
88 XEvent xev;
89
90 const unsigned int kKeycodeA =
91 XKeysymToKeycode(ui::GetXDisplay(), XK_a);
92 const unsigned int kKeycodeSuperL =
93 XKeysymToKeycode(ui::GetXDisplay(), XK_Super_L);
94 const unsigned int kKeycodeSuperR =
95 XKeysymToKeycode(ui::GetXDisplay(), XK_Super_R);
96 const unsigned int kKeycodeControlL =
97 XKeysymToKeycode(ui::GetXDisplay(), XK_Control_L);
98 const unsigned int kKeycodeControlR =
99 XKeysymToKeycode(ui::GetXDisplay(), XK_Control_R);
100
101 // First, test with a PC keyboard. 201 // First, test with a PC keyboard.
202 TestingPrefService prefs;
102 KeyRewriter rewriter; 203 KeyRewriter rewriter;
103 rewriter.DeviceAddedForTesting(0, "PC Keyboard"); 204 rewriter.DeviceAddedForTesting(0, "PC Keyboard");
104 rewriter.set_last_device_id_for_testing(0); 205 rewriter.set_last_device_id_for_testing(0);
105 { 206 rewriter.set_pref_service_for_testing(&prefs);
106 // XK_a, Alt modifier. 207
107 InitXKeyEvent(ui::VKEY_A, ui::EF_ALT_DOWN, kKeycodeA, Mod1Mask, &xev); 208 // XK_a, Alt modifier.
108 aura::KeyEvent keyevent(&xev, false /* is_char */); 209 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
109 rewriter.RewriteForTesting(&keyevent); 210 ui::EF_ALT_DOWN,
110 EXPECT_EQ(ui::VKEY_A, keyevent.key_code()); 211 ui::ET_KEY_PRESSED,
111 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 212 keycode_a_,
112 const XKeyEvent& xkey = keyevent.native_event()->xkey; 213 Mod1Mask,
113 EXPECT_EQ(kKeycodeA, xkey.keycode); 214 KeyPress),
114 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask), xkey.state); 215 GetRewrittenEventAsString(&rewriter,
115 } 216 ui::VKEY_A,
116 { 217 ui::EF_ALT_DOWN,
117 // XK_a, Win modifier. 218 ui::ET_KEY_PRESSED,
118 InitXKeyEvent(ui::VKEY_A, 0, kKeycodeA, Mod4Mask, &xev); 219 keycode_a_,
119 aura::KeyEvent keyevent(&xev, false /* is_char */); 220 Mod1Mask));
120 rewriter.RewriteForTesting(&keyevent); 221
121 EXPECT_EQ(ui::VKEY_A, keyevent.key_code()); 222 // XK_a, Win modifier.
122 EXPECT_EQ(0, keyevent.flags()); 223 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
123 const XKeyEvent& xkey = keyevent.native_event()->xkey; 224 0,
124 EXPECT_EQ(kKeycodeA, xkey.keycode); 225 ui::ET_KEY_PRESSED,
125 EXPECT_EQ(static_cast<unsigned int>(Mod4Mask), xkey.state); 226 keycode_a_,
126 } 227 Mod4Mask,
127 { 228 KeyPress),
128 // XK_a, Alt+Win modifier. 229 GetRewrittenEventAsString(&rewriter,
129 InitXKeyEvent(ui::VKEY_A, ui::EF_ALT_DOWN, 230 ui::VKEY_A,
130 kKeycodeA, Mod1Mask | Mod4Mask, &xev); 231 0,
131 aura::KeyEvent keyevent(&xev, false /* is_char */); 232 ui::ET_KEY_PRESSED,
132 rewriter.RewriteForTesting(&keyevent); 233 keycode_a_,
133 EXPECT_EQ(ui::VKEY_A, keyevent.key_code()); 234 Mod4Mask));
134 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 235
135 const XKeyEvent& xkey = keyevent.native_event()->xkey; 236 // XK_a, Alt+Win modifier.
136 EXPECT_EQ(kKeycodeA, xkey.keycode); 237 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
137 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod4Mask), xkey.state); 238 ui::EF_ALT_DOWN,
138 } 239 ui::ET_KEY_PRESSED,
139 { 240 keycode_a_,
140 // XK_Super_L (left Windows key), Alt modifier. 241 Mod1Mask | Mod4Mask,
141 InitXKeyEvent(ui::VKEY_LWIN, ui::EF_ALT_DOWN, 242 KeyPress),
142 kKeycodeSuperL, Mod1Mask, &xev); 243 GetRewrittenEventAsString(&rewriter,
143 aura::KeyEvent keyevent(&xev, false /* is_char */); 244 ui::VKEY_A,
144 rewriter.RewriteForTesting(&keyevent); 245 ui::EF_ALT_DOWN,
145 EXPECT_EQ(ui::VKEY_LWIN, keyevent.key_code()); 246 ui::ET_KEY_PRESSED,
146 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 247 keycode_a_,
147 const XKeyEvent& xkey = keyevent.native_event()->xkey; 248 Mod1Mask | Mod4Mask));
148 EXPECT_EQ(kKeycodeSuperL, xkey.keycode); 249
149 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask), xkey.state); 250 // XK_Super_L (left Windows key), Alt modifier.
150 } 251 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_LWIN,
151 { 252 ui::EF_ALT_DOWN,
152 // XK_Super_R (right Windows key), Alt modifier. 253 ui::ET_KEY_PRESSED,
153 InitXKeyEvent(ui::VKEY_RWIN, ui::EF_ALT_DOWN, 254 keycode_super_l_,
154 kKeycodeSuperR, Mod1Mask, &xev); 255 Mod1Mask,
155 aura::KeyEvent keyevent(&xev, false /* is_char */); 256 KeyPress),
156 rewriter.RewriteForTesting(&keyevent); 257 GetRewrittenEventAsString(&rewriter,
157 EXPECT_EQ(ui::VKEY_RWIN, keyevent.key_code()); 258 ui::VKEY_LWIN,
158 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 259 ui::EF_ALT_DOWN,
159 const XKeyEvent& xkey = keyevent.native_event()->xkey; 260 ui::ET_KEY_PRESSED,
160 EXPECT_EQ(kKeycodeSuperR, xkey.keycode); 261 keycode_super_l_,
161 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask), xkey.state); 262 Mod1Mask));
162 } 263
264 // XK_Super_R (right Windows key), Alt modifier.
265 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_RWIN,
266 ui::EF_ALT_DOWN,
267 ui::ET_KEY_PRESSED,
268 keycode_super_r_,
269 Mod1Mask,
270 KeyPress),
271 GetRewrittenEventAsString(&rewriter,
272 ui::VKEY_RWIN,
273 ui::EF_ALT_DOWN,
274 ui::ET_KEY_PRESSED,
275 keycode_super_r_,
276 Mod1Mask));
163 277
164 // An Apple keyboard reuse the ID, zero. 278 // An Apple keyboard reuse the ID, zero.
165 rewriter.DeviceAddedForTesting(0, "Apple Keyboard"); 279 rewriter.DeviceAddedForTesting(0, "Apple Keyboard");
166 rewriter.set_last_device_id_for_testing(0); 280 rewriter.set_last_device_id_for_testing(0);
167 { 281
168 // XK_a, Alt modifier. 282 // XK_a, Alt modifier.
169 InitXKeyEvent(ui::VKEY_A, ui::EF_ALT_DOWN, kKeycodeA, Mod1Mask, &xev); 283 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
170 aura::KeyEvent keyevent(&xev, false /* is_char */); 284 ui::EF_ALT_DOWN,
171 rewriter.RewriteForTesting(&keyevent); 285 ui::ET_KEY_PRESSED,
172 EXPECT_EQ(ui::VKEY_A, keyevent.key_code()); 286 keycode_a_,
173 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 287 Mod1Mask,
174 const XKeyEvent& xkey = keyevent.native_event()->xkey; 288 KeyPress),
175 EXPECT_EQ(kKeycodeA, xkey.keycode); 289 GetRewrittenEventAsString(&rewriter,
176 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask), xkey.state); 290 ui::VKEY_A,
177 } 291 ui::EF_ALT_DOWN,
178 { 292 ui::ET_KEY_PRESSED,
179 // XK_a, Win modifier. 293 keycode_a_,
180 InitXKeyEvent(ui::VKEY_A, 0, kKeycodeA, Mod4Mask, &xev); 294 Mod1Mask));
181 aura::KeyEvent keyevent(&xev, false /* is_char */); 295
182 rewriter.RewriteForTesting(&keyevent); 296 // XK_a, Win modifier.
183 EXPECT_EQ(ui::VKEY_A, keyevent.key_code()); 297 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
184 EXPECT_EQ(ui::EF_CONTROL_DOWN, keyevent.flags()); 298 ui::EF_CONTROL_DOWN,
185 const XKeyEvent& xkey = keyevent.native_event()->xkey; 299 ui::ET_KEY_PRESSED,
186 EXPECT_EQ(kKeycodeA, xkey.keycode); 300 keycode_a_,
187 EXPECT_EQ(static_cast<unsigned int>(ControlMask), xkey.state); 301 ControlMask,
188 } 302 KeyPress),
189 { 303 GetRewrittenEventAsString(&rewriter,
190 // XK_a, Alt+Win modifier. 304 ui::VKEY_A,
191 InitXKeyEvent(ui::VKEY_A, ui::EF_ALT_DOWN, 305 0,
192 kKeycodeA, Mod1Mask | Mod4Mask, &xev); 306 ui::ET_KEY_PRESSED,
193 aura::KeyEvent keyevent(&xev, false /* is_char */); 307 keycode_a_,
194 rewriter.RewriteForTesting(&keyevent); 308 Mod4Mask));
195 EXPECT_EQ(ui::VKEY_A, keyevent.key_code()); 309
196 EXPECT_EQ(ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, keyevent.flags()); 310 // XK_a, Alt+Win modifier.
197 const XKeyEvent& xkey = keyevent.native_event()->xkey; 311 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
198 EXPECT_EQ(kKeycodeA, xkey.keycode); 312 ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN,
199 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | ControlMask), xkey.state); 313 ui::ET_KEY_PRESSED,
200 } 314 keycode_a_,
201 { 315 Mod1Mask | ControlMask,
202 // XK_Super_L (left Windows key), Alt modifier. 316 KeyPress),
203 InitXKeyEvent(ui::VKEY_LWIN, ui::EF_ALT_DOWN, 317 GetRewrittenEventAsString(&rewriter,
204 kKeycodeSuperL, Mod1Mask, &xev); 318 ui::VKEY_A,
205 aura::KeyEvent keyevent(&xev, false /* is_char */); 319 ui::EF_ALT_DOWN,
206 rewriter.RewriteForTesting(&keyevent); 320 ui::ET_KEY_PRESSED,
207 EXPECT_EQ(ui::VKEY_CONTROL, keyevent.key_code()); 321 keycode_a_,
208 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 322 Mod1Mask | Mod4Mask));
209 const XKeyEvent& xkey = keyevent.native_event()->xkey; 323
210 EXPECT_EQ(kKeycodeControlL, xkey.keycode); 324 // XK_Super_L (left Windows key), Alt modifier.
211 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask), xkey.state); 325 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
212 } 326 ui::EF_ALT_DOWN,
213 { 327 ui::ET_KEY_PRESSED,
214 // XK_Super_R (right Windows key), Alt modifier. 328 keycode_control_l_,
215 InitXKeyEvent(ui::VKEY_RWIN, ui::EF_ALT_DOWN, 329 Mod1Mask,
216 kKeycodeSuperR, Mod1Mask, &xev); 330 KeyPress),
217 aura::KeyEvent keyevent(&xev, false /* is_char */); 331 GetRewrittenEventAsString(&rewriter,
218 rewriter.RewriteForTesting(&keyevent); 332 ui::VKEY_LWIN,
219 EXPECT_EQ(ui::VKEY_CONTROL, keyevent.key_code()); 333 ui::EF_ALT_DOWN,
220 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 334 ui::ET_KEY_PRESSED,
221 const XKeyEvent& xkey = keyevent.native_event()->xkey; 335 keycode_super_l_,
222 EXPECT_EQ(kKeycodeControlR, xkey.keycode); 336 Mod1Mask));
223 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask), xkey.state); 337
224 } 338 // XK_Super_R (right Windows key), Alt modifier.
339 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
340 ui::EF_ALT_DOWN,
341 ui::ET_KEY_PRESSED,
342 keycode_control_r_,
343 Mod1Mask,
344 KeyPress),
345 GetRewrittenEventAsString(&rewriter,
346 ui::VKEY_RWIN,
347 ui::EF_ALT_DOWN,
348 ui::ET_KEY_PRESSED,
349 keycode_super_r_,
350 Mod1Mask));
225 } 351 }
226 352
227 TEST(KeyRewriterTest, TestRewriteNumPadKeys) { 353 TEST_F(KeyRewriterTest, TestRewriteNumPadKeys) {
228 XEvent xev; 354 TestingPrefService prefs;
229 Display* display = ui::GetXDisplay();
230
231 const unsigned int kKeycodeNumPad0 = XKeysymToKeycode(display, XK_KP_0);
232 const unsigned int kKeycodeNumPadDecimal =
233 XKeysymToKeycode(display, XK_KP_Decimal);
234 const unsigned int kKeycodeNumPad1 = XKeysymToKeycode(display, XK_KP_1);
235 const unsigned int kKeycodeNumPad2 = XKeysymToKeycode(display, XK_KP_2);
236 const unsigned int kKeycodeNumPad3 = XKeysymToKeycode(display, XK_KP_3);
237 const unsigned int kKeycodeNumPad4 = XKeysymToKeycode(display, XK_KP_4);
238 const unsigned int kKeycodeNumPad5 = XKeysymToKeycode(display, XK_KP_5);
239 const unsigned int kKeycodeNumPad6 = XKeysymToKeycode(display, XK_KP_6);
240 const unsigned int kKeycodeNumPad7 = XKeysymToKeycode(display, XK_KP_7);
241 const unsigned int kKeycodeNumPad8 = XKeysymToKeycode(display, XK_KP_8);
242 const unsigned int kKeycodeNumPad9 = XKeysymToKeycode(display, XK_KP_9);
243
244 const unsigned int kKeycodeNumPadInsert =
245 XKeysymToKeycode(display, XK_KP_Insert);
246 const unsigned int kKeycodeNumPadDelete =
247 XKeysymToKeycode(display, XK_KP_Delete);
248 const unsigned int kKeycodeNumPadEnd = XKeysymToKeycode(display, XK_KP_End);
249 const unsigned int kKeycodeNumPadDown = XKeysymToKeycode(display, XK_KP_Down);
250 const unsigned int kKeycodeNumPadNext = XKeysymToKeycode(display, XK_KP_Next);
251 const unsigned int kKeycodeNumPadLeft = XKeysymToKeycode(display, XK_KP_Left);
252 const unsigned int kKeycodeNumPadBegin =
253 XKeysymToKeycode(display, XK_KP_Begin);
254 const unsigned int kKeycodeNumPadRight =
255 XKeysymToKeycode(display, XK_KP_Right);
256 const unsigned int kKeycodeNumPadHome = XKeysymToKeycode(display, XK_KP_Home);
257 const unsigned int kKeycodeNumPadUp = XKeysymToKeycode(display, XK_KP_Up);
258 const unsigned int kKeycodeNumPadPrior =
259 XKeysymToKeycode(display, XK_KP_Prior);
260
261 KeyRewriter rewriter; 355 KeyRewriter rewriter;
262 { 356 rewriter.set_pref_service_for_testing(&prefs);
263 // XK_KP_Insert (= NumPad 0 without Num Lock), no modifier. 357
264 InitXKeyEvent(ui::VKEY_INSERT, 0, kKeycodeNumPadInsert, 0, &xev); 358 // XK_KP_Insert (= NumPad 0 without Num Lock), no modifier.
265 aura::KeyEvent keyevent(&xev, false /* is_char */); 359 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD0,
266 rewriter.RewriteForTesting(&keyevent); 360 0,
267 EXPECT_EQ(ui::VKEY_NUMPAD0, keyevent.key_code()); 361 ui::ET_KEY_PRESSED,
268 EXPECT_EQ(0, keyevent.flags()); 362 keycode_num_pad_0_,
269 const XKeyEvent& xkey = keyevent.native_event()->xkey; 363 Mod2Mask, // Num Lock
270 EXPECT_EQ(kKeycodeNumPad0, xkey.keycode); 364 KeyPress),
271 // Mod2Mask means Num Lock. 365 GetRewrittenEventAsString(&rewriter,
272 EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state); 366 ui::VKEY_INSERT,
273 } 367 0,
274 { 368 ui::ET_KEY_PRESSED,
275 // XK_KP_Insert (= NumPad 0 without Num Lock), Alt modifier. 369 keycode_num_pad_insert_,
276 InitXKeyEvent(ui::VKEY_INSERT, ui::EF_ALT_DOWN, 370 0));
277 kKeycodeNumPadInsert, Mod1Mask, &xev); 371
278 aura::KeyEvent keyevent(&xev, false /* is_char */); 372 // XK_KP_Insert (= NumPad 0 without Num Lock), Alt modifier.
279 rewriter.RewriteForTesting(&keyevent); 373 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD0,
280 EXPECT_EQ(ui::VKEY_NUMPAD0, keyevent.key_code()); 374 ui::EF_ALT_DOWN,
281 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 375 ui::ET_KEY_PRESSED,
282 const XKeyEvent& xkey = keyevent.native_event()->xkey; 376 keycode_num_pad_0_,
283 EXPECT_EQ(kKeycodeNumPad0, xkey.keycode); 377 Mod1Mask | Mod2Mask,
284 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state); 378 KeyPress),
285 } 379 GetRewrittenEventAsString(&rewriter,
286 { 380 ui::VKEY_INSERT,
287 // XK_KP_Delete (= NumPad . without Num Lock), Alt modifier. 381 ui::EF_ALT_DOWN,
288 InitXKeyEvent(ui::VKEY_DELETE, ui::EF_ALT_DOWN, 382 ui::ET_KEY_PRESSED,
289 kKeycodeNumPadDelete, Mod1Mask, &xev); 383 keycode_num_pad_insert_,
290 aura::KeyEvent keyevent(&xev, false /* is_char */); 384 Mod1Mask));
291 rewriter.RewriteForTesting(&keyevent); 385
292 EXPECT_EQ(ui::VKEY_DECIMAL, keyevent.key_code()); 386 // XK_KP_Delete (= NumPad . without Num Lock), Alt modifier.
293 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 387 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_DECIMAL,
294 const XKeyEvent& xkey = keyevent.native_event()->xkey; 388 ui::EF_ALT_DOWN,
295 EXPECT_EQ(kKeycodeNumPadDecimal, xkey.keycode); 389 ui::ET_KEY_PRESSED,
296 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state); 390 keycode_num_pad_decimal_,
297 } 391 Mod1Mask | Mod2Mask,
298 { 392 KeyPress),
299 // XK_KP_End (= NumPad 1 without Num Lock), Alt modifier. 393 GetRewrittenEventAsString(&rewriter,
300 InitXKeyEvent(ui::VKEY_END, ui::EF_ALT_DOWN, 394 ui::VKEY_DELETE,
301 kKeycodeNumPadEnd, Mod1Mask, &xev); 395 ui::EF_ALT_DOWN,
302 aura::KeyEvent keyevent(&xev, false /* is_char */); 396 ui::ET_KEY_PRESSED,
303 rewriter.RewriteForTesting(&keyevent); 397 keycode_num_pad_delete_,
304 EXPECT_EQ(ui::VKEY_NUMPAD1, keyevent.key_code()); 398 Mod1Mask));
305 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 399
306 const XKeyEvent& xkey = keyevent.native_event()->xkey; 400 // XK_KP_End (= NumPad 1 without Num Lock), Alt modifier.
307 EXPECT_EQ(kKeycodeNumPad1, xkey.keycode); 401 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD1,
308 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state); 402 ui::EF_ALT_DOWN,
309 } 403 ui::ET_KEY_PRESSED,
310 { 404 keycode_num_pad_1_,
311 // XK_KP_Down (= NumPad 2 without Num Lock), Alt modifier. 405 Mod1Mask | Mod2Mask,
312 InitXKeyEvent(ui::VKEY_DOWN, ui::EF_ALT_DOWN, 406 KeyPress),
313 kKeycodeNumPadDown, Mod1Mask, &xev); 407 GetRewrittenEventAsString(&rewriter,
314 aura::KeyEvent keyevent(&xev, false /* is_char */); 408 ui::VKEY_END,
315 rewriter.RewriteForTesting(&keyevent); 409 ui::EF_ALT_DOWN,
316 EXPECT_EQ(ui::VKEY_NUMPAD2, keyevent.key_code()); 410 ui::ET_KEY_PRESSED,
317 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 411 keycode_num_pad_end_,
318 const XKeyEvent& xkey = keyevent.native_event()->xkey; 412 Mod1Mask));
319 EXPECT_EQ(kKeycodeNumPad2, xkey.keycode); 413
320 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state); 414 // XK_KP_Down (= NumPad 2 without Num Lock), Alt modifier.
321 } 415 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD2,
322 { 416 ui::EF_ALT_DOWN,
323 // XK_KP_Next (= NumPad 3 without Num Lock), Alt modifier. 417 ui::ET_KEY_PRESSED,
324 InitXKeyEvent(ui::VKEY_NEXT, ui::EF_ALT_DOWN, 418 keycode_num_pad_2_,
325 kKeycodeNumPadNext, Mod1Mask, &xev); 419 Mod1Mask | Mod2Mask,
326 aura::KeyEvent keyevent(&xev, false /* is_char */); 420 KeyPress),
327 rewriter.RewriteForTesting(&keyevent); 421 GetRewrittenEventAsString(&rewriter,
328 EXPECT_EQ(ui::VKEY_NUMPAD3, keyevent.key_code()); 422 ui::VKEY_DOWN,
329 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 423 ui::EF_ALT_DOWN,
330 const XKeyEvent& xkey = keyevent.native_event()->xkey; 424 ui::ET_KEY_PRESSED,
331 EXPECT_EQ(kKeycodeNumPad3, xkey.keycode); 425 keycode_num_pad_down_,
332 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state); 426 Mod1Mask));
333 } 427
334 { 428 // XK_KP_Next (= NumPad 3 without Num Lock), Alt modifier.
335 // XK_KP_Left (= NumPad 4 without Num Lock), Alt modifier. 429 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD3,
336 InitXKeyEvent(ui::VKEY_LEFT, ui::EF_ALT_DOWN, 430 ui::EF_ALT_DOWN,
337 kKeycodeNumPadLeft, Mod1Mask, &xev); 431 ui::ET_KEY_PRESSED,
338 aura::KeyEvent keyevent(&xev, false /* is_char */); 432 keycode_num_pad_3_,
339 rewriter.RewriteForTesting(&keyevent); 433 Mod1Mask | Mod2Mask,
340 EXPECT_EQ(ui::VKEY_NUMPAD4, keyevent.key_code()); 434 KeyPress),
341 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 435 GetRewrittenEventAsString(&rewriter,
342 const XKeyEvent& xkey = keyevent.native_event()->xkey; 436 ui::VKEY_NEXT,
343 EXPECT_EQ(kKeycodeNumPad4, xkey.keycode); 437 ui::EF_ALT_DOWN,
344 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state); 438 ui::ET_KEY_PRESSED,
345 } 439 keycode_num_pad_next_,
346 { 440 Mod1Mask));
347 // XK_KP_Begin (= NumPad 5 without Num Lock), Alt modifier. 441
348 InitXKeyEvent(ui::VKEY_CLEAR, ui::EF_ALT_DOWN, 442 // XK_KP_Left (= NumPad 4 without Num Lock), Alt modifier.
349 kKeycodeNumPadBegin, Mod1Mask, &xev); 443 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD4,
350 aura::KeyEvent keyevent(&xev, false /* is_char */); 444 ui::EF_ALT_DOWN,
351 rewriter.RewriteForTesting(&keyevent); 445 ui::ET_KEY_PRESSED,
352 EXPECT_EQ(ui::VKEY_NUMPAD5, keyevent.key_code()); 446 keycode_num_pad_4_,
353 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 447 Mod1Mask | Mod2Mask,
354 const XKeyEvent& xkey = keyevent.native_event()->xkey; 448 KeyPress),
355 EXPECT_EQ(kKeycodeNumPad5, xkey.keycode); 449 GetRewrittenEventAsString(&rewriter,
356 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state); 450 ui::VKEY_LEFT,
357 } 451 ui::EF_ALT_DOWN,
358 { 452 ui::ET_KEY_PRESSED,
359 // XK_KP_Right (= NumPad 6 without Num Lock), Alt modifier. 453 keycode_num_pad_left_,
360 InitXKeyEvent(ui::VKEY_RIGHT, ui::EF_ALT_DOWN, 454 Mod1Mask));
361 kKeycodeNumPadRight, Mod1Mask, &xev); 455
362 aura::KeyEvent keyevent(&xev, false /* is_char */); 456 // XK_KP_Begin (= NumPad 5 without Num Lock), Alt modifier.
363 rewriter.RewriteForTesting(&keyevent); 457 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD5,
364 EXPECT_EQ(ui::VKEY_NUMPAD6, keyevent.key_code()); 458 ui::EF_ALT_DOWN,
365 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 459 ui::ET_KEY_PRESSED,
366 const XKeyEvent& xkey = keyevent.native_event()->xkey; 460 keycode_num_pad_5_,
367 EXPECT_EQ(kKeycodeNumPad6, xkey.keycode); 461 Mod1Mask | Mod2Mask,
368 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state); 462 KeyPress),
369 } 463 GetRewrittenEventAsString(&rewriter,
370 { 464 ui::VKEY_CLEAR,
371 // XK_KP_Home (= NumPad 7 without Num Lock), Alt modifier. 465 ui::EF_ALT_DOWN,
372 InitXKeyEvent(ui::VKEY_HOME, ui::EF_ALT_DOWN, 466 ui::ET_KEY_PRESSED,
373 kKeycodeNumPadHome, Mod1Mask, &xev); 467 keycode_num_pad_begin_,
374 aura::KeyEvent keyevent(&xev, false /* is_char */); 468 Mod1Mask));
375 rewriter.RewriteForTesting(&keyevent); 469
376 EXPECT_EQ(ui::VKEY_NUMPAD7, keyevent.key_code()); 470 // XK_KP_Right (= NumPad 6 without Num Lock), Alt modifier.
377 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 471 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD6,
378 const XKeyEvent& xkey = keyevent.native_event()->xkey; 472 ui::EF_ALT_DOWN,
379 EXPECT_EQ(kKeycodeNumPad7, xkey.keycode); 473 ui::ET_KEY_PRESSED,
380 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state); 474 keycode_num_pad_6_,
381 } 475 Mod1Mask | Mod2Mask,
382 { 476 KeyPress),
383 // XK_KP_Up (= NumPad 8 without Num Lock), Alt modifier. 477 GetRewrittenEventAsString(&rewriter,
384 InitXKeyEvent(ui::VKEY_UP, ui::EF_ALT_DOWN, 478 ui::VKEY_RIGHT,
385 kKeycodeNumPadUp, Mod1Mask, &xev); 479 ui::EF_ALT_DOWN,
386 aura::KeyEvent keyevent(&xev, false /* is_char */); 480 ui::ET_KEY_PRESSED,
387 rewriter.RewriteForTesting(&keyevent); 481 keycode_num_pad_right_,
388 EXPECT_EQ(ui::VKEY_NUMPAD8, keyevent.key_code()); 482 Mod1Mask));
389 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 483
390 const XKeyEvent& xkey = keyevent.native_event()->xkey; 484 // XK_KP_Home (= NumPad 7 without Num Lock), Alt modifier.
391 EXPECT_EQ(kKeycodeNumPad8, xkey.keycode); 485 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD7,
392 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state); 486 ui::EF_ALT_DOWN,
393 } 487 ui::ET_KEY_PRESSED,
394 { 488 keycode_num_pad_7_,
395 // XK_KP_Prior (= NumPad 9 without Num Lock), Alt modifier. 489 Mod1Mask | Mod2Mask,
396 InitXKeyEvent(ui::VKEY_PRIOR, ui::EF_ALT_DOWN, 490 KeyPress),
397 kKeycodeNumPadPrior, Mod1Mask, &xev); 491 GetRewrittenEventAsString(&rewriter,
398 aura::KeyEvent keyevent(&xev, false /* is_char */); 492 ui::VKEY_HOME,
399 rewriter.RewriteForTesting(&keyevent); 493 ui::EF_ALT_DOWN,
400 EXPECT_EQ(ui::VKEY_NUMPAD9, keyevent.key_code()); 494 ui::ET_KEY_PRESSED,
401 EXPECT_EQ(ui::EF_ALT_DOWN, keyevent.flags()); 495 keycode_num_pad_home_,
402 const XKeyEvent& xkey = keyevent.native_event()->xkey; 496 Mod1Mask));
403 EXPECT_EQ(kKeycodeNumPad9, xkey.keycode); 497
404 EXPECT_EQ(static_cast<unsigned int>(Mod1Mask | Mod2Mask), xkey.state); 498 // XK_KP_Up (= NumPad 8 without Num Lock), Alt modifier.
405 } 499 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD8,
406 { 500 ui::EF_ALT_DOWN,
407 // XK_KP_0 (= NumPad 0 with Num Lock), Num Lock modifier. 501 ui::ET_KEY_PRESSED,
408 InitXKeyEvent(ui::VKEY_NUMPAD0, 0, kKeycodeNumPad0, Mod2Mask, &xev); 502 keycode_num_pad_8_,
409 aura::KeyEvent keyevent(&xev, false /* is_char */); 503 Mod1Mask | Mod2Mask,
410 rewriter.RewriteForTesting(&keyevent); 504 KeyPress),
411 EXPECT_EQ(ui::VKEY_NUMPAD0, keyevent.key_code()); 505 GetRewrittenEventAsString(&rewriter,
412 EXPECT_EQ(0, keyevent.flags()); 506 ui::VKEY_UP,
413 const XKeyEvent& xkey = keyevent.native_event()->xkey; 507 ui::EF_ALT_DOWN,
414 EXPECT_EQ(kKeycodeNumPad0, xkey.keycode); 508 ui::ET_KEY_PRESSED,
415 EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state); 509 keycode_num_pad_up_,
416 } 510 Mod1Mask));
417 { 511
418 // XK_KP_DECIMAL (= NumPad . with Num Lock), Num Lock modifier. 512 // XK_KP_Prior (= NumPad 9 without Num Lock), Alt modifier.
419 InitXKeyEvent(ui::VKEY_DECIMAL, 0, kKeycodeNumPadDecimal, Mod2Mask, &xev); 513 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD9,
420 aura::KeyEvent keyevent(&xev, false /* is_char */); 514 ui::EF_ALT_DOWN,
421 rewriter.RewriteForTesting(&keyevent); 515 ui::ET_KEY_PRESSED,
422 EXPECT_EQ(ui::VKEY_DECIMAL, keyevent.key_code()); 516 keycode_num_pad_9_,
423 EXPECT_EQ(0, keyevent.flags()); 517 Mod1Mask | Mod2Mask,
424 const XKeyEvent& xkey = keyevent.native_event()->xkey; 518 KeyPress),
425 EXPECT_EQ(kKeycodeNumPadDecimal, xkey.keycode); 519 GetRewrittenEventAsString(&rewriter,
426 EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state); 520 ui::VKEY_PRIOR,
427 } 521 ui::EF_ALT_DOWN,
428 { 522 ui::ET_KEY_PRESSED,
429 // XK_KP_1 (= NumPad 1 with Num Lock), Num Lock modifier. 523 keycode_num_pad_prior_,
430 InitXKeyEvent(ui::VKEY_NUMPAD1, 0, kKeycodeNumPad1, Mod2Mask, &xev); 524 Mod1Mask));
431 aura::KeyEvent keyevent(&xev, false /* is_char */); 525
432 rewriter.RewriteForTesting(&keyevent); 526 // XK_KP_0 (= NumPad 0 with Num Lock), Num Lock modifier.
433 EXPECT_EQ(ui::VKEY_NUMPAD1, keyevent.key_code()); 527 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD0,
434 EXPECT_EQ(0, keyevent.flags()); 528 0,
435 const XKeyEvent& xkey = keyevent.native_event()->xkey; 529 ui::ET_KEY_PRESSED,
436 EXPECT_EQ(kKeycodeNumPad1, xkey.keycode); 530 keycode_num_pad_0_,
437 EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state); 531 Mod2Mask,
438 } 532 KeyPress),
439 { 533 GetRewrittenEventAsString(&rewriter,
440 // XK_KP_2 (= NumPad 2 with Num Lock), Num Lock modifier. 534 ui::VKEY_NUMPAD0,
441 InitXKeyEvent(ui::VKEY_NUMPAD2, 0, kKeycodeNumPad2, Mod2Mask, &xev); 535 0,
442 aura::KeyEvent keyevent(&xev, false /* is_char */); 536 ui::ET_KEY_PRESSED,
443 rewriter.RewriteForTesting(&keyevent); 537 keycode_num_pad_0_,
444 EXPECT_EQ(ui::VKEY_NUMPAD2, keyevent.key_code()); 538 Mod2Mask));
445 EXPECT_EQ(0, keyevent.flags()); 539
446 const XKeyEvent& xkey = keyevent.native_event()->xkey; 540 // XK_KP_DECIMAL (= NumPad . with Num Lock), Num Lock modifier.
447 EXPECT_EQ(kKeycodeNumPad2, xkey.keycode); 541 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_DECIMAL,
448 EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state); 542 0,
449 } 543 ui::ET_KEY_PRESSED,
450 { 544 keycode_num_pad_decimal_,
451 // XK_KP_3 (= NumPad 3 with Num Lock), Num Lock modifier. 545 Mod2Mask,
452 InitXKeyEvent(ui::VKEY_NUMPAD3, 0, kKeycodeNumPad3, Mod2Mask, &xev); 546 KeyPress),
453 aura::KeyEvent keyevent(&xev, false /* is_char */); 547 GetRewrittenEventAsString(&rewriter,
454 rewriter.RewriteForTesting(&keyevent); 548 ui::VKEY_DECIMAL,
455 EXPECT_EQ(ui::VKEY_NUMPAD3, keyevent.key_code()); 549 0,
456 EXPECT_EQ(0, keyevent.flags()); 550 ui::ET_KEY_PRESSED,
457 const XKeyEvent& xkey = keyevent.native_event()->xkey; 551 keycode_num_pad_decimal_,
458 EXPECT_EQ(kKeycodeNumPad3, xkey.keycode); 552 Mod2Mask));
459 EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state); 553
460 } 554 // XK_KP_1 (= NumPad 1 with Num Lock), Num Lock modifier.
461 { 555 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD1,
462 // XK_KP_4 (= NumPad 4 with Num Lock), Num Lock modifier. 556 0,
463 InitXKeyEvent(ui::VKEY_NUMPAD4, 0, kKeycodeNumPad4, Mod2Mask, &xev); 557 ui::ET_KEY_PRESSED,
464 aura::KeyEvent keyevent(&xev, false /* is_char */); 558 keycode_num_pad_1_,
465 rewriter.RewriteForTesting(&keyevent); 559 Mod2Mask,
466 EXPECT_EQ(ui::VKEY_NUMPAD4, keyevent.key_code()); 560 KeyPress),
467 EXPECT_EQ(0, keyevent.flags()); 561 GetRewrittenEventAsString(&rewriter,
468 const XKeyEvent& xkey = keyevent.native_event()->xkey; 562 ui::VKEY_NUMPAD1,
469 EXPECT_EQ(kKeycodeNumPad4, xkey.keycode); 563 0,
470 EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state); 564 ui::ET_KEY_PRESSED,
471 } 565 keycode_num_pad_1_,
472 { 566 Mod2Mask));
473 // XK_KP_5 (= NumPad 5 with Num Lock), Num Lock modifier. 567
474 InitXKeyEvent(ui::VKEY_NUMPAD5, 0, kKeycodeNumPad5, Mod2Mask, &xev); 568 // XK_KP_2 (= NumPad 2 with Num Lock), Num Lock modifier.
475 aura::KeyEvent keyevent(&xev, false /* is_char */); 569 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD2,
476 rewriter.RewriteForTesting(&keyevent); 570 0,
477 EXPECT_EQ(ui::VKEY_NUMPAD5, keyevent.key_code()); 571 ui::ET_KEY_PRESSED,
478 EXPECT_EQ(0, keyevent.flags()); 572 keycode_num_pad_2_,
479 const XKeyEvent& xkey = keyevent.native_event()->xkey; 573 Mod2Mask,
480 EXPECT_EQ(kKeycodeNumPad5, xkey.keycode); 574 KeyPress),
481 EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state); 575 GetRewrittenEventAsString(&rewriter,
482 } 576 ui::VKEY_NUMPAD2,
483 { 577 0,
484 // XK_KP_6 (= NumPad 6 with Num Lock), Num Lock modifier. 578 ui::ET_KEY_PRESSED,
485 InitXKeyEvent(ui::VKEY_NUMPAD6, 0, kKeycodeNumPad6, Mod2Mask, &xev); 579 keycode_num_pad_2_,
486 aura::KeyEvent keyevent(&xev, false /* is_char */); 580 Mod2Mask));
487 rewriter.RewriteForTesting(&keyevent); 581
488 EXPECT_EQ(ui::VKEY_NUMPAD6, keyevent.key_code()); 582 // XK_KP_3 (= NumPad 3 with Num Lock), Num Lock modifier.
489 EXPECT_EQ(0, keyevent.flags()); 583 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD3,
490 const XKeyEvent& xkey = keyevent.native_event()->xkey; 584 0,
491 EXPECT_EQ(kKeycodeNumPad6, xkey.keycode); 585 ui::ET_KEY_PRESSED,
492 EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state); 586 keycode_num_pad_3_,
493 } 587 Mod2Mask,
494 { 588 KeyPress),
495 // XK_KP_7 (= NumPad 7 with Num Lock), Num Lock modifier. 589 GetRewrittenEventAsString(&rewriter,
496 InitXKeyEvent(ui::VKEY_NUMPAD7, 0, kKeycodeNumPad7, Mod2Mask, &xev); 590 ui::VKEY_NUMPAD3,
497 aura::KeyEvent keyevent(&xev, false /* is_char */); 591 0,
498 rewriter.RewriteForTesting(&keyevent); 592 ui::ET_KEY_PRESSED,
499 EXPECT_EQ(ui::VKEY_NUMPAD7, keyevent.key_code()); 593 keycode_num_pad_3_,
500 EXPECT_EQ(0, keyevent.flags()); 594 Mod2Mask));
501 const XKeyEvent& xkey = keyevent.native_event()->xkey; 595
502 EXPECT_EQ(kKeycodeNumPad7, xkey.keycode); 596 // XK_KP_4 (= NumPad 4 with Num Lock), Num Lock modifier.
503 EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state); 597 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD4,
504 } 598 0,
505 { 599 ui::ET_KEY_PRESSED,
506 // XK_KP_8 (= NumPad 8 with Num Lock), Num Lock modifier. 600 keycode_num_pad_4_,
507 InitXKeyEvent(ui::VKEY_NUMPAD8, 0, kKeycodeNumPad8, Mod2Mask, &xev); 601 Mod2Mask,
508 aura::KeyEvent keyevent(&xev, false /* is_char */); 602 KeyPress),
509 rewriter.RewriteForTesting(&keyevent); 603 GetRewrittenEventAsString(&rewriter,
510 EXPECT_EQ(ui::VKEY_NUMPAD8, keyevent.key_code()); 604 ui::VKEY_NUMPAD4,
511 EXPECT_EQ(0, keyevent.flags()); 605 0,
512 const XKeyEvent& xkey = keyevent.native_event()->xkey; 606 ui::ET_KEY_PRESSED,
513 EXPECT_EQ(kKeycodeNumPad8, xkey.keycode); 607 keycode_num_pad_4_,
514 EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state); 608 Mod2Mask));
515 } 609
516 { 610 // XK_KP_5 (= NumPad 5 with Num Lock), Num Lock modifier.
517 // XK_KP_9 (= NumPad 9 with Num Lock), Num Lock modifier. 611 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD5,
518 InitXKeyEvent(ui::VKEY_NUMPAD9, 0, kKeycodeNumPad9, Mod2Mask, &xev); 612 0,
519 aura::KeyEvent keyevent(&xev, false /* is_char */); 613 ui::ET_KEY_PRESSED,
520 rewriter.RewriteForTesting(&keyevent); 614 keycode_num_pad_5_,
521 EXPECT_EQ(ui::VKEY_NUMPAD9, keyevent.key_code()); 615 Mod2Mask,
522 EXPECT_EQ(0, keyevent.flags()); 616 KeyPress),
523 const XKeyEvent& xkey = keyevent.native_event()->xkey; 617 GetRewrittenEventAsString(&rewriter,
524 EXPECT_EQ(kKeycodeNumPad9, xkey.keycode); 618 ui::VKEY_NUMPAD5,
525 EXPECT_EQ(static_cast<unsigned int>(Mod2Mask), xkey.state); 619 0,
526 } 620 ui::ET_KEY_PRESSED,
621 keycode_num_pad_5_,
622 Mod2Mask));
623
624 // XK_KP_6 (= NumPad 6 with Num Lock), Num Lock modifier.
625 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD6,
626 0,
627 ui::ET_KEY_PRESSED,
628 keycode_num_pad_6_,
629 Mod2Mask,
630 KeyPress),
631 GetRewrittenEventAsString(&rewriter,
632 ui::VKEY_NUMPAD6,
633 0,
634 ui::ET_KEY_PRESSED,
635 keycode_num_pad_6_,
636 Mod2Mask));
637
638 // XK_KP_7 (= NumPad 7 with Num Lock), Num Lock modifier.
639 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD7,
640 0,
641 ui::ET_KEY_PRESSED,
642 keycode_num_pad_7_,
643 Mod2Mask,
644 KeyPress),
645 GetRewrittenEventAsString(&rewriter,
646 ui::VKEY_NUMPAD7,
647 0,
648 ui::ET_KEY_PRESSED,
649 keycode_num_pad_7_,
650 Mod2Mask));
651
652 // XK_KP_8 (= NumPad 8 with Num Lock), Num Lock modifier.
653 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD8,
654 0,
655 ui::ET_KEY_PRESSED,
656 keycode_num_pad_8_,
657 Mod2Mask,
658 KeyPress),
659 GetRewrittenEventAsString(&rewriter,
660 ui::VKEY_NUMPAD8,
661 0,
662 ui::ET_KEY_PRESSED,
663 keycode_num_pad_8_,
664 Mod2Mask));
665
666 // XK_KP_9 (= NumPad 9 with Num Lock), Num Lock modifier.
667 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD9,
668 0,
669 ui::ET_KEY_PRESSED,
670 keycode_num_pad_9_,
671 Mod2Mask,
672 KeyPress),
673 GetRewrittenEventAsString(&rewriter,
674 ui::VKEY_NUMPAD9,
675 0,
676 ui::ET_KEY_PRESSED,
677 keycode_num_pad_9_,
678 Mod2Mask));
527 } 679 }
528 680
529 // Tests if the rewriter can handle a Command + Num Pad event. 681 // Tests if the rewriter can handle a Command + Num Pad event.
530 TEST(KeyRewriterTest, TestRewriteNumPadKeysOnAppleKeyboard) { 682 TEST_F(KeyRewriterTest, TestRewriteNumPadKeysOnAppleKeyboard) {
531 XEvent xev; 683 TestingPrefService prefs;
532 Display* display = ui::GetXDisplay();
533
534 const unsigned int kKeycodeNumPadEnd = XKeysymToKeycode(display, XK_KP_End);
535 const unsigned int kKeycodeNumPad1 = XKeysymToKeycode(display, XK_KP_1);
536
537 KeyRewriter rewriter; 684 KeyRewriter rewriter;
538 rewriter.DeviceAddedForTesting(0, "Apple Keyboard"); 685 rewriter.DeviceAddedForTesting(0, "Apple Keyboard");
539 rewriter.set_last_device_id_for_testing(0); 686 rewriter.set_last_device_id_for_testing(0);
540 { 687 rewriter.set_pref_service_for_testing(&prefs);
541 // XK_KP_End (= NumPad 1 without Num Lock), Win modifier. 688
542 InitXKeyEvent(ui::VKEY_END, 0, kKeycodeNumPadEnd, Mod4Mask, &xev); 689 // XK_KP_End (= NumPad 1 without Num Lock), Win modifier.
543 aura::KeyEvent keyevent(&xev, false /* is_char */); 690 // The result should be "Num Pad 1 with Control + Num Lock modifiers".
544 rewriter.RewriteForTesting(&keyevent); 691 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD1,
545 // The result should be "Num Pad 1 with Control + Num Lock modifiers". 692 ui::EF_CONTROL_DOWN,
546 EXPECT_EQ(ui::VKEY_NUMPAD1, keyevent.key_code()); 693 ui::ET_KEY_PRESSED,
547 EXPECT_EQ(ui::EF_CONTROL_DOWN, keyevent.flags()); 694 keycode_num_pad_1_,
548 const XKeyEvent& xkey = keyevent.native_event()->xkey; 695 ControlMask | Mod2Mask,
549 EXPECT_EQ(kKeycodeNumPad1, xkey.keycode); 696 KeyPress),
550 EXPECT_EQ(static_cast<unsigned int>(ControlMask | Mod2Mask), xkey.state); 697 GetRewrittenEventAsString(&rewriter,
551 } 698 ui::VKEY_END,
552 { 699 0,
553 // XK_KP_1 (= NumPad 1 without Num Lock), Win modifier. 700 ui::ET_KEY_PRESSED,
554 InitXKeyEvent(ui::VKEY_NUMPAD1, 0, kKeycodeNumPadEnd, Mod4Mask, &xev); 701 keycode_num_pad_end_,
555 aura::KeyEvent keyevent(&xev, false /* is_char */); 702 Mod4Mask));
556 rewriter.RewriteForTesting(&keyevent); 703
557 // The result should also be "Num Pad 1 with Control + Num Lock modifiers". 704 // XK_KP_1 (= NumPad 1 without Num Lock), Win modifier.
558 EXPECT_EQ(ui::VKEY_NUMPAD1, keyevent.key_code()); 705 // The result should also be "Num Pad 1 with Control + Num Lock modifiers".
559 EXPECT_EQ(ui::EF_CONTROL_DOWN, keyevent.flags()); 706 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD1,
560 const XKeyEvent& xkey = keyevent.native_event()->xkey; 707 ui::EF_CONTROL_DOWN,
561 EXPECT_EQ(kKeycodeNumPad1, xkey.keycode); 708 ui::ET_KEY_PRESSED,
562 EXPECT_EQ(static_cast<unsigned int>(ControlMask | Mod2Mask), xkey.state); 709 keycode_num_pad_1_,
563 } 710 ControlMask | Mod2Mask,
711 KeyPress),
712 GetRewrittenEventAsString(&rewriter,
713 ui::VKEY_NUMPAD1,
714 0,
715 ui::ET_KEY_PRESSED,
716 keycode_num_pad_end_,
717 Mod4Mask));
564 } 718 }
565 719
720 TEST_F(KeyRewriterTest, TestRewriteModifiersNoRemap) {
721 TestingPrefService prefs;
722 KeyRewriter rewriter;
723 rewriter.set_pref_service_for_testing(&prefs);
724
725 // Press Search. Confirm the event is not rewritten.
726 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_LWIN,
727 0,
728 ui::ET_KEY_PRESSED,
729 keycode_super_l_,
730 0U,
731 KeyPress),
732 GetRewrittenEventAsString(&rewriter,
733 ui::VKEY_LWIN,
734 0,
735 ui::ET_KEY_PRESSED,
736 keycode_super_l_,
737 0U));
738
739 // Press left Control. Confirm the event is not rewritten.
740 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
741 0,
742 ui::ET_KEY_PRESSED,
743 keycode_control_l_,
744 0U,
745 KeyPress),
746 GetRewrittenEventAsString(&rewriter,
747 ui::VKEY_CONTROL,
748 0,
749 ui::ET_KEY_PRESSED,
750 keycode_control_l_,
751 0U));
752
753 // Press right Control. Confirm the event is not rewritten.
754 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
755 0,
756 ui::ET_KEY_PRESSED,
757 keycode_control_r_,
758 0U,
759 KeyPress),
760 GetRewrittenEventAsString(&rewriter,
761 ui::VKEY_CONTROL,
762 0,
763 ui::ET_KEY_PRESSED,
764 keycode_control_r_,
765 0U));
766
767 // Press left Alt. Confirm the event is not rewritten.
768 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
769 0,
770 ui::ET_KEY_PRESSED,
771 keycode_alt_l_,
772 0,
773 KeyPress),
774 GetRewrittenEventAsString(&rewriter,
775 ui::VKEY_MENU,
776 0,
777 ui::ET_KEY_PRESSED,
778 keycode_alt_l_,
779 0U));
780
781 // Press right Alt. Confirm the event is not rewritten.
782 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
783 0,
784 ui::ET_KEY_PRESSED,
785 keycode_alt_r_,
786 0,
787 KeyPress),
788 GetRewrittenEventAsString(&rewriter,
789 ui::VKEY_MENU,
790 0,
791 ui::ET_KEY_PRESSED,
792 keycode_alt_r_,
793 0U));
794
795 // Test KeyRelease event, just in case.
796 // Release Search. Confirm the release event is not rewritten.
797 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_LWIN,
798 0,
799 ui::ET_KEY_RELEASED,
800 keycode_super_l_,
801 Mod4Mask,
802 KeyRelease),
803 GetRewrittenEventAsString(&rewriter,
804 ui::VKEY_LWIN,
805 0,
806 ui::ET_KEY_RELEASED,
807 keycode_super_l_,
808 Mod4Mask));
809 }
810
811 TEST_F(KeyRewriterTest, TestRewriteModifiersNoRemapMultipleKeys) {
812 TestingPrefService prefs;
813 KeyRewriter rewriter;
814 rewriter.set_pref_service_for_testing(&prefs);
815
816 // Press left Alt with Shift. Confirm the event is not rewritten.
817 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
818 ui::EF_SHIFT_DOWN,
819 ui::ET_KEY_PRESSED,
820 keycode_meta_l_,
821 ShiftMask,
822 KeyPress),
823 GetRewrittenEventAsString(&rewriter,
824 ui::VKEY_MENU,
825 ui::EF_SHIFT_DOWN,
826 ui::ET_KEY_PRESSED,
827 keycode_meta_l_,
828 ShiftMask));
829
830 // Press right Alt with Shift. Confirm the event is not rewritten.
831 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
832 ui::EF_SHIFT_DOWN,
833 ui::ET_KEY_PRESSED,
834 keycode_meta_r_,
835 ShiftMask,
836 KeyPress),
837 GetRewrittenEventAsString(&rewriter,
838 ui::VKEY_MENU,
839 ui::EF_SHIFT_DOWN,
840 ui::ET_KEY_PRESSED,
841 keycode_meta_r_,
842 ShiftMask));
843
844 // Press Search with Caps Lock mask. Confirm the event is not rewritten.
845 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_LWIN,
846 ui::EF_CAPS_LOCK_DOWN,
847 ui::ET_KEY_PRESSED,
848 keycode_super_l_,
849 LockMask,
850 KeyPress),
851 GetRewrittenEventAsString(&rewriter,
852 ui::VKEY_LWIN,
853 ui::EF_CAPS_LOCK_DOWN,
854 ui::ET_KEY_PRESSED,
855 keycode_super_l_,
856 LockMask));
857
858 // Release Search with Caps Lock mask. Confirm the event is not rewritten.
859 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_LWIN,
860 ui::EF_CAPS_LOCK_DOWN,
861 ui::ET_KEY_RELEASED,
862 keycode_super_l_,
863 LockMask | Mod4Mask,
864 KeyRelease),
865 GetRewrittenEventAsString(&rewriter,
866 ui::VKEY_LWIN,
867 ui::EF_CAPS_LOCK_DOWN,
868 ui::ET_KEY_RELEASED,
869 keycode_super_l_,
870 LockMask | Mod4Mask));
871
872 // Press Shift+Ctrl+Alt+Search+A. Confirm the event is not rewritten.
873 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_B,
874 ui::EF_SHIFT_DOWN |
875 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
876 ui::ET_KEY_PRESSED,
877 keycode_b_,
878 ShiftMask | ControlMask | Mod1Mask |
879 Mod4Mask,
880 KeyPress),
881 GetRewrittenEventAsString(&rewriter,
882 ui::VKEY_B,
883 ui::EF_SHIFT_DOWN |
884 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
885 ui::ET_KEY_PRESSED,
886 keycode_b_,
887 ShiftMask | ControlMask | Mod1Mask |
888 Mod4Mask));
889 }
890
891 TEST_F(KeyRewriterTest, TestRewriteModifiersDisableSome) {
892 // Disable Search and Control keys.
893 TestingPrefService prefs;
894 chromeos::Preferences::RegisterUserPrefs(&prefs);
895 IntegerPrefMember search;
896 search.Init(prefs::kLanguageXkbRemapSearchKeyTo, &prefs, NULL);
897 search.SetValue(chromeos::input_method::kVoidKey);
898 IntegerPrefMember control;
899 control.Init(prefs::kLanguageXkbRemapControlKeyTo, &prefs, NULL);
900 control.SetValue(chromeos::input_method::kVoidKey);
901
902 KeyRewriter rewriter;
903 rewriter.set_pref_service_for_testing(&prefs);
904
905 // Press left Alt with Shift. This key press shouldn't be affected by the
906 // pref. Confirm the event is not rewritten.
907 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
908 ui::EF_SHIFT_DOWN,
909 ui::ET_KEY_PRESSED,
910 keycode_meta_l_,
911 ShiftMask,
912 KeyPress),
913 GetRewrittenEventAsString(&rewriter,
914 ui::VKEY_MENU,
915 ui::EF_SHIFT_DOWN,
916 ui::ET_KEY_PRESSED,
917 keycode_meta_l_,
918 ShiftMask));
919
920 // Press Search. Confirm the event is now VKEY_UNKNOWN + XK_VoidSymbol.
921 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_UNKNOWN,
922 0,
923 ui::ET_KEY_PRESSED,
924 keycode_void_symbol_,
925 0U,
926 KeyPress),
927 GetRewrittenEventAsString(&rewriter,
928 ui::VKEY_LWIN,
929 0,
930 ui::ET_KEY_PRESSED,
931 keycode_super_l_,
932 0U));
933
934 // Press Control. Confirm the event is now VKEY_UNKNOWN + XK_VoidSymbol.
935 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_UNKNOWN,
936 0,
937 ui::ET_KEY_PRESSED,
938 keycode_void_symbol_,
939 0U,
940 KeyPress),
941 GetRewrittenEventAsString(&rewriter,
942 ui::VKEY_CONTROL,
943 0,
944 ui::ET_KEY_PRESSED,
945 keycode_control_l_,
946 0U));
947
948 // Press Control+Search. Confirm the event is now VKEY_UNKNOWN +
949 // XK_VoidSymbol without any modifiers.
950 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_UNKNOWN,
951 0,
952 ui::ET_KEY_PRESSED,
953 keycode_void_symbol_,
954 0U,
955 KeyPress),
956 GetRewrittenEventAsString(&rewriter,
957 ui::VKEY_LWIN,
958 ui::EF_CONTROL_DOWN,
959 ui::ET_KEY_PRESSED,
960 keycode_super_l_,
961 ControlMask));
962
963 // Press Control+Search+a. Confirm the event is now VKEY_A without any
964 // modifiers.
965 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
966 0,
967 ui::ET_KEY_PRESSED,
968 keycode_a_,
969 0U,
970 KeyPress),
971 GetRewrittenEventAsString(&rewriter,
972 ui::VKEY_A,
973 ui::EF_CONTROL_DOWN,
974 ui::ET_KEY_PRESSED,
975 keycode_a_,
976 ControlMask | Mod4Mask));
977
978 // Press Control+Search+Alt+a. Confirm the event is now VKEY_A only with
979 // the Alt modifier.
980 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
981 ui::EF_ALT_DOWN,
982 ui::ET_KEY_PRESSED,
983 keycode_a_,
984 Mod1Mask,
985 KeyPress),
986 GetRewrittenEventAsString(&rewriter,
987 ui::VKEY_A,
988 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
989 ui::ET_KEY_PRESSED,
990 keycode_a_,
991 ControlMask | Mod1Mask | Mod4Mask));
992
993 // Remap Alt to Control.
994 IntegerPrefMember alt;
995 alt.Init(prefs::kLanguageXkbRemapAltKeyTo, &prefs, NULL);
996 alt.SetValue(chromeos::input_method::kControlKey);
997
998 // Press left Alt. Confirm the event is now VKEY_CONTROL + XK_Control_L
999 // even though the Control key itself is disabled.
1000 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1001 0,
1002 ui::ET_KEY_PRESSED,
1003 keycode_control_l_,
1004 0U,
1005 KeyPress),
1006 GetRewrittenEventAsString(&rewriter,
1007 ui::VKEY_MENU,
1008 0,
1009 ui::ET_KEY_PRESSED,
1010 keycode_alt_l_,
1011 0U));
1012
1013 // Press Alt+a. Confirm the event is now Control+a even though the Control
1014 // key itself is disabled.
1015 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
1016 ui::EF_CONTROL_DOWN,
1017 ui::ET_KEY_PRESSED,
1018 keycode_a_,
1019 ControlMask,
1020 KeyPress),
1021 GetRewrittenEventAsString(&rewriter,
1022 ui::VKEY_A,
1023 ui::EF_ALT_DOWN,
1024 ui::ET_KEY_PRESSED,
1025 keycode_a_,
1026 Mod1Mask));
1027 }
1028
1029 TEST_F(KeyRewriterTest, TestRewriteModifiersRemapToControl) {
1030 // Remap Search to Control.
1031 TestingPrefService prefs;
1032 chromeos::Preferences::RegisterUserPrefs(&prefs);
1033 IntegerPrefMember search;
1034 search.Init(prefs::kLanguageXkbRemapSearchKeyTo, &prefs, NULL);
1035 search.SetValue(chromeos::input_method::kControlKey);
1036
1037 KeyRewriter rewriter;
1038 rewriter.set_pref_service_for_testing(&prefs);
1039
1040 // Press Search. Confirm the event is now VKEY_CONTROL + XK_Control_L.
1041 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1042 0,
1043 ui::ET_KEY_PRESSED,
1044 keycode_control_l_,
1045 0U,
1046 KeyPress),
1047 GetRewrittenEventAsString(&rewriter,
1048 ui::VKEY_LWIN,
1049 0,
1050 ui::ET_KEY_PRESSED,
1051 keycode_super_l_,
1052 0U));
1053
1054 // Remap Alt to Control too.
1055 IntegerPrefMember alt;
1056 alt.Init(prefs::kLanguageXkbRemapAltKeyTo, &prefs, NULL);
1057 alt.SetValue(chromeos::input_method::kControlKey);
1058
1059 // Press left Alt. Confirm the event is now VKEY_CONTROL + XK_Control_L.
1060 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1061 0,
1062 ui::ET_KEY_PRESSED,
1063 keycode_control_l_,
1064 0U,
1065 KeyPress),
1066 GetRewrittenEventAsString(&rewriter,
1067 ui::VKEY_MENU,
1068 0,
1069 ui::ET_KEY_PRESSED,
1070 keycode_alt_l_,
1071 0U));
1072
1073 // Press right Alt. Confirm the event is now VKEY_CONTROL + XK_Control_R.
1074 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1075 0,
1076 ui::ET_KEY_PRESSED,
1077 keycode_control_r_,
1078 0U,
1079 KeyPress),
1080 GetRewrittenEventAsString(&rewriter,
1081 ui::VKEY_MENU,
1082 0,
1083 ui::ET_KEY_PRESSED,
1084 keycode_alt_r_,
1085 0U));
1086
1087 // Press Alt+Search. Confirm the event is now VKEY_CONTROL + XK_Control_L.
1088 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1089 ui::EF_CONTROL_DOWN,
1090 ui::ET_KEY_PRESSED,
1091 keycode_control_l_,
1092 ControlMask,
1093 KeyPress),
1094 GetRewrittenEventAsString(&rewriter,
1095 ui::VKEY_LWIN,
1096 ui::EF_ALT_DOWN,
1097 ui::ET_KEY_PRESSED,
1098 keycode_super_l_,
1099 Mod1Mask));
1100
1101 // Press Control+Alt+Search. Confirm the event is now VKEY_CONTROL +
1102 // XK_Control_L.
1103 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1104 ui::EF_CONTROL_DOWN,
1105 ui::ET_KEY_PRESSED,
1106 keycode_control_l_,
1107 ControlMask,
1108 KeyPress),
1109 GetRewrittenEventAsString(&rewriter,
1110 ui::VKEY_LWIN,
1111 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1112 ui::ET_KEY_PRESSED,
1113 keycode_super_l_,
1114 ControlMask | Mod1Mask));
1115
1116 // Press Shift+Control+Alt+Search. Confirm the event is now Control with
1117 // Shift and Control modifiers.
1118 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1119 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN,
1120 ui::ET_KEY_PRESSED,
1121 keycode_control_l_,
1122 ShiftMask | ControlMask,
1123 KeyPress),
1124 GetRewrittenEventAsString(&rewriter,
1125 ui::VKEY_LWIN,
1126 ui::EF_SHIFT_DOWN |
1127 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1128 ui::ET_KEY_PRESSED,
1129 keycode_super_l_,
1130 ShiftMask | ControlMask | Mod1Mask));
1131
1132 // Press Shift+Control+Alt+Search+B. Confirm the event is now B with Shift
1133 // and Control modifiers.
1134 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_B,
1135 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN,
1136 ui::ET_KEY_PRESSED,
1137 keycode_b_,
1138 ShiftMask | ControlMask,
1139 KeyPress),
1140 GetRewrittenEventAsString(&rewriter,
1141 ui::VKEY_B,
1142 ui::EF_SHIFT_DOWN |
1143 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1144 ui::ET_KEY_PRESSED,
1145 keycode_b_,
1146 ShiftMask | ControlMask | Mod1Mask));
1147 }
1148
1149 TEST_F(KeyRewriterTest, TestRewriteModifiersRemapMany) {
1150 // Remap Search to Alt.
1151 TestingPrefService prefs;
1152 chromeos::Preferences::RegisterUserPrefs(&prefs);
1153 IntegerPrefMember search;
1154 search.Init(prefs::kLanguageXkbRemapSearchKeyTo, &prefs, NULL);
1155 search.SetValue(chromeos::input_method::kAltKey);
1156
1157 KeyRewriter rewriter;
1158 rewriter.set_pref_service_for_testing(&prefs);
1159
1160 // Press Search. Confirm the event is now VKEY_MENU + XK_Alt_L.
1161 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
1162 0,
1163 ui::ET_KEY_PRESSED,
1164 keycode_alt_l_,
1165 0U,
1166 KeyPress),
1167 GetRewrittenEventAsString(&rewriter,
1168 ui::VKEY_LWIN,
1169 0,
1170 ui::ET_KEY_PRESSED,
1171 keycode_super_l_,
1172 0U));
1173
1174 // Remap Alt to Control.
1175 IntegerPrefMember alt;
1176 alt.Init(prefs::kLanguageXkbRemapAltKeyTo, &prefs, NULL);
1177 alt.SetValue(chromeos::input_method::kControlKey);
1178
1179 // Press left Alt. Confirm the event is now VKEY_CONTROL + XK_Control_L.
1180 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
1181 0,
1182 ui::ET_KEY_PRESSED,
1183 keycode_control_l_,
1184 0U,
1185 KeyPress),
1186 GetRewrittenEventAsString(&rewriter,
1187 ui::VKEY_MENU,
1188 0,
1189 ui::ET_KEY_PRESSED,
1190 keycode_alt_l_,
1191 0U));
1192
1193 // Remap Control to Search.
1194 IntegerPrefMember control;
1195 control.Init(prefs::kLanguageXkbRemapControlKeyTo, &prefs, NULL);
1196 control.SetValue(chromeos::input_method::kSearchKey);
1197
1198 // Press left Control. Confirm the event is now VKEY_LWIN.
1199 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_LWIN,
1200 0,
1201 ui::ET_KEY_PRESSED,
1202 keycode_super_l_,
1203 0U,
1204 KeyPress),
1205 GetRewrittenEventAsString(&rewriter,
1206 ui::VKEY_CONTROL,
1207 0,
1208 ui::ET_KEY_PRESSED,
1209 keycode_control_l_,
1210 0U));
1211
1212 // Then, press all of the three, Control+Alt+Search.
1213 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
1214 ui::EF_CONTROL_DOWN,
1215 ui::ET_KEY_PRESSED,
1216 keycode_alt_l_,
1217 ControlMask | Mod4Mask,
1218 KeyPress),
1219 GetRewrittenEventAsString(&rewriter,
1220 ui::VKEY_LWIN,
1221 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1222 ui::ET_KEY_PRESSED,
1223 keycode_super_l_,
1224 ControlMask | Mod1Mask));
1225
1226 // Press Shift+Control+Alt+Search.
1227 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
1228 ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN,
1229 ui::ET_KEY_PRESSED,
1230 keycode_alt_l_,
1231 ShiftMask | ControlMask | Mod4Mask,
1232 KeyPress),
1233 GetRewrittenEventAsString(&rewriter,
1234 ui::VKEY_LWIN,
1235 ui::EF_SHIFT_DOWN |
1236 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1237 ui::ET_KEY_PRESSED,
1238 keycode_super_l_,
1239 ShiftMask | ControlMask | Mod1Mask));
1240
1241 // Press Shift+Control+Alt+Search+B
1242 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_B,
1243 ui::EF_SHIFT_DOWN |
1244 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1245 ui::ET_KEY_PRESSED,
1246 keycode_b_,
1247 ShiftMask | ControlMask | Mod1Mask |
1248 Mod4Mask,
1249 KeyPress),
1250 GetRewrittenEventAsString(&rewriter,
1251 ui::VKEY_B,
1252 ui::EF_SHIFT_DOWN |
1253 ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
1254 ui::ET_KEY_PRESSED,
1255 keycode_b_,
1256 ShiftMask | ControlMask | Mod1Mask |
1257 Mod4Mask));
1258 }
1259
1260 TEST_F(KeyRewriterTest, TestRewriteModifiersRemapToCapsLock) {
1261 // Remap Search to Caps Lock.
1262 TestingPrefService prefs;
1263 chromeos::Preferences::RegisterUserPrefs(&prefs);
1264 IntegerPrefMember search;
1265 search.Init(prefs::kLanguageXkbRemapSearchKeyTo, &prefs, NULL);
1266 search.SetValue(chromeos::input_method::kCapsLockKey);
1267
1268 chromeos::input_method::MockXKeyboard xkeyboard;
1269 KeyRewriter rewriter;
1270 rewriter.set_pref_service_for_testing(&prefs);
1271 rewriter.set_xkeyboard_for_testing(&xkeyboard);
1272 EXPECT_FALSE(xkeyboard.caps_lock_is_enabled_);
1273
1274 // Press Search.
1275 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
1276 0,
1277 ui::ET_KEY_PRESSED,
1278 keycode_caps_lock_,
1279 0U,
1280 KeyPress),
1281 GetRewrittenEventAsString(&rewriter,
1282 ui::VKEY_LWIN,
1283 0,
1284 ui::ET_KEY_PRESSED,
1285 keycode_super_l_,
1286 0U));
1287 // Confirm that the Caps Lock status is changed.
1288 EXPECT_TRUE(xkeyboard.caps_lock_is_enabled_);
1289
1290 // Release Search.
1291 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
1292 ui::EF_CAPS_LOCK_DOWN,
1293 ui::ET_KEY_RELEASED,
1294 keycode_caps_lock_,
1295 LockMask,
1296 KeyRelease),
1297 GetRewrittenEventAsString(&rewriter,
1298 ui::VKEY_LWIN,
1299 ui::EF_CAPS_LOCK_DOWN,
1300 ui::ET_KEY_RELEASED,
1301 keycode_super_l_,
1302 Mod4Mask | LockMask));
1303 // Confirm that the Caps Lock status is not changed.
1304 EXPECT_TRUE(xkeyboard.caps_lock_is_enabled_);
1305
1306 // Press Search.
1307 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
1308 ui::EF_CAPS_LOCK_DOWN,
1309 ui::ET_KEY_PRESSED,
1310 keycode_caps_lock_,
1311 LockMask,
1312 KeyPress),
1313 GetRewrittenEventAsString(&rewriter,
1314 ui::VKEY_LWIN,
1315 ui::EF_CAPS_LOCK_DOWN,
1316 ui::ET_KEY_PRESSED,
1317 keycode_super_l_,
1318 LockMask));
1319 // Confirm that the Caps Lock status is changed.
1320 EXPECT_FALSE(xkeyboard.caps_lock_is_enabled_);
1321
1322 // Release Search.
1323 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
1324 ui::EF_CAPS_LOCK_DOWN,
1325 ui::ET_KEY_RELEASED,
1326 keycode_caps_lock_,
1327 LockMask,
1328 KeyRelease),
1329 GetRewrittenEventAsString(&rewriter,
1330 ui::VKEY_LWIN,
1331 ui::EF_CAPS_LOCK_DOWN,
1332 ui::ET_KEY_RELEASED,
1333 keycode_super_l_,
1334 Mod4Mask | LockMask));
1335 // Confirm that the Caps Lock status is not changed.
1336 EXPECT_FALSE(xkeyboard.caps_lock_is_enabled_);
1337
1338 // Press Caps Lock (on an external keyboard).
1339 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
1340 0,
1341 ui::ET_KEY_PRESSED,
1342 keycode_caps_lock_,
1343 0U,
1344 KeyPress),
1345 GetRewrittenEventAsString(&rewriter,
1346 ui::VKEY_CAPITAL,
1347 0,
1348 ui::ET_KEY_PRESSED,
1349 keycode_caps_lock_,
1350 0U));
1351
1352 // Confirm that calling RewriteForTesting() does not change the state of
1353 // |xkeyboard|. In this case, X Window system itself should change the
1354 // Caps Lock state, not ash::KeyRewriter.
1355 EXPECT_FALSE(xkeyboard.caps_lock_is_enabled_);
1356
1357 // Press Caps Lock (on an external keyboard).
1358 EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
1359 ui::EF_CAPS_LOCK_DOWN,
1360 ui::ET_KEY_RELEASED,
1361 keycode_caps_lock_,
1362 LockMask,
1363 KeyRelease),
1364 GetRewrittenEventAsString(&rewriter,
1365 ui::VKEY_CAPITAL,
1366 ui::EF_CAPS_LOCK_DOWN,
1367 ui::ET_KEY_RELEASED,
1368 keycode_caps_lock_,
1369 LockMask));
1370 EXPECT_FALSE(xkeyboard.caps_lock_is_enabled_);
1371 }
566 #endif // OS_CHROMEOS 1372 #endif // OS_CHROMEOS
OLDNEW
« no previous file with comments | « chrome/browser/ui/views/ash/key_rewriter.cc ('k') | chrome/chrome_browser.gypi » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698