1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/test/chromedriver/key_converter.h" 6 7 #include "base/format_macros.h" 8 #include "base/strings/stringprintf.h" 9 #include "base/strings/utf_string_conversions.h" 10 #include "chrome/test/chromedriver/chrome/status.h" 11 #include "chrome/test/chromedriver/chrome/ui_events.h" 12 #include "chrome/test/chromedriver/keycode_text_conversion.h" 13 14 namespace { 15 16 struct ModifierMaskAndKeyCode { 17 int mask; 18 ui::KeyboardCode key_code; 19 }; 20 21 const ModifierMaskAndKeyCode kModifiers[] = { 22 { kShiftKeyModifierMask, ui::VKEY_SHIFT }, 23 { kControlKeyModifierMask, ui::VKEY_CONTROL }, 24 { kAltKeyModifierMask, ui::VKEY_MENU } 25 }; 26 27 // TODO(kkania): Use this in KeyMap. 28 // Ordered list of all the key codes corresponding to special WebDriver keys. 29 // These WebDriver keys are defined in the Unicode Private Use Area. 30 // http://code.google.com/p/selenium/wiki/JsonWireProtocol#/session/:sessionId/element/:id/value 31 const ui::KeyboardCode kSpecialWebDriverKeys[] = { 32 ui::VKEY_UNKNOWN, 33 ui::VKEY_UNKNOWN, 34 ui::VKEY_HELP, 35 ui::VKEY_BACK, 36 ui::VKEY_TAB, 37 ui::VKEY_CLEAR, 38 ui::VKEY_RETURN, 39 ui::VKEY_RETURN, 40 ui::VKEY_SHIFT, 41 ui::VKEY_CONTROL, 42 ui::VKEY_MENU, 43 ui::VKEY_PAUSE, 44 ui::VKEY_ESCAPE, 45 ui::VKEY_SPACE, 46 ui::VKEY_PRIOR, // page up 47 ui::VKEY_NEXT, // page down 48 ui::VKEY_END, 49 ui::VKEY_HOME, 50 ui::VKEY_LEFT, 51 ui::VKEY_UP, 52 ui::VKEY_RIGHT, 53 ui::VKEY_DOWN, 54 ui::VKEY_INSERT, 55 ui::VKEY_DELETE, 56 ui::VKEY_OEM_1, // semicolon 57 ui::VKEY_OEM_PLUS, // equals 58 ui::VKEY_NUMPAD0, 59 ui::VKEY_NUMPAD1, 60 ui::VKEY_NUMPAD2, 61 ui::VKEY_NUMPAD3, 62 ui::VKEY_NUMPAD4, 63 ui::VKEY_NUMPAD5, 64 ui::VKEY_NUMPAD6, 65 ui::VKEY_NUMPAD7, 66 ui::VKEY_NUMPAD8, 67 ui::VKEY_NUMPAD9, 68 ui::VKEY_MULTIPLY, 69 ui::VKEY_ADD, 70 ui::VKEY_OEM_COMMA, 71 ui::VKEY_SUBTRACT, 72 ui::VKEY_DECIMAL, 73 ui::VKEY_DIVIDE, 74 ui::VKEY_UNKNOWN, 75 ui::VKEY_UNKNOWN, 76 ui::VKEY_UNKNOWN, 77 ui::VKEY_UNKNOWN, 78 ui::VKEY_UNKNOWN, 79 ui::VKEY_UNKNOWN, 80 ui::VKEY_UNKNOWN, 81 ui::VKEY_F1, 82 ui::VKEY_F2, 83 ui::VKEY_F3, 84 ui::VKEY_F4, 85 ui::VKEY_F5, 86 ui::VKEY_F6, 87 ui::VKEY_F7, 88 ui::VKEY_F8, 89 ui::VKEY_F9, 90 ui::VKEY_F10, 91 ui::VKEY_F11, 92 ui::VKEY_F12}; 93 94 const base::char16 kWebDriverNullKey = 0xE000U; 95 const base::char16 kWebDriverShiftKey = 0xE008U; 96 const base::char16 kWebDriverControlKey = 0xE009U; 97 const base::char16 kWebDriverAltKey = 0xE00AU; 98 const base::char16 kWebDriverCommandKey = 0xE03DU; 99 100 // Returns whether the given key code has a corresponding printable char. 101 // Notice: The given key code should be a special WebDriver key code. 102 bool IsSpecialKeyPrintable(ui::KeyboardCode key_code) { 103 return key_code == ui::VKEY_TAB || key_code == ui::VKEY_SPACE || 104 key_code == ui::VKEY_OEM_1 || key_code == ui::VKEY_OEM_PLUS || 105 key_code == ui::VKEY_OEM_COMMA || 106 (key_code >= ui::VKEY_NUMPAD0 && key_code <= ui::VKEY_DIVIDE); 107 } 108 109 // Returns whether the given key is a WebDriver key modifier. 110 bool IsModifierKey(base::char16 key) { 111 switch (key) { 112 case kWebDriverShiftKey: 113 case kWebDriverControlKey: 114 case kWebDriverAltKey: 115 case kWebDriverCommandKey: 116 return true; 117 default: 118 return false; 119 } 120 } 121 122 // Gets the key code associated with |key|, if it is a special WebDriver key. 123 // Returns whether |key| is a special WebDriver key. If true, |key_code| will 124 // be set. 125 bool KeyCodeFromSpecialWebDriverKey(base::char16 key, 126 ui::KeyboardCode* key_code) { 127 int index = static_cast<int>(key) - 0xE000U; 128 bool is_special_key = index >= 0 && 129 index < static_cast<int>(arraysize(kSpecialWebDriverKeys)); 130 if (is_special_key) 131 *key_code = kSpecialWebDriverKeys[index]; 132 return is_special_key; 133 } 134 135 // Gets the key code associated with |key_utf16|, if it is a special shorthand 136 // key. Shorthand keys are common text equivalents for keys, such as the newline 137 // character, which is shorthand for the return key. Returns whether |key| is 138 // a shorthand key. If true, |key_code| will be set and |client_should_skip| 139 // will be set to whether the key should be skipped. 140 bool KeyCodeFromShorthandKey(base::char16 key_utf16, 141 ui::KeyboardCode* key_code, 142 bool* client_should_skip) { 143 base::string16 key_str_utf16; 144 key_str_utf16.push_back(key_utf16); 145 std::string key_str_utf8 = base::UTF16ToUTF8(key_str_utf16); 146 if (key_str_utf8.length() != 1) 147 return false; 148 bool should_skip = false; 149 char key = key_str_utf8[0]; 150 if (key == '\n') { 151 *key_code = ui::VKEY_RETURN; 152 } else if (key == '\t') { 153 *key_code = ui::VKEY_TAB; 154 } else if (key == '\b') { 155 *key_code = ui::VKEY_BACK; 156 } else if (key == ' ') { 157 *key_code = ui::VKEY_SPACE; 158 } else if (key == '\r') { 159 *key_code = ui::VKEY_UNKNOWN; 160 should_skip = true; 161 } else { 162 return false; 163 } 164 *client_should_skip = should_skip; 165 return true; 166 } 167 168 } // namespace 169 170 KeyEvent CreateKeyDownEvent(ui::KeyboardCode key_code, int modifiers) { 171 return KeyEvent( 172 kRawKeyDownEventType, modifiers, std::string(), std::string(), key_code); 173 } 174 175 KeyEvent CreateKeyUpEvent(ui::KeyboardCode key_code, int modifiers) { 176 return KeyEvent( 177 kKeyUpEventType, modifiers, std::string(), std::string(), key_code); 178 } 179 180 KeyEvent CreateCharEvent(const std::string& unmodified_text, 181 const std::string& modified_text, 182 int modifiers) { 183 return KeyEvent(kCharEventType, 184 modifiers, 185 modified_text, 186 unmodified_text, 187 ui::VKEY_UNKNOWN); 188 } 189 190 Status ConvertKeysToKeyEvents(const base::string16& client_keys, 191 bool release_modifiers, 192 int* modifiers, 193 std::list<KeyEvent>* client_key_events) { 194 std::list<KeyEvent> key_events; 195 196 base::string16 keys = client_keys; 197 // Add an implicit NULL character to the end of the input to depress all 198 // modifiers. 199 if (release_modifiers) 200 keys.push_back(kWebDriverNullKey); 201 202 int sticky_modifiers = *modifiers; 203 for (size_t i = 0; i < keys.size(); ++i) { 204 base::char16 key = keys[i]; 205 206 if (key == kWebDriverNullKey) { 207 // Release all modifier keys and clear |stick_modifiers|. 208 if (sticky_modifiers & kShiftKeyModifierMask) 209 key_events.push_back(CreateKeyUpEvent(ui::VKEY_SHIFT, 0)); 210 if (sticky_modifiers & kControlKeyModifierMask) 211 key_events.push_back(CreateKeyUpEvent(ui::VKEY_CONTROL, 0)); 212 if (sticky_modifiers & kAltKeyModifierMask) 213 key_events.push_back(CreateKeyUpEvent(ui::VKEY_MENU, 0)); 214 if (sticky_modifiers & kMetaKeyModifierMask) 215 key_events.push_back(CreateKeyUpEvent(ui::VKEY_COMMAND, 0)); 216 sticky_modifiers = 0; 217 continue; 218 } 219 if (IsModifierKey(key)) { 220 // Press or release the modifier, and adjust |sticky_modifiers|. 221 bool modifier_down = false; 222 ui::KeyboardCode key_code = ui::VKEY_UNKNOWN; 223 if (key == kWebDriverShiftKey) { 224 sticky_modifiers ^= kShiftKeyModifierMask; 225 modifier_down = (sticky_modifiers & kShiftKeyModifierMask) != 0; 226 key_code = ui::VKEY_SHIFT; 227 } else if (key == kWebDriverControlKey) { 228 sticky_modifiers ^= kControlKeyModifierMask; 229 modifier_down = (sticky_modifiers & kControlKeyModifierMask) != 0; 230 key_code = ui::VKEY_CONTROL; 231 } else if (key == kWebDriverAltKey) { 232 sticky_modifiers ^= kAltKeyModifierMask; 233 modifier_down = (sticky_modifiers & kAltKeyModifierMask) != 0; 234 key_code = ui::VKEY_MENU; 235 } else if (key == kWebDriverCommandKey) { 236 sticky_modifiers ^= kMetaKeyModifierMask; 237 modifier_down = (sticky_modifiers & kMetaKeyModifierMask) != 0; 238 key_code = ui::VKEY_COMMAND; 239 } else { 240 return Status(kUnknownError, "unknown modifier key"); 241 } 242 if (modifier_down) 243 key_events.push_back(CreateKeyDownEvent(key_code, sticky_modifiers)); 244 else 245 key_events.push_back(CreateKeyUpEvent(key_code, sticky_modifiers)); 246 continue; 247 } 248 249 ui::KeyboardCode key_code = ui::VKEY_UNKNOWN; 250 std::string unmodified_text, modified_text; 251 int all_modifiers = sticky_modifiers; 252 253 // Get the key code, text, and modifiers for the given key. 254 bool should_skip = false; 255 bool is_special_key = KeyCodeFromSpecialWebDriverKey(key, &key_code); 256 std::string error_msg; 257 if (is_special_key || 258 KeyCodeFromShorthandKey(key, &key_code, &should_skip)) { 259 if (should_skip) 260 continue; 261 if (key_code == ui::VKEY_UNKNOWN) { 262 return Status(kUnknownError, base::StringPrintf( 263 "unknown WebDriver key(%d) at string index (%" PRIuS ")", 264 static_cast<int>(key), 265 i)); 266 } 267 if (key_code == ui::VKEY_RETURN) { 268 // For some reason Chrome expects a carriage return for the return key. 269 modified_text = unmodified_text = "\r"; 270 } else if (is_special_key && !IsSpecialKeyPrintable(key_code)) { 271 // To prevent char event for special keys like DELETE. 272 modified_text = unmodified_text = std::string(); 273 } else { 274 // WebDriver assumes a numpad key should translate to the number, 275 // which requires NumLock to be on with some platforms. This isn't 276 // formally in the spec, but is expected by their tests. 277 int webdriver_modifiers = 0; 278 if (key_code >= ui::VKEY_NUMPAD0 && key_code <= ui::VKEY_NUMPAD9) 279 webdriver_modifiers = kNumLockKeyModifierMask; 280 if (!ConvertKeyCodeToText( 281 key_code, webdriver_modifiers, &unmodified_text, &error_msg)) 282 return Status(kUnknownError, error_msg); 283 if (!ConvertKeyCodeToText( 284 key_code, all_modifiers | webdriver_modifiers, &modified_text, 285 &error_msg)) 286 return Status(kUnknownError, error_msg); 287 } 288 } else { 289 int necessary_modifiers = 0; 290 ConvertCharToKeyCode(key, &key_code, &necessary_modifiers, &error_msg); 291 if (!error_msg.empty()) 292 return Status(kUnknownError, error_msg); 293 all_modifiers |= necessary_modifiers; 294 if (key_code != ui::VKEY_UNKNOWN) { 295 if (!ConvertKeyCodeToText(key_code, 0, &unmodified_text, &error_msg)) 296 return Status(kUnknownError, error_msg); 297 if (!ConvertKeyCodeToText( 298 key_code, all_modifiers, &modified_text, &error_msg)) 299 return Status(kUnknownError, error_msg); 300 if (unmodified_text.empty() || modified_text.empty()) { 301 // To prevent char event for special cases like CTRL + x (cut). 302 unmodified_text.clear(); 303 modified_text.clear(); 304 } 305 } else { 306 // Do a best effort and use the raw key we were given. 307 unmodified_text = base::UTF16ToUTF8(keys.substr(i, 1)); 308 modified_text = base::UTF16ToUTF8(keys.substr(i, 1)); 309 } 310 } 311 312 // Create the key events. 313 bool necessary_modifiers[3]; 314 for (int i = 0; i < 3; ++i) { 315 necessary_modifiers[i] = 316 all_modifiers & kModifiers[i].mask && 317 !(sticky_modifiers & kModifiers[i].mask); 318 if (necessary_modifiers[i]) { 319 key_events.push_back( 320 CreateKeyDownEvent(kModifiers[i].key_code, sticky_modifiers)); 321 } 322 } 323 324 key_events.push_back(CreateKeyDownEvent(key_code, all_modifiers)); 325 if (unmodified_text.length() || modified_text.length()) { 326 key_events.push_back( 327 CreateCharEvent(unmodified_text, modified_text, all_modifiers)); 328 } 329 key_events.push_back(CreateKeyUpEvent(key_code, all_modifiers)); 330 331 for (int i = 2; i > -1; --i) { 332 if (necessary_modifiers[i]) { 333 key_events.push_back( 334 CreateKeyUpEvent(kModifiers[i].key_code, sticky_modifiers)); 335 } 336 } 337 } 338 client_key_events->swap(key_events); 339 *modifiers = sticky_modifiers; 340 return Status(kOk); 341 } 342
