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 3 // found in the LICENSE file. 4 5 #include "chrome/common/extensions/command.h" 6 7 #include "base/logging.h" 8 #include "base/strings/string_number_conversions.h" 9 #include "base/strings/string_split.h" 10 #include "base/strings/string_util.h" 11 #include "base/values.h" 12 #include "extensions/common/error_utils.h" 13 #include "extensions/common/extension.h" 14 #include "extensions/common/feature_switch.h" 15 #include "extensions/common/manifest_constants.h" 16 #include "grit/generated_resources.h" 17 #include "ui/base/l10n/l10n_util.h" 18 19 namespace extensions { 20 21 namespace errors = manifest_errors; 22 namespace keys = manifest_keys; 23 namespace values = manifest_values; 24 25 namespace { 26 27 static const char kMissing[] = "Missing"; 28 29 static const char kCommandKeyNotSupported[] = 30 "Command key is not supported. Note: Ctrl means Command on Mac"; 31 32 bool IsNamedCommand(const std::string& command_name) { 33 return command_name != values::kPageActionCommandEvent && 34 command_name != values::kBrowserActionCommandEvent; 35 } 36 37 bool DoesRequireModifier(const std::string& accelerator) { 38 return accelerator != values::kKeyMediaNextTrack && 39 accelerator != values::kKeyMediaPlayPause && 40 accelerator != values::kKeyMediaPrevTrack && 41 accelerator != values::kKeyMediaStop; 42 } 43 44 ui::Accelerator ParseImpl(const std::string& accelerator, 45 const std::string& platform_key, 46 int index, 47 bool should_parse_media_keys, 48 base::string16* error) { 49 error->clear(); 50 if (platform_key != values::kKeybindingPlatformWin && 51 platform_key != values::kKeybindingPlatformMac && 52 platform_key != values::kKeybindingPlatformChromeOs && 53 platform_key != values::kKeybindingPlatformLinux && 54 platform_key != values::kKeybindingPlatformDefault) { 55 *error = ErrorUtils::FormatErrorMessageUTF16( 56 errors::kInvalidKeyBindingUnknownPlatform, 57 base::IntToString(index), 58 platform_key); 59 return ui::Accelerator(); 60 } 61 62 std::vector<std::string> tokens; 63 base::SplitString(accelerator, '+', &tokens); 64 if (tokens.size() == 0 || 65 (tokens.size() == 1 && DoesRequireModifier(accelerator)) || 66 tokens.size() > 3) { 67 *error = ErrorUtils::FormatErrorMessageUTF16( 68 errors::kInvalidKeyBinding, 69 base::IntToString(index), 70 platform_key, 71 accelerator); 72 return ui::Accelerator(); 73 } 74 75 // Now, parse it into an accelerator. 76 int modifiers = ui::EF_NONE; 77 ui::KeyboardCode key = ui::VKEY_UNKNOWN; 78 for (size_t i = 0; i < tokens.size(); i++) { 79 if (tokens[i] == values::kKeyCtrl) { 80 modifiers |= ui::EF_CONTROL_DOWN; 81 } else if (tokens[i] == values::kKeyCommand) { 82 if (platform_key == values::kKeybindingPlatformMac) { 83 // Either the developer specified Command+foo in the manifest for Mac or 84 // they specified Ctrl and it got normalized to Command (to get Ctrl on 85 // Mac the developer has to specify MacCtrl). Therefore we treat this 86 // as Command. 87 modifiers |= ui::EF_COMMAND_DOWN; 88 #if defined(OS_MACOSX) 89 } else if (platform_key == values::kKeybindingPlatformDefault) { 90 // If we see "Command+foo" in the Default section it can mean two 91 // things, depending on the platform: 92 // The developer specified "Ctrl+foo" for Default and it got normalized 93 // on Mac to "Command+foo". This is fine. Treat it as Command. 94 modifiers |= ui::EF_COMMAND_DOWN; 95 #endif 96 } else { 97 // No other platform supports Command. 98 key = ui::VKEY_UNKNOWN; 99 break; 100 } 101 } else if (tokens[i] == values::kKeyAlt) { 102 modifiers |= ui::EF_ALT_DOWN; 103 } else if (tokens[i] == values::kKeyShift) { 104 modifiers |= ui::EF_SHIFT_DOWN; 105 } else if (tokens[i].size() == 1 || // A-Z, 0-9. 106 tokens[i] == values::kKeyComma || 107 tokens[i] == values::kKeyPeriod || 108 tokens[i] == values::kKeyUp || 109 tokens[i] == values::kKeyDown || 110 tokens[i] == values::kKeyLeft || 111 tokens[i] == values::kKeyRight || 112 tokens[i] == values::kKeyIns || 113 tokens[i] == values::kKeyDel || 114 tokens[i] == values::kKeyHome || 115 tokens[i] == values::kKeyEnd || 116 tokens[i] == values::kKeyPgUp || 117 tokens[i] == values::kKeyPgDwn || 118 tokens[i] == values::kKeyTab || 119 tokens[i] == values::kKeyMediaNextTrack || 120 tokens[i] == values::kKeyMediaPlayPause || 121 tokens[i] == values::kKeyMediaPrevTrack || 122 tokens[i] == values::kKeyMediaStop) { 123 if (key != ui::VKEY_UNKNOWN) { 124 // Multiple key assignments. 125 key = ui::VKEY_UNKNOWN; 126 break; 127 } 128 129 if (tokens[i] == values::kKeyComma) { 130 key = ui::VKEY_OEM_COMMA; 131 } else if (tokens[i] == values::kKeyPeriod) { 132 key = ui::VKEY_OEM_PERIOD; 133 } else if (tokens[i] == values::kKeyUp) { 134 key = ui::VKEY_UP; 135 } else if (tokens[i] == values::kKeyDown) { 136 key = ui::VKEY_DOWN; 137 } else if (tokens[i] == values::kKeyLeft) { 138 key = ui::VKEY_LEFT; 139 } else if (tokens[i] == values::kKeyRight) { 140 key = ui::VKEY_RIGHT; 141 } else if (tokens[i] == values::kKeyIns) { 142 key = ui::VKEY_INSERT; 143 } else if (tokens[i] == values::kKeyDel) { 144 key = ui::VKEY_DELETE; 145 } else if (tokens[i] == values::kKeyHome) { 146 key = ui::VKEY_HOME; 147 } else if (tokens[i] == values::kKeyEnd) { 148 key = ui::VKEY_END; 149 } else if (tokens[i] == values::kKeyPgUp) { 150 key = ui::VKEY_PRIOR; 151 } else if (tokens[i] == values::kKeyPgDwn) { 152 key = ui::VKEY_NEXT; 153 } else if (tokens[i] == values::kKeyTab) { 154 key = ui::VKEY_TAB; 155 } else if (tokens[i] == values::kKeyMediaNextTrack && 156 should_parse_media_keys) { 157 key = ui::VKEY_MEDIA_NEXT_TRACK; 158 } else if (tokens[i] == values::kKeyMediaPlayPause && 159 should_parse_media_keys) { 160 key = ui::VKEY_MEDIA_PLAY_PAUSE; 161 } else if (tokens[i] == values::kKeyMediaPrevTrack && 162 should_parse_media_keys) { 163 key = ui::VKEY_MEDIA_PREV_TRACK; 164 } else if (tokens[i] == values::kKeyMediaStop && 165 should_parse_media_keys) { 166 key = ui::VKEY_MEDIA_STOP; 167 } else if (tokens[i].size() == 1 && 168 tokens[i][0] >= 'A' && tokens[i][0] <= 'Z') { 169 key = static_cast<ui::KeyboardCode>(ui::VKEY_A + (tokens[i][0] - 'A')); 170 } else if (tokens[i].size() == 1 && 171 tokens[i][0] >= '0' && tokens[i][0] <= '9') { 172 key = static_cast<ui::KeyboardCode>(ui::VKEY_0 + (tokens[i][0] - '0')); 173 } else { 174 key = ui::VKEY_UNKNOWN; 175 break; 176 } 177 } else { 178 *error = ErrorUtils::FormatErrorMessageUTF16( 179 errors::kInvalidKeyBinding, 180 base::IntToString(index), 181 platform_key, 182 accelerator); 183 return ui::Accelerator(); 184 } 185 } 186 187 bool command = (modifiers & ui::EF_COMMAND_DOWN) != 0; 188 bool ctrl = (modifiers & ui::EF_CONTROL_DOWN) != 0; 189 bool alt = (modifiers & ui::EF_ALT_DOWN) != 0; 190 bool shift = (modifiers & ui::EF_SHIFT_DOWN) != 0; 191 192 // We support Ctrl+foo, Alt+foo, Ctrl+Shift+foo, Alt+Shift+foo, but not 193 // Ctrl+Alt+foo and not Shift+foo either. For a more detailed reason why we 194 // don't support Ctrl+Alt+foo see this article: 195 // http://blogs.msdn.com/b/oldnewthing/archive/2004/03/29/101121.aspx. 196 // On Mac Command can also be used in combination with Shift or on its own, 197 // as a modifier. 198 if (key == ui::VKEY_UNKNOWN || (ctrl && alt) || (command && alt) || 199 (shift && !ctrl && !alt && !command)) { 200 *error = ErrorUtils::FormatErrorMessageUTF16( 201 errors::kInvalidKeyBinding, 202 base::IntToString(index), 203 platform_key, 204 accelerator); 205 return ui::Accelerator(); 206 } 207 208 if ((key == ui::VKEY_MEDIA_NEXT_TRACK || 209 key == ui::VKEY_MEDIA_PREV_TRACK || 210 key == ui::VKEY_MEDIA_PLAY_PAUSE || 211 key == ui::VKEY_MEDIA_STOP) && 212 (shift || ctrl || alt || command)) { 213 *error = ErrorUtils::FormatErrorMessageUTF16( 214 errors::kInvalidKeyBindingMediaKeyWithModifier, 215 base::IntToString(index), 216 platform_key, 217 accelerator); 218 return ui::Accelerator(); 219 } 220 221 return ui::Accelerator(key, modifiers); 222 } 223 224 // For Mac, we convert "Ctrl" to "Command" and "MacCtrl" to "Ctrl". Other 225 // platforms leave the shortcut untouched. 226 std::string NormalizeShortcutSuggestion(const std::string& suggestion, 227 const std::string& platform) { 228 bool normalize = false; 229 if (platform == values::kKeybindingPlatformMac) { 230 normalize = true; 231 } else if (platform == values::kKeybindingPlatformDefault) { 232 #if defined(OS_MACOSX) 233 normalize = true; 234 #endif 235 } 236 237 if (!normalize) 238 return suggestion; 239 240 std::vector<std::string> tokens; 241 base::SplitString(suggestion, '+', &tokens); 242 for (size_t i = 0; i < tokens.size(); i++) { 243 if (tokens[i] == values::kKeyCtrl) 244 tokens[i] = values::kKeyCommand; 245 else if (tokens[i] == values::kKeyMacCtrl) 246 tokens[i] = values::kKeyCtrl; 247 } 248 return JoinString(tokens, '+'); 249 } 250 251 } // namespace 252 253 Command::Command() : global_(false) {} 254 255 Command::Command(const std::string& command_name, 256 const base::string16& description, 257 const std::string& accelerator, 258 bool global) 259 : command_name_(command_name), 260 description_(description), 261 global_(global) { 262 base::string16 error; 263 accelerator_ = ParseImpl(accelerator, CommandPlatform(), 0, 264 IsNamedCommand(command_name), &error); 265 } 266 267 Command::~Command() {} 268 269 // static 270 std::string Command::CommandPlatform() { 271 #if defined(OS_WIN) 272 return values::kKeybindingPlatformWin; 273 #elif defined(OS_MACOSX) 274 return values::kKeybindingPlatformMac; 275 #elif defined(OS_CHROMEOS) 276 return values::kKeybindingPlatformChromeOs; 277 #elif defined(OS_LINUX) 278 return values::kKeybindingPlatformLinux; 279 #else 280 return ""; 281 #endif 282 } 283 284 // static 285 ui::Accelerator Command::StringToAccelerator(const std::string& accelerator, 286 const std::string& command_name) { 287 base::string16 error; 288 ui::Accelerator parsed = 289 ParseImpl(accelerator, Command::CommandPlatform(), 0, 290 IsNamedCommand(command_name), &error); 291 return parsed; 292 } 293 294 // static 295 std::string Command::AcceleratorToString(const ui::Accelerator& accelerator) { 296 std::string shortcut; 297 298 // Ctrl and Alt are mutually exclusive. 299 if (accelerator.IsCtrlDown()) 300 shortcut += values::kKeyCtrl; 301 else if (accelerator.IsAltDown()) 302 shortcut += values::kKeyAlt; 303 if (!shortcut.empty()) 304 shortcut += values::kKeySeparator; 305 306 if (accelerator.IsCmdDown()) { 307 shortcut += values::kKeyCommand; 308 shortcut += values::kKeySeparator; 309 } 310 311 if (accelerator.IsShiftDown()) { 312 shortcut += values::kKeyShift; 313 shortcut += values::kKeySeparator; 314 } 315 316 if (accelerator.key_code() >= ui::VKEY_0 && 317 accelerator.key_code() <= ui::VKEY_9) { 318 shortcut += '0' + (accelerator.key_code() - ui::VKEY_0); 319 } else if (accelerator.key_code() >= ui::VKEY_A && 320 accelerator.key_code() <= ui::VKEY_Z) { 321 shortcut += 'A' + (accelerator.key_code() - ui::VKEY_A); 322 } else { 323 switch (accelerator.key_code()) { 324 case ui::VKEY_OEM_COMMA: 325 shortcut += values::kKeyComma; 326 break; 327 case ui::VKEY_OEM_PERIOD: 328 shortcut += values::kKeyPeriod; 329 break; 330 case ui::VKEY_UP: 331 shortcut += values::kKeyUp; 332 break; 333 case ui::VKEY_DOWN: 334 shortcut += values::kKeyDown; 335 break; 336 case ui::VKEY_LEFT: 337 shortcut += values::kKeyLeft; 338 break; 339 case ui::VKEY_RIGHT: 340 shortcut += values::kKeyRight; 341 break; 342 case ui::VKEY_INSERT: 343 shortcut += values::kKeyIns; 344 break; 345 case ui::VKEY_DELETE: 346 shortcut += values::kKeyDel; 347 break; 348 case ui::VKEY_HOME: 349 shortcut += values::kKeyHome; 350 break; 351 case ui::VKEY_END: 352 shortcut += values::kKeyEnd; 353 break; 354 case ui::VKEY_PRIOR: 355 shortcut += values::kKeyPgUp; 356 break; 357 case ui::VKEY_NEXT: 358 shortcut += values::kKeyPgDwn; 359 break; 360 case ui::VKEY_TAB: 361 shortcut += values::kKeyTab; 362 break; 363 case ui::VKEY_MEDIA_NEXT_TRACK: 364 shortcut += values::kKeyMediaNextTrack; 365 break; 366 case ui::VKEY_MEDIA_PLAY_PAUSE: 367 shortcut += values::kKeyMediaPlayPause; 368 break; 369 case ui::VKEY_MEDIA_PREV_TRACK: 370 shortcut += values::kKeyMediaPrevTrack; 371 break; 372 case ui::VKEY_MEDIA_STOP: 373 shortcut += values::kKeyMediaStop; 374 break; 375 default: 376 return ""; 377 } 378 } 379 return shortcut; 380 } 381 382 // static 383 bool Command::IsMediaKey(const ui::Accelerator& accelerator) { 384 if (accelerator.modifiers() != 0) 385 return false; 386 387 return (accelerator.key_code() == ui::VKEY_MEDIA_NEXT_TRACK || 388 accelerator.key_code() == ui::VKEY_MEDIA_PREV_TRACK || 389 accelerator.key_code() == ui::VKEY_MEDIA_PLAY_PAUSE || 390 accelerator.key_code() == ui::VKEY_MEDIA_STOP); 391 } 392 393 bool Command::Parse(const base::DictionaryValue* command, 394 const std::string& command_name, 395 int index, 396 base::string16* error) { 397 DCHECK(!command_name.empty()); 398 399 base::string16 description; 400 if (IsNamedCommand(command_name)) { 401 if (!command->GetString(keys::kDescription, &description) || 402 description.empty()) { 403 *error = ErrorUtils::FormatErrorMessageUTF16( 404 errors::kInvalidKeyBindingDescription, 405 base::IntToString(index)); 406 return false; 407 } 408 } 409 410 // We'll build up a map of platform-to-shortcut suggestions. 411 typedef std::map<const std::string, std::string> SuggestionMap; 412 SuggestionMap suggestions; 413 414 // First try to parse the |suggested_key| as a dictionary. 415 const base::DictionaryValue* suggested_key_dict; 416 if (command->GetDictionary(keys::kSuggestedKey, &suggested_key_dict)) { 417 for (base::DictionaryValue::Iterator iter(*suggested_key_dict); 418 !iter.IsAtEnd(); iter.Advance()) { 419 // For each item in the dictionary, extract the platforms specified. 420 std::string suggested_key_string; 421 if (iter.value().GetAsString(&suggested_key_string) && 422 !suggested_key_string.empty()) { 423 // Found a platform, add it to the suggestions list. 424 suggestions[iter.key()] = suggested_key_string; 425 } else { 426 *error = ErrorUtils::FormatErrorMessageUTF16( 427 errors::kInvalidKeyBinding, 428 base::IntToString(index), 429 keys::kSuggestedKey, 430 kMissing); 431 return false; 432 } 433 } 434 } else { 435 // No dictionary was found, fall back to using just a string, so developers 436 // don't have to specify a dictionary if they just want to use one default 437 // for all platforms. 438 std::string suggested_key_string; 439 if (command->GetString(keys::kSuggestedKey, &suggested_key_string) && 440 !suggested_key_string.empty()) { 441 // If only a single string is provided, it must be default for all. 442 suggestions[values::kKeybindingPlatformDefault] = suggested_key_string; 443 } else { 444 suggestions[values::kKeybindingPlatformDefault] = ""; 445 } 446 } 447 448 // Check if this is a global or a regular shortcut. 449 bool global = false; 450 if (FeatureSwitch::global_commands()->IsEnabled()) 451 command->GetBoolean(keys::kGlobal, &global); 452 453 // Normalize the suggestions. 454 for (SuggestionMap::iterator iter = suggestions.begin(); 455 iter != suggestions.end(); ++iter) { 456 // Before we normalize Ctrl to Command we must detect when the developer 457 // specified Command in the Default section, which will work on Mac after 458 // normalization but only fail on other platforms when they try it out on 459 // other platforms, which is not what we want. 460 if (iter->first == values::kKeybindingPlatformDefault && 461 iter->second.find("Command+") != std::string::npos) { 462 *error = ErrorUtils::FormatErrorMessageUTF16( 463 errors::kInvalidKeyBinding, 464 base::IntToString(index), 465 keys::kSuggestedKey, 466 kCommandKeyNotSupported); 467 return false; 468 } 469 470 suggestions[iter->first] = NormalizeShortcutSuggestion(iter->second, 471 iter->first); 472 } 473 474 std::string platform = CommandPlatform(); 475 std::string key = platform; 476 if (suggestions.find(key) == suggestions.end()) 477 key = values::kKeybindingPlatformDefault; 478 if (suggestions.find(key) == suggestions.end()) { 479 *error = ErrorUtils::FormatErrorMessageUTF16( 480 errors::kInvalidKeyBindingMissingPlatform, 481 base::IntToString(index), 482 keys::kSuggestedKey, 483 platform); 484 return false; // No platform specified and no fallback. Bail. 485 } 486 487 // For developer convenience, we parse all the suggestions (and complain about 488 // errors for platforms other than the current one) but use only what we need. 489 std::map<const std::string, std::string>::const_iterator iter = 490 suggestions.begin(); 491 for ( ; iter != suggestions.end(); ++iter) { 492 ui::Accelerator accelerator; 493 if (!iter->second.empty()) { 494 // Note that we pass iter->first to pretend we are on a platform we're not 495 // on. 496 accelerator = ParseImpl(iter->second, iter->first, index, 497 IsNamedCommand(command_name), error); 498 if (accelerator.key_code() == ui::VKEY_UNKNOWN) { 499 if (error->empty()) { 500 *error = ErrorUtils::FormatErrorMessageUTF16( 501 errors::kInvalidKeyBinding, 502 base::IntToString(index), 503 iter->first, 504 iter->second); 505 } 506 return false; 507 } 508 } 509 510 if (iter->first == key) { 511 // This platform is our platform, so grab this key. 512 accelerator_ = accelerator; 513 command_name_ = command_name; 514 description_ = description; 515 global_ = global; 516 } 517 } 518 return true; 519 } 520 521 base::DictionaryValue* Command::ToValue(const Extension* extension, 522 bool active) const { 523 base::DictionaryValue* extension_data = new base::DictionaryValue(); 524 525 base::string16 command_description; 526 bool extension_action = false; 527 if (command_name() == values::kBrowserActionCommandEvent || 528 command_name() == values::kPageActionCommandEvent) { 529 command_description = 530 l10n_util::GetStringUTF16(IDS_EXTENSION_COMMANDS_GENERIC_ACTIVATE); 531 extension_action = true; 532 } else { 533 command_description = description(); 534 } 535 extension_data->SetString("description", command_description); 536 extension_data->SetBoolean("active", active); 537 extension_data->SetString("keybinding", accelerator().GetShortcutText()); 538 extension_data->SetString("command_name", command_name()); 539 extension_data->SetString("extension_id", extension->id()); 540 extension_data->SetBoolean("global", global()); 541 extension_data->SetBoolean("extension_action", extension_action); 542 543 if (FeatureSwitch::global_commands()->IsEnabled()) 544 extension_data->SetBoolean("scope_ui_visible", true); 545 546 return extension_data; 547 } 548 549 } // namespace extensions 550
