Support more keys for the Commands API:

Arrow keys, Home, End, Ins, Del, PgUp, PgDwn, Tab, Comma and Period.

Since the names of these keys are localizable (unlike A-Z, 0-9 -- that were the only keys we supported before), we need to stop relying on Accelerator::GetShortcutText (which localizes the string it returns).

BUG=232884
TBR=willchan, sky

Review URL: https://chromiumcodereview.appspot.com/14533005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@199730 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 309 insertions, 29 deletions

diff --git a/chrome/browser/extensions/api/commands/command_service.cc b/chrome/browser/extensions/api/commands/command_service.cc
index 4717da2..90e65ab 100644
--- a/chrome/browser/extensions/api/commands/command_service.cc
+++ b/chrome/browser/extensions/api/commands/command_service.cc
@@ -37,7 +37,7 @@ const char kInitialBindingsHaveBeenAssigned[] = "initial_keybindings_set";
 std::string GetPlatformKeybindingKeyForAccelerator(
     const ui::Accelerator& accelerator) {
   return extensions::Command::CommandPlatform() + ":" +
-         UTF16ToUTF8(accelerator.GetShortcutText());
+         extensions::Command::AcceleratorToString(accelerator);
 }
 
 void SetInitialBindingsHaveBeenAssigned(
diff --git a/chrome/browser/resources/extensions/extension_command_list.js b/chrome/browser/resources/extensions/extension_command_list.js
index 16901ec..d730c9d 100644
--- a/chrome/browser/resources/extensions/extension_command_list.js
+++ b/chrome/browser/resources/extensions/extension_command_list.js
@@ -13,6 +13,20 @@ cr.define('options', function() {
    */
   var ExtensionCommandList = cr.ui.define('div');
 
+  /** @const */ var keyComma = 188;
+  /** @const */ var keyDel = 46;
+  /** @const */ var keyDown = 40;
+  /** @const */ var keyEnd = 35;
+  /** @const */ var keyHome = 36;
+  /** @const */ var keyIns = 45;
+  /** @const */ var keyLeft = 37;
+  /** @const */ var keyPageDown = 34;
+  /** @const */ var keyPageUp = 33;
+  /** @const */ var keyPeriod = 190;
+  /** @const */ var keyRight = 39;
+  /** @const */ var keyTab = 9;
+  /** @const */ var keyUp = 38;
+
   /**
    * Returns whether the passed in |keyCode| is a valid extension command
    * char or not. This is restricted to A-Z and 0-9 (ignoring modifiers) at
@@ -21,7 +35,20 @@ cr.define('options', function() {
    * @return {boolean} Returns whether the char is valid.
    */
   function validChar(keyCode) {
-    return (keyCode >= 'A'.charCodeAt(0) && keyCode <= 'Z'.charCodeAt(0)) ||
+    return keyCode == keyComma ||
+           keyCode == keyDel ||
+           keyCode == keyDown ||
+           keyCode == keyEnd ||
+           keyCode == keyHome ||
+           keyCode == keyIns ||
+           keyCode == keyLeft ||
+           keyCode == keyPageDown ||
+           keyCode == keyPageUp ||
+           keyCode == keyPeriod ||
+           keyCode == keyRight ||
+           keyCode == keyTab ||
+           keyCode == keyUp ||
+           (keyCode >= 'A'.charCodeAt(0) && keyCode <= 'Z'.charCodeAt(0)) ||
            (keyCode >= '0'.charCodeAt(0) && keyCode <= '9'.charCodeAt(0));
   }
 
@@ -41,8 +68,44 @@ cr.define('options', function() {
       output += 'Alt+';
     if (event.shiftKey)
       output += 'Shift+';
-    if (validChar(event.keyCode))
-      output += String.fromCharCode('A'.charCodeAt(0) + event.keyCode - 65);
+
+    var keyCode = event.keyCode;
+    if (validChar(keyCode)) {
+      if ((keyCode >= 'A'.charCodeAt(0) && keyCode <= 'Z'.charCodeAt(0)) ||
+          (keyCode >= '0'.charCodeAt(0) && keyCode <= '9'.charCodeAt(0))) {
+        output += String.fromCharCode('A'.charCodeAt(0) + keyCode - 65);
+      } else {
+        switch (keyCode) {
+          case keyComma:
+            output += 'Comma'; break;
+          case keyDel:
+            output += 'Delete'; break;
+          case keyDown:
+            output += 'Down'; break;
+          case keyEnd:
+            output += 'End'; break;
+          case keyHome:
+            output += 'Home'; break;
+          case keyIns:
+            output += 'Insert'; break;
+          case keyLeft:
+            output += 'Left'; break;
+          case keyPageDown:
+            output += 'PageDown'; break;
+          case keyPageUp:
+            output += 'PageUp'; break;
+          case keyPeriod:
+            output += 'Period'; break;
+          case keyRight:
+            output += 'Right'; break;
+          case keyTab:
+            output += 'Tab'; break;
+          case keyUp:
+            output += 'Up'; break;
+        }
+      }
+    }
+
     return output;
   }
 
diff --git a/chrome/common/extensions/command.cc b/chrome/common/extensions/command.cc
index de9a1b5..4c7868a 100644
--- a/chrome/common/extensions/command.cc
+++ b/chrome/common/extensions/command.cc
@@ -20,6 +20,7 @@ namespace keys = extension_manifest_keys;
 namespace values = extension_manifest_values;
 
 using extensions::ErrorUtils;
+using extensions::Command;
 
 namespace {
 
@@ -28,7 +29,6 @@ static const char kMissing[] = "Missing";
 static const char kCommandKeyNotSupported[] =
     "Command key is not supported. Note: Ctrl means Command on Mac";
 
-
 ui::Accelerator ParseImpl(const std::string& accelerator,
                           const std::string& platform_key,
                           int index,
@@ -60,17 +60,17 @@ ui::Accelerator ParseImpl(const std::string& accelerator,
   int modifiers = ui::EF_NONE;
   ui::KeyboardCode key = ui::VKEY_UNKNOWN;
   for (size_t i = 0; i < tokens.size(); i++) {
-    if (tokens[i] == "Ctrl") {
+    if (tokens[i] == values::kKeyCtrl) {
       modifiers |= ui::EF_CONTROL_DOWN;
-    } else if (tokens[i] == "Command") {
-      if (platform_key == "mac") {
+    } else if (tokens[i] == values::kKeyCommand) {
+      if (platform_key == values::kKeybindingPlatformMac) {
         // Either the developer specified Command+foo in the manifest for Mac or
         // they specified Ctrl and it got normalized to Command (to get Ctrl on
         // Mac the developer has to specify MacCtrl). Therefore we treat this
         // as Command.
         modifiers |= ui::EF_COMMAND_DOWN;
 #if defined(OS_MACOSX)
-      } else if (platform_key == "default") {
+      } else if (platform_key == values::kKeybindingPlatformDefault) {
         // If we see "Command+foo" in the Default section it can mean two
         // things, depending on the platform:
         // The developer specified "Ctrl+foo" for Default and it got normalized
@@ -82,19 +82,61 @@ ui::Accelerator ParseImpl(const std::string& accelerator,
         key = ui::VKEY_UNKNOWN;
         break;
       }
-    } else if (tokens[i] == "Alt") {
+    } else if (tokens[i] == values::kKeyAlt) {
       modifiers |= ui::EF_ALT_DOWN;
-    } else if (tokens[i] == "Shift") {
+    } else if (tokens[i] == values::kKeyShift) {
       modifiers |= ui::EF_SHIFT_DOWN;
-    } else if (tokens[i].size() == 1) {
+    } else if (tokens[i].size() == 1 ||  // A-Z, 0-9.
+               tokens[i] == values::kKeyComma ||
+               tokens[i] == values::kKeyPeriod ||
+               tokens[i] == values::kKeyUp ||
+               tokens[i] == values::kKeyDown ||
+               tokens[i] == values::kKeyLeft ||
+               tokens[i] == values::kKeyRight ||
+               tokens[i] == values::kKeyIns ||
+               tokens[i] == values::kKeyDel ||
+               tokens[i] == values::kKeyHome ||
+               tokens[i] == values::kKeyEnd ||
+               tokens[i] == values::kKeyPgUp ||
+               tokens[i] == values::kKeyPgDwn ||
+               tokens[i] == values::kKeyTab) {
       if (key != ui::VKEY_UNKNOWN) {
         // Multiple key assignments.
         key = ui::VKEY_UNKNOWN;
         break;
       }
-      if (tokens[i][0] >= 'A' && tokens[i][0] <= 'Z') {
+
+      if (tokens[i] == values::kKeyComma) {
+        key = ui::VKEY_OEM_COMMA;
+      } else if (tokens[i] == values::kKeyPeriod) {
+        key = ui::VKEY_OEM_PERIOD;
+      } else if (tokens[i] == values::kKeyUp) {
+        key = ui::VKEY_UP;
+      } else if (tokens[i] == values::kKeyDown) {
+        key = ui::VKEY_DOWN;
+      } else if (tokens[i] == values::kKeyLeft) {
+        key = ui::VKEY_LEFT;
+      } else if (tokens[i] == values::kKeyRight) {
+        key = ui::VKEY_RIGHT;
+      } else if (tokens[i] == values::kKeyIns) {
+        key = ui::VKEY_INSERT;
+      } else if (tokens[i] == values::kKeyDel) {
+        key = ui::VKEY_DELETE;
+      } else if (tokens[i] == values::kKeyHome) {
+        key = ui::VKEY_HOME;
+      } else if (tokens[i] == values::kKeyEnd) {
+        key = ui::VKEY_END;
+      } else if (tokens[i] == values::kKeyPgUp) {
+        key = ui::VKEY_PRIOR;
+      } else if (tokens[i] == values::kKeyPgDwn) {
+        key = ui::VKEY_NEXT;
+      } else if (tokens[i] == values::kKeyTab) {
+        key = ui::VKEY_TAB;
+      } else if (tokens[i].size() == 1 &&
+                 tokens[i][0] >= 'A' && tokens[i][0] <= 'Z') {
         key = static_cast<ui::KeyboardCode>(ui::VKEY_A + (tokens[i][0] - 'A'));
-      } else if (tokens[i][0] >= '0' && tokens[i][0] <= '9') {
+      } else if (tokens[i].size() == 1 &&
+                 tokens[i][0] >= '0' && tokens[i][0] <= '9') {
         key = static_cast<ui::KeyboardCode>(ui::VKEY_0 + (tokens[i][0] - '0'));
       } else {
         key = ui::VKEY_UNKNOWN;
@@ -138,9 +180,9 @@ ui::Accelerator ParseImpl(const std::string& accelerator,
 std::string NormalizeShortcutSuggestion(const std::string& suggestion,
                                         const std::string& platform) {
   bool normalize = false;
-  if (platform == "mac") {
+  if (platform == values::kKeybindingPlatformMac) {
     normalize = true;
-  } else if (platform == "default") {
+  } else if (platform == values::kKeybindingPlatformDefault) {
 #if defined(OS_MACOSX)
     normalize = true;
 #endif
@@ -153,10 +195,10 @@ std::string NormalizeShortcutSuggestion(const std::string& suggestion,
   std::vector<std::string> tokens;
   base::SplitString(suggestion, '+', &tokens);
   for (size_t i = 0; i < tokens.size(); i++) {
-    if (tokens[i] == "Ctrl")
-      tokens[i] = "Command";
-    else if (tokens[i] == "MacCtrl")
-      tokens[i] = "Ctrl";
+    if (tokens[i] == values::kKeyCtrl)
+      tokens[i] = values::kKeyCommand;
+    else if (tokens[i] == values::kKeyMacCtrl)
+      tokens[i] = values::kKeyCtrl;
   }
   return JoinString(tokens, '+');
 }
@@ -202,6 +244,82 @@ ui::Accelerator Command::StringToAccelerator(const std::string& accelerator) {
   return parsed;
 }
 
+// static
+std::string Command::AcceleratorToString(const ui::Accelerator& accelerator) {
+  std::string shortcut;
+
+  // Ctrl and Alt are mutually exclusive.
+  if (accelerator.IsCtrlDown())
+    shortcut += values::kKeyCtrl;
+  else if (accelerator.IsAltDown())
+    shortcut += values::kKeyAlt;
+  if (!shortcut.empty())
+    shortcut += values::kKeySeparator;
+
+  if (accelerator.IsCmdDown()) {
+    shortcut += values::kKeyCommand;
+    shortcut += values::kKeySeparator;
+  }
+
+  if (accelerator.IsShiftDown()) {
+    shortcut += values::kKeyShift;
+    shortcut += values::kKeySeparator;
+  }
+
+  if (accelerator.key_code() >= ui::VKEY_0 &&
+      accelerator.key_code() <= ui::VKEY_9) {
+    shortcut += '0' + (accelerator.key_code() - ui::VKEY_0);
+  } else if (accelerator.key_code() >= ui::VKEY_A &&
+           accelerator.key_code() <= ui::VKEY_Z) {
+    shortcut += 'A' + (accelerator.key_code() - ui::VKEY_A);
+  } else {
+    switch (accelerator.key_code()) {
+      case ui::VKEY_OEM_COMMA:
+        shortcut += values::kKeyComma;
+        break;
+      case ui::VKEY_OEM_PERIOD:
+        shortcut += values::kKeyPeriod;
+        break;
+      case ui::VKEY_UP:
+        shortcut += values::kKeyUp;
+        break;
+      case ui::VKEY_DOWN:
+        shortcut += values::kKeyDown;
+        break;
+      case ui::VKEY_LEFT:
+        shortcut += values::kKeyLeft;
+        break;
+      case ui::VKEY_RIGHT:
+        shortcut += values::kKeyRight;
+        break;
+      case ui::VKEY_INSERT:
+        shortcut += values::kKeyIns;
+        break;
+      case ui::VKEY_DELETE:
+        shortcut += values::kKeyDel;
+        break;
+      case ui::VKEY_HOME:
+        shortcut += values::kKeyHome;
+        break;
+      case ui::VKEY_END:
+        shortcut += values::kKeyEnd;
+        break;
+      case ui::VKEY_PRIOR:
+        shortcut += values::kKeyPgUp;
+        break;
+      case ui::VKEY_NEXT:
+        shortcut += values::kKeyPgDwn;
+        break;
+      case ui::VKEY_TAB:
+        shortcut += values::kKeyTab;
+        break;
+      default:
+        return "";
+    }
+  }
+  return shortcut;
+}
+
 bool Command::Parse(const DictionaryValue* command,
                     const std::string& command_name,
                     int index,
@@ -253,9 +371,9 @@ bool Command::Parse(const DictionaryValue* command,
     if (command->GetString(keys::kSuggestedKey, &suggested_key_string) &&
         !suggested_key_string.empty()) {
       // If only a single string is provided, it must be default for all.
-      suggestions["default"] = suggested_key_string;
+      suggestions[values::kKeybindingPlatformDefault] = suggested_key_string;
     } else {
-      suggestions["default"] = "";
+      suggestions[values::kKeybindingPlatformDefault] = "";
     }
   }
 
@@ -266,7 +384,7 @@ bool Command::Parse(const DictionaryValue* command,
     // specified Command in the Default section, which will work on Mac after
     // normalization but only fail on other platforms when they try it out on
     // other platforms, which is not what we want.
-    if (iter->first == "default" &&
+    if (iter->first == values::kKeybindingPlatformDefault &&
         iter->second.find("Command+") != std::string::npos) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidKeyBinding,
diff --git a/chrome/common/extensions/command.h b/chrome/common/extensions/command.h
index 8edcfdf..bccfe2a 100644
--- a/chrome/common/extensions/command.h
+++ b/chrome/common/extensions/command.h
@@ -36,6 +36,10 @@ class Command {
   // a generic ui::Accelerator object will be returns (with key_code Unknown).
   static ui::Accelerator StringToAccelerator(const std::string& accelerator);
 
+  // Returns the string representation of an accelerator without localizing the
+  // shortcut text (like accelerator::GetShortcutText() does).
+  static std::string AcceleratorToString(const ui::Accelerator& accelerator);
+
   // Parse the command.
   bool Parse(const base::DictionaryValue* command,
              const std::string& command_name,
diff --git a/chrome/common/extensions/command_unittest.cc b/chrome/common/extensions/command_unittest.cc
index b47cfad..6a11bad 100644
--- a/chrome/common/extensions/command_unittest.cc
+++ b/chrome/common/extensions/command_unittest.cc
@@ -31,6 +31,18 @@ TEST(CommandTest, ExtensionCommandParsing) {
   const ui::Accelerator alt_shift_f =
       ui::Accelerator(ui::VKEY_F, ui::EF_ALT_DOWN | ui::EF_SHIFT_DOWN);
   const ui::Accelerator ctrl_1 = ui::Accelerator(ui::VKEY_1, ctrl);
+  const ui::Accelerator ctrl_comma = ui::Accelerator(ui::VKEY_OEM_COMMA, ctrl);
+  const ui::Accelerator ctrl_dot = ui::Accelerator(ui::VKEY_OEM_PERIOD, ctrl);
+  const ui::Accelerator ctrl_left = ui::Accelerator(ui::VKEY_LEFT, ctrl);
+  const ui::Accelerator ctrl_right = ui::Accelerator(ui::VKEY_RIGHT, ctrl);
+  const ui::Accelerator ctrl_up = ui::Accelerator(ui::VKEY_UP, ctrl);
+  const ui::Accelerator ctrl_down = ui::Accelerator(ui::VKEY_DOWN, ctrl);
+  const ui::Accelerator ctrl_ins = ui::Accelerator(ui::VKEY_INSERT, ctrl);
+  const ui::Accelerator ctrl_del = ui::Accelerator(ui::VKEY_DELETE, ctrl);
+  const ui::Accelerator ctrl_home = ui::Accelerator(ui::VKEY_HOME, ctrl);
+  const ui::Accelerator ctrl_end = ui::Accelerator(ui::VKEY_END, ctrl);
+  const ui::Accelerator ctrl_pgup = ui::Accelerator(ui::VKEY_PRIOR, ctrl);
+  const ui::Accelerator ctrl_pgdwn = ui::Accelerator(ui::VKEY_NEXT, ctrl);
 
   const struct {
     bool expected_result;
@@ -75,6 +87,19 @@ TEST(CommandTest, ExtensionCommandParsing) {
     // Skipping description is OK for browser- and pageActions.
     { true, ctrl_f, "_execute_browser_action", "Ctrl+F", "" },
     { true, ctrl_f, "_execute_page_action",    "Ctrl+F", "" },
+    // Home, End, Arrow keys, etc.
+    { true, ctrl_comma, "_execute_browser_action", "Ctrl+Comma", "" },
+    { true, ctrl_dot, "_execute_browser_action", "Ctrl+Period", "" },
+    { true, ctrl_left, "_execute_browser_action", "Ctrl+Left", "" },
+    { true, ctrl_right, "_execute_browser_action", "Ctrl+Right", "" },
+    { true, ctrl_up, "_execute_browser_action", "Ctrl+Up", "" },
+    { true, ctrl_down, "_execute_browser_action", "Ctrl+Down", "" },
+    { true, ctrl_ins, "_execute_browser_action", "Ctrl+Insert", "" },
+    { true, ctrl_del, "_execute_browser_action", "Ctrl+Delete", "" },
+    { true, ctrl_home, "_execute_browser_action", "Ctrl+Home", "" },
+    { true, ctrl_end, "_execute_browser_action", "Ctrl+End", "" },
+    { true, ctrl_pgup, "_execute_browser_action", "Ctrl+PageUp", "" },
+    { true, ctrl_pgdwn, "_execute_browser_action", "Ctrl+PageDown", "" },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTests); ++i) {
diff --git a/chrome/common/extensions/docs/templates/intros/commands.html b/chrome/common/extensions/docs/templates/intros/commands.html
index 2c7fca2..c2862c6 100644
--- a/chrome/common/extensions/docs/templates/intros/commands.html
+++ b/chrome/common/extensions/docs/templates/intros/commands.html
@@ -28,14 +28,22 @@ You must set manifest_version to (at least) 2 to use this API.
 <h2 id="usage">Usage</h2>
 <p>The commands API allows you to define specific commands, and bind them to a
 default key combination. Each command your extension accepts must be listed in
-the manifest as an attribute of the 'commands' manifest key. Note: Combinations
+the manifest as an attribute of the 'commands' manifest key. An extension can
+have many commands but only 4 suggested keys can be specified. The user can
+manually add more shortcuts from the chrome://extensions page.</p>
+
+<p>Supported keys: A-Z, 0-9, Comma, Period, Home, End, PageUp, PageDown, Insert,
+Delete, Tab and the arrow keys (Up, Down, Left, Right).</p>
+
+<p>Note: All key combinations must include either Ctrl* or Alt. Combinations
 that involve Ctrl+Alt are not permitted in order to avoid conflicts with the
-AltGr key. Also note that on Mac 'Ctrl' is automatically converted to 'Command'.
-If you want 'Ctrl' instead, please specify 'MacCtrl'.</p>
+AltGr key. Shift can be used in addition to Alt or Ctrl, but is not required.<p>
+
+<p>* Also note that on Mac 'Ctrl' is automatically converted to 'Command'. If
+you want 'Ctrl' instead, please specify 'MacCtrl'.</p>
 
-<p>An extension can have many commands but only 4 suggested keys can be
-specified. The user can manually add more shortcuts from the chrome://extensions
-page.</p>
+<p>Certain Chrome shortcuts (e.g. window management) always take priority over
+Extension Command shortcuts and can not be overwritten.</p>
 
 <pre>{
   "name": "My extension",
diff --git a/chrome/common/extensions/extension_manifest_constants.cc b/chrome/common/extensions/extension_manifest_constants.cc
index 094c466..325220c 100644
--- a/chrome/common/extensions/extension_manifest_constants.cc
+++ b/chrome/common/extensions/extension_manifest_constants.cc
@@ -166,6 +166,25 @@ const char kKeybindingPlatformDefault[] = "default";
 const char kKeybindingPlatformLinux[] = "linux";
 const char kKeybindingPlatformMac[] = "mac";
 const char kKeybindingPlatformWin[] = "windows";
+const char kKeyAlt[] = "Alt";
+const char kKeyComma[] = "Comma";
+const char kKeyCommand[] = "Command";
+const char kKeyCtrl[] = "Ctrl";
+const char kKeyDel[] = "Delete";
+const char kKeyDown[] = "Down";
+const char kKeyEnd[] = "End";
+const char kKeyHome[] = "Home";
+const char kKeyIns[] = "Insert";
+const char kKeyLeft[] = "Left";
+const char kKeyMacCtrl[] = "MacCtrl";
+const char kKeyPgDwn[] = "PageDown";
+const char kKeyPgUp[] = "PageUp";
+const char kKeyPeriod[] = "Period";
+const char kKeyRight[] = "Right";
+const char kKeySeparator[] = "+";
+const char kKeyShift[] = "Shift";
+const char kKeyTab[] = "Tab";
+const char kKeyUp[] = "Up";
 const char kRunAtDocumentStart[] = "document_start";
 const char kRunAtDocumentEnd[] = "document_end";
 const char kRunAtDocumentIdle[] = "document_idle";
diff --git a/chrome/common/extensions/extension_manifest_constants.h b/chrome/common/extensions/extension_manifest_constants.h
index 6853ba8..f594176 100644
--- a/chrome/common/extensions/extension_manifest_constants.h
+++ b/chrome/common/extensions/extension_manifest_constants.h
@@ -172,6 +172,25 @@ namespace extension_manifest_values {
   extern const char kKeybindingPlatformLinux[];
   extern const char kKeybindingPlatformMac[];
   extern const char kKeybindingPlatformWin[];
+  extern const char kKeyAlt[];
+  extern const char kKeyShift[];
+  extern const char kKeyCommand[];
+  extern const char kKeyCtrl[];
+  extern const char kKeyComma[];
+  extern const char kKeyDel[];
+  extern const char kKeyDown[];
+  extern const char kKeyHome[];
+  extern const char kKeyEnd[];
+  extern const char kKeyIns[];
+  extern const char kKeyLeft[];
+  extern const char kKeyMacCtrl[];
+  extern const char kKeyPgDwn[];
+  extern const char kKeyPgUp[];
+  extern const char kKeyPeriod[];
+  extern const char kKeyRight[];
+  extern const char kKeySeparator[];
+  extern const char kKeyTab[];
+  extern const char kKeyUp[];
   extern const char kLaunchContainerPanel[];
   extern const char kLaunchContainerTab[];
   extern const char kLaunchContainerWindow[];
diff --git a/ui/base/accelerators/accelerator.cc b/ui/base/accelerators/accelerator.cc
index 1104b97..57f9cd5 100644
--- a/ui/base/accelerators/accelerator.cc
+++ b/ui/base/accelerators/accelerator.cc
@@ -134,6 +134,12 @@ string16 Accelerator::GetShortcutText() const {
     case ui::VKEY_RIGHT:
       string_id = IDS_APP_RIGHT_ARROW_KEY;
       break;
+    case ui::VKEY_UP:
+      string_id = IDS_APP_UP_ARROW_KEY;
+      break;
+    case ui::VKEY_DOWN:
+      string_id = IDS_APP_DOWN_ARROW_KEY;
+      break;
     case ui::VKEY_BACK:
       string_id = IDS_APP_BACKSPACE_KEY;
       break;
@@ -143,6 +149,12 @@ string16 Accelerator::GetShortcutText() const {
     case ui::VKEY_F11:
       string_id = IDS_APP_F11_KEY;
       break;
+    case ui::VKEY_OEM_COMMA:
+      string_id = IDS_APP_COMMA_KEY;
+      break;
+    case ui::VKEY_OEM_PERIOD:
+      string_id = IDS_APP_PERIOD_KEY;
+      break;
     default:
       break;
   }
diff --git a/ui/base/strings/ui_strings.grd b/ui/base/strings/ui_strings.grd
index 2927de0..ec5030d 100644
--- a/ui/base/strings/ui_strings.grd
+++ b/ui/base/strings/ui_strings.grd
@@ -359,6 +359,12 @@ need to be translated for each locale.-->
       <message name="IDS_APP_RIGHT_ARROW_KEY" desc="Right arrow key">
         Right Arrow
       </message>
+      <message name="IDS_APP_UP_ARROW_KEY" desc="Up arrow key">
+        Up Arrow
+      </message>
+      <message name="IDS_APP_DOWN_ARROW_KEY" desc="Down arrow key">
+        Down Arrow
+      </message>
       <message name="IDS_APP_ENTER_KEY" desc="Enter key">
         Enter
       </message>
@@ -371,6 +377,12 @@ need to be translated for each locale.-->
       <message name="IDS_APP_BACKSPACE_KEY" desc="Backspace key">
         Backspace
       </message>
+      <message name="IDS_APP_COMMA_KEY" desc="Comma key">
+        Comma
+      </message>
+      <message name="IDS_APP_PERIOD_KEY" desc="Period key">
+        Period
+      </message>
 
       <!-- Shortcut Modifiers -->
       <message name="IDS_APP_CONTROL_MODIFIER" desc="Control key shortcut modifier">