Add diamond-key remapping support.

BUG=157065
TEST=Changes diamond-key remapping setting on the setting page, and confirms the key is changed correctly.

R=yusukes@chromium.org
R=sky@chromium.org
R=dpolukhin@chromium.org
TBR=nkostylev@chromium.org

Review URL: https://codereview.chromium.org/11943009

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

9 files changed, 226 insertions, 11 deletions

diff --git a/chrome/app/chromeos_strings.grdp b/chrome/app/chromeos_strings.grdp
index cb3b911..0e7f741 100644
--- a/chrome/app/chromeos_strings.grdp
+++ b/chrome/app/chromeos_strings.grdp
@@ -2050,6 +2050,10 @@ Press any key to continue exploring.
            desc="The label for 'Customize modifier keys' overlay">
     Caps Lock
   </message>
+  <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_KEY_DIAMOND_KEY_LABEL"
+           desc="The label for 'Customize modifier keys' overlay">
+    Diamond
+  </message>
   <message name="IDS_OPTIONS_SETTINGS_LANGUAGES_KEY_SEARCH"
            desc="The dropdown list item for 'Customize modifier keys' overlay">
     Search
diff --git a/chrome/browser/chromeos/preferences.cc b/chrome/browser/chromeos/preferences.cc
index 8a4e738..7f5233f 100644
--- a/chrome/browser/chromeos/preferences.cc
+++ b/chrome/browser/chromeos/preferences.cc
@@ -241,6 +241,9 @@ void Preferences::RegisterUserPrefs(PrefServiceSyncable* prefs) {
   prefs->RegisterIntegerPref(prefs::kLanguageRemapCapsLockKeyTo,
                              input_method::kCapsLockKey,
                              PrefServiceSyncable::SYNCABLE_PREF);
+  prefs->RegisterIntegerPref(prefs::kLanguageRemapDiamondKeyTo,
+                             input_method::kControlKey,
+                             PrefServiceSyncable::SYNCABLE_PREF);
   // We don't sync the following keyboard prefs since they are not user-
   // configurable.
   prefs->RegisterBooleanPref(prefs::kLanguageXkbAutoRepeatEnabled,
diff --git a/chrome/browser/resources/options/chromeos/keyboard_overlay.html b/chrome/browser/resources/options/chromeos/keyboard_overlay.html
index 4c3b7248..90a8e20c 100644
--- a/chrome/browser/resources/options/chromeos/keyboard_overlay.html
+++ b/chrome/browser/resources/options/chromeos/keyboard_overlay.html
@@ -56,6 +56,21 @@
                i18n-options="remapCapsLockKeyToValue" dialog-pref></select>
          </td>
        </tr>
+       <!-- The diamond key section is hidden by default. This is only visible
+            when --has-chromeos-diamond-key flag is passed. -->
+       <tr id="diamond-key-remapping-section" hidden>
+         <td>
+           <label class="option-name" for="remap-diamond-key-to"
+               i18n-content="remapDiamondKeyToContent">
+           </label>
+         </td>
+         <td class="option-value">
+           <select id="remap-diamond-key-to" class="control"
+               data-type="number"
+               pref="settings.language.remap_diamond_key_to"
+               i18n-options="remapDiamondKeyToValue" dialog-pref></select>
+         </td>
+       </tr>
     </table>
   </div>
   <div class="content-area">
diff --git a/chrome/browser/resources/options/chromeos/keyboard_overlay.js b/chrome/browser/resources/options/chromeos/keyboard_overlay.js
index 719cc49..39c8a69 100644
--- a/chrome/browser/resources/options/chromeos/keyboard_overlay.js
+++ b/chrome/browser/resources/options/chromeos/keyboard_overlay.js
@@ -38,11 +38,20 @@ cr.define('options', function() {
     showCapsLockOptions_: function(show) {
       $('caps-lock-remapping-section').hidden = !show;
     },
+
+    /**
+     * Show/hide the diamond key remapping section.
+     * @private
+     */
+    showDiamondKeyOptions_: function(show) {
+      $('diamond-key-remapping-section').hidden = !show;
+    },
   };
 
   // Forward public APIs to private implementations.
   [
     'showCapsLockOptions',
+    'showDiamondKeyOptions',
   ].forEach(function(name) {
     KeyboardOverlay[name] = function() {
       var instance = KeyboardOverlay.getInstance();
diff --git a/chrome/browser/ui/ash/event_rewriter.cc b/chrome/browser/ui/ash/event_rewriter.cc
index ad5fdec..0518320 100644
--- a/chrome/browser/ui/ash/event_rewriter.cc
+++ b/chrome/browser/ui/ash/event_rewriter.cc
@@ -85,6 +85,7 @@ const struct ModifierFlagToPrefName {
   { Mod4Mask, 0, prefs::kLanguageRemapSearchKeyTo },
   { ControlMask, ui::EF_CONTROL_DOWN, prefs::kLanguageRemapControlKeyTo },
   { Mod1Mask, ui::EF_ALT_DOWN, prefs::kLanguageRemapAltKeyTo },
+  { Mod2Mask, 0, prefs::kLanguageRemapDiamondKeyTo },
 };
 
 // Gets a remapped key for |pref_name| key. For example, to find out which
@@ -122,6 +123,11 @@ bool HasChromeOSKeyboard() {
       switches::kHasChromeOSKeyboard);
 }
 
+bool HasDiamondKey() {
+  return CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kHasChromeOSDiamondKey);
+}
+
 bool IsMod3UsedByCurrentInputMethod() {
   // Since both German Neo2 XKB layout and Caps Lock depend on Mod3Mask,
   // it's not possible to make both features work. For now, we don't remap
@@ -426,7 +432,7 @@ void EventRewriter::GetRemappedModifierMasks(
       (original_flags & ~(ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN)) |
       *remapped_flags;
 
-  unsigned int native_mask = Mod4Mask | ControlMask | Mod1Mask;
+  unsigned int native_mask = Mod4Mask | ControlMask | Mod1Mask | Mod2Mask;
   if (!skip_mod3)
     native_mask |= Mod3Mask;
   *remapped_native_modifiers =
@@ -467,6 +473,19 @@ bool EventRewriter::RewriteModifiers(ui::KeyEvent* event) {
   // First, remap |keysym|.
   const ModifierRemapping* remapped_key = NULL;
   switch (keysym) {
+    // On Chrome OS, XF86XK_Launch6 (F15) with Mod2Mask is sent when Diamond
+    // key is pressed.
+    case XF86XK_Launch6:
+      // When diamond key is not available, the configuration UI for Diamond
+      // key is not shown. Therefore, ignore the kLanguageRemapDiamondKeyTo
+      // syncable pref.
+      if (HasDiamondKey())
+        remapped_key =
+            GetRemappedKey(prefs::kLanguageRemapDiamondKeyTo, *pref_service);
+      // Default behavior is Ctrl key.
+      if (!remapped_key)
+        remapped_key = kModifierRemappingCtrl;
+      break;
     // On Chrome OS, XF86XK_Launch7 (F16) with Mod3Mask is sent when Caps Lock
     // is pressed (with one exception: when IsMod3UsedByCurrentInputMethod() is
     // true, the key generates XK_ISO_Level3_Shift with Mod3Mask, not
@@ -475,11 +494,12 @@ bool EventRewriter::RewriteModifiers(ui::KeyEvent* event) {
       // When a Chrome OS keyboard is available, the configuration UI for Caps
       // Lock is not shown. Therefore, ignore the kLanguageRemapCapsLockKeyTo
       // syncable pref.
-      if (HasChromeOSKeyboard())
-        remapped_key = kModifierRemappingCapsLock;
-      else
+      if (!HasChromeOSKeyboard())
         remapped_key =
             GetRemappedKey(prefs::kLanguageRemapCapsLockKeyTo, *pref_service);
+      // Default behavior is Caps Lock key.
+      if (!remapped_key)
+        remapped_key = kModifierRemappingCapsLock;
       break;
     case XK_Super_L:
     case XK_Super_R:
@@ -489,6 +509,8 @@ bool EventRewriter::RewriteModifiers(ui::KeyEvent* event) {
       else
         remapped_key =
             GetRemappedKey(prefs::kLanguageRemapSearchKeyTo, *pref_service);
+      // Default behavior is Super key, hence don't remap the event if the pref
+      // is unavailable.
       break;
     case XK_Control_L:
     case XK_Control_R:
diff --git a/chrome/browser/ui/ash/event_rewriter_unittest.cc b/chrome/browser/ui/ash/event_rewriter_unittest.cc
index 4887884..16fb115 100644
--- a/chrome/browser/ui/ash/event_rewriter_unittest.cc
+++ b/chrome/browser/ui/ash/event_rewriter_unittest.cc
@@ -117,6 +117,7 @@ class EventRewriterTest : public testing::Test {
         keycode_next_(XKeysymToKeycode(display_, XK_Next)),
         keycode_home_(XKeysymToKeycode(display_, XK_Home)),
         keycode_end_(XKeysymToKeycode(display_, XK_End)),
+        keycode_launch6_(XKeysymToKeycode(display_, XF86XK_Launch6)),
         keycode_launch7_(XKeysymToKeycode(display_, XF86XK_Launch7)),
         keycode_f1_(XKeysymToKeycode(display_, XK_F1)),
         keycode_f2_(XKeysymToKeycode(display_, XK_F2)),
@@ -179,6 +180,9 @@ class EventRewriterTest : public testing::Test {
   }
 
  protected:
+  void TestRewriteNumPadKeys();
+  void TestRewriteNumPadKeysOnAppleKeyboard();
+
   Display* display_;
   const KeyCode keycode_a_;
   const KeyCode keycode_alt_l_;
@@ -224,6 +228,7 @@ class EventRewriterTest : public testing::Test {
   const KeyCode keycode_next_;
   const KeyCode keycode_home_;
   const KeyCode keycode_end_;
+  const KeyCode keycode_launch6_;  // F15
   const KeyCode keycode_launch7_;  // F16
   const KeyCode keycode_f1_;
   const KeyCode keycode_f2_;
@@ -545,7 +550,7 @@ TEST_F(EventRewriterTest, TestRewriteCommandToControlWithControlRemapped) {
                                       Mod1Mask));
 }
 
-TEST_F(EventRewriterTest, TestRewriteNumPadKeys) {
+void EventRewriterTest::TestRewriteNumPadKeys() {
   TestingPrefServiceSyncable prefs;
   EventRewriter rewriter;
   rewriter.set_pref_service_for_testing(&prefs);
@@ -873,8 +878,21 @@ TEST_F(EventRewriterTest, TestRewriteNumPadKeys) {
                                       Mod2Mask));
 }
 
+TEST_F(EventRewriterTest, TestRewriteNumPadKeys) {
+  TestRewriteNumPadKeys();
+}
+
+TEST_F(EventRewriterTest, TestRewriteNumPadKeysWithDiamondKeyFlag) {
+  // Make sure the num lock works correctly even when Diamond key exists.
+  const CommandLine original_cl(*CommandLine::ForCurrentProcess());
+  CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+      switches::kHasChromeOSDiamondKey, "");
+
+  TestRewriteNumPadKeys();
+}
+
 // Tests if the rewriter can handle a Command + Num Pad event.
-TEST_F(EventRewriterTest, TestRewriteNumPadKeysOnAppleKeyboard) {
+void EventRewriterTest::TestRewriteNumPadKeysOnAppleKeyboard() {
   TestingPrefServiceSyncable prefs;
   EventRewriter rewriter;
   rewriter.DeviceAddedForTesting(0, "Apple Keyboard");
@@ -912,6 +930,20 @@ TEST_F(EventRewriterTest, TestRewriteNumPadKeysOnAppleKeyboard) {
                                       Mod4Mask));
 }
 
+TEST_F(EventRewriterTest, TestRewriteNumPadKeysOnAppleKeyboard) {
+  TestRewriteNumPadKeysOnAppleKeyboard();
+}
+
+TEST_F(EventRewriterTest,
+       TestRewriteNumPadKeysOnAppleKeyboardWithDiamondKeyFlag) {
+  // Makes sure the num lock works correctly even when Diamond key exists.
+  const CommandLine original_cl(*CommandLine::ForCurrentProcess());
+  CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+      switches::kHasChromeOSDiamondKey, "");
+
+  TestRewriteNumPadKeysOnAppleKeyboard();
+}
+
 TEST_F(EventRewriterTest, TestRewriteModifiersNoRemap) {
   TestingPrefServiceSyncable prefs;
   EventRewriter rewriter;
@@ -1629,6 +1661,124 @@ TEST_F(EventRewriterTest, DISABLED_TestRewriteCapsLockWithFlag) {
   *CommandLine::ForCurrentProcess() = original_cl;
 }
 
+TEST_F(EventRewriterTest, DISABLED_TestRewriteDiamondKey) {
+  // TODO(yusukes): Reenable the test once build servers are upgraded.
+
+  TestingPrefServiceSyncable prefs;
+  chromeos::Preferences::RegisterUserPrefs(&prefs);
+
+  chromeos::input_method::MockXKeyboard xkeyboard;
+  EventRewriter rewriter;
+  rewriter.set_pref_service_for_testing(&prefs);
+  rewriter.set_xkeyboard_for_testing(&xkeyboard);
+
+  // F15 should work as Ctrl when --has-chromeos-diamond-key is not specified.
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
+                                      ui::EF_CONTROL_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_control_l_,
+                                      0U,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_F15,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_launch6_,
+                                      0U));
+}
+
+TEST_F(EventRewriterTest, DISABLED_TestRewriteDiamondKeyWithFlag) {
+  // TODO(yusukes): Reenable the test once build servers are upgraded.
+
+  const CommandLine original_cl(*CommandLine::ForCurrentProcess());
+  CommandLine::ForCurrentProcess()->AppendSwitchASCII(
+      switches::kHasChromeOSDiamondKey, "");
+
+  TestingPrefServiceSyncable prefs;
+  chromeos::Preferences::RegisterUserPrefs(&prefs);
+
+  chromeos::input_method::MockXKeyboard xkeyboard;
+  EventRewriter rewriter;
+  rewriter.set_pref_service_for_testing(&prefs);
+  rewriter.set_xkeyboard_for_testing(&xkeyboard);
+
+  // By default, F15 should work as Control.
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
+                                      ui::EF_CONTROL_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_control_l_,
+                                      0U,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_F15,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_launch6_,
+                                      0U));
+
+  IntegerPrefMember diamond;
+  diamond.Init(prefs::kLanguageRemapDiamondKeyTo, &prefs);
+  diamond.SetValue(chromeos::input_method::kVoidKey);
+
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_UNKNOWN,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_void_symbol_,
+                                      0U,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_F15,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_launch6_,
+                                      0U));
+
+  diamond.SetValue(chromeos::input_method::kControlKey);
+
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
+                                      ui::EF_CONTROL_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_control_l_,
+                                      0U,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_F15,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_launch6_,
+                                      0U));
+
+  diamond.SetValue(chromeos::input_method::kAltKey);
+
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_MENU,
+                                      ui::EF_ALT_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_alt_l_,
+                                      0,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_F15,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_launch6_,
+                                      0U));
+
+  diamond.SetValue(chromeos::input_method::kCapsLockKey);
+
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
+                                      ui::EF_CAPS_LOCK_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_caps_lock_,
+                                      0U,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_F15,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_launch6_,
+                                      0U));
+}
+
 TEST_F(EventRewriterTest, TestRewriteCapsLockToControl) {
   TestingPrefServiceSyncable prefs;
   chromeos::Preferences::RegisterUserPrefs(&prefs);
diff --git a/chrome/browser/ui/webui/options/chromeos/keyboard_handler.cc b/chrome/browser/ui/webui/options/chromeos/keyboard_handler.cc
index 18dec62..6ceb0c3 100644
--- a/chrome/browser/ui/webui/options/chromeos/keyboard_handler.cc
+++ b/chrome/browser/ui/webui/options/chromeos/keyboard_handler.cc
@@ -34,6 +34,7 @@ const char* kDataValuesNames[] = {
   "remapControlKeyToValue",
   "remapAltKeyToValue",
   "remapCapsLockKeyToValue",
+  "remapDiamondKeyToValue",
 };
 }  // namespace
 
@@ -63,6 +64,9 @@ void KeyboardHandler::GetLocalizedValues(DictionaryValue* localized_strings) {
   localized_strings->SetString("remapCapsLockKeyToContent",
       l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_LANGUAGES_KEY_CAPS_LOCK_LABEL));
+  localized_strings->SetString("remapDiamondKeyToContent",
+      l10n_util::GetStringUTF16(
+          IDS_OPTIONS_SETTINGS_LANGUAGES_KEY_DIAMOND_KEY_LABEL));
   localized_strings->SetString("changeLanguageAndInputSettings",
       l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_CHANGE_LANGUAGE_AND_INPUT_SETTINGS));
@@ -92,13 +96,18 @@ void KeyboardHandler::GetLocalizedValues(DictionaryValue* localized_strings) {
 void KeyboardHandler::InitializePage() {
   bool chromeos_keyboard = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kHasChromeOSKeyboard);
+  const base::FundamentalValue show_caps_lock_options(chromeos_keyboard);
 
-  const base::FundamentalValue show_options(true);
+  bool has_diamond_key = CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kHasChromeOSDiamondKey);
+  const base::FundamentalValue show_diamond_key_options(has_diamond_key);
 
-  if (!chromeos_keyboard) {
-    web_ui()->CallJavascriptFunction(
-        "options.KeyboardOverlay.showCapsLockOptions", show_options);
-  }
+  web_ui()->CallJavascriptFunction(
+      "options.KeyboardOverlay.showCapsLockOptions",
+      show_caps_lock_options);
+  web_ui()->CallJavascriptFunction(
+      "options.KeyboardOverlay.showDiamondKeyOptions",
+      show_diamond_key_options);
 }
 
 }  // namespace options
diff --git a/chrome/common/pref_names.cc b/chrome/common/pref_names.cc
index 9ff1fe4..7ae3cc0 100644
--- a/chrome/common/pref_names.cc
+++ b/chrome/common/pref_names.cc
@@ -724,6 +724,8 @@ const char kLanguageRemapAltKeyTo[] =
     "settings.language.xkb_remap_alt_key_to";
 const char kLanguageRemapCapsLockKeyTo[] =
     "settings.language.remap_caps_lock_key_to";
+const char kLanguageRemapDiamondKeyTo[] =
+    "settings.language.remap_diamond_key_to";
 
 // A boolean pref which determines whether key repeat is enabled.
 const char kLanguageXkbAutoRepeatEnabled[] =
diff --git a/chrome/common/pref_names.h b/chrome/common/pref_names.h
index a1a87b2..45df444 100644
--- a/chrome/common/pref_names.h
+++ b/chrome/common/pref_names.h
@@ -265,6 +265,7 @@ extern const char kLanguageRemapCapsLockKeyTo[];
 extern const char kLanguageRemapSearchKeyTo[];
 extern const char kLanguageRemapControlKeyTo[];
 extern const char kLanguageRemapAltKeyTo[];
+extern const char kLanguageRemapDiamondKeyTo[];
 extern const char kLanguageXkbAutoRepeatEnabled[];
 extern const char kLanguageXkbAutoRepeatDelay[];
 extern const char kLanguageXkbAutoRepeatInterval[];