Add diamond-key remapping support.

chrome/browser/ui/ash/event_rewriter_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/ash/event_rewriter.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/prefs/public/pref_member.h"
 #include "base/stringprintf.h"
@@ skipping 99 matching lines @@
         keycode_delete_(XKeysymToKeycode(display_, XK_Delete)),
         keycode_backspace_(XKeysymToKeycode(display_, XK_BackSpace)),
         keycode_up_(XKeysymToKeycode(display_, XK_Up)),
         keycode_down_(XKeysymToKeycode(display_, XK_Down)),
         keycode_left_(XKeysymToKeycode(display_, XK_Left)),
         keycode_right_(XKeysymToKeycode(display_, XK_Right)),
         keycode_prior_(XKeysymToKeycode(display_, XK_Prior)),
         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)),
         keycode_f3_(XKeysymToKeycode(display_, XK_F3)),
         keycode_f4_(XKeysymToKeycode(display_, XK_F4)),
         keycode_f5_(XKeysymToKeycode(display_, XK_F5)),
         keycode_f6_(XKeysymToKeycode(display_, XK_F6)),
         keycode_f7_(XKeysymToKeycode(display_, XK_F7)),
         keycode_f8_(XKeysymToKeycode(display_, XK_F8)),
         keycode_f9_(XKeysymToKeycode(display_, XK_F9)),
@@ skipping 42 matching lines @@
     chromeos::input_method::InitializeForTesting(
         input_method_manager_mock_);  // pass ownership
   }
 
   virtual void TearDown() {
     // Shutdown() deletes the IME mock object.
     chromeos::input_method::Shutdown();
   }
 
  protected:
+  void TestRewriteNumPadKeys();
+  void TestRewriteNumPadKeysOnAppleKeyboard();
+
   Display* display_;
   const KeyCode keycode_a_;
   const KeyCode keycode_alt_l_;
   const KeyCode keycode_alt_r_;
   const KeyCode keycode_b_;
   const KeyCode keycode_caps_lock_;
   const KeyCode keycode_control_l_;
   const KeyCode keycode_control_r_;
   const KeyCode keycode_meta_l_;
   const KeyCode keycode_meta_r_;
@@ skipping 25 matching lines @@
   const KeyCode keycode_delete_;
   const KeyCode keycode_backspace_;
   const KeyCode keycode_up_;
   const KeyCode keycode_down_;
   const KeyCode keycode_left_;
   const KeyCode keycode_right_;
   const KeyCode keycode_prior_;
   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_;
   const KeyCode keycode_f3_;
   const KeyCode keycode_f4_;
   const KeyCode keycode_f5_;
   const KeyCode keycode_f6_;
   const KeyCode keycode_f7_;
   const KeyCode keycode_f8_;
   const KeyCode keycode_f9_;
@@ skipping 301 matching lines @@
                                       Mod1Mask,
                                       KeyPress),
             GetRewrittenEventAsString(&rewriter,
                                       ui::VKEY_RWIN,
                                       ui::EF_ALT_DOWN,
                                       ui::ET_KEY_PRESSED,
                                       keycode_super_r_,
                                       Mod1Mask));
 }
 
-TEST_F(EventRewriterTest, TestRewriteNumPadKeys) {
+void EventRewriterTest::TestRewriteNumPadKeys() {
   TestingPrefServiceSyncable prefs;
   EventRewriter rewriter;
   rewriter.set_pref_service_for_testing(&prefs);
 
   // XK_KP_Insert (= NumPad 0 without Num Lock), no modifier.
   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD0,
                                       0,
                                       ui::ET_KEY_PRESSED,
                                       keycode_num_pad_0_,
                                       Mod2Mask,  // Num Lock
@@ skipping 307 matching lines @@
                                       Mod2Mask,
                                       KeyPress),
             GetRewrittenEventAsString(&rewriter,
                                       ui::VKEY_NUMPAD9,
                                       0,
                                       ui::ET_KEY_PRESSED,
                                       keycode_num_pad_9_,
                                       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");
   rewriter.set_last_device_id_for_testing(0);
   rewriter.set_pref_service_for_testing(&prefs);
 
   // XK_KP_End (= NumPad 1 without Num Lock), Win modifier.
   // The result should be "Num Pad 1 with Control + Num Lock modifiers".
   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NUMPAD1,
                                       ui::EF_CONTROL_DOWN,
@@ skipping 17 matching lines @@
                                       ControlMask | Mod2Mask,
                                       KeyPress),
             GetRewrittenEventAsString(&rewriter,
                                       ui::VKEY_NUMPAD1,
                                       0,
                                       ui::ET_KEY_PRESSED,
                                       keycode_num_pad_end_,
                                       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;
   rewriter.set_pref_service_for_testing(&prefs);
 
   // Press Search. Confirm the event is not rewritten.
   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_LWIN,
                                       0,
                                       ui::ET_KEY_PRESSED,
                                       keycode_super_l_,
@@ skipping 697 matching lines @@
                                       ui::VKEY_F16,
                                       0,
                                       ui::ET_KEY_PRESSED,
                                       keycode_launch7_,
                                       0U));
   EXPECT_TRUE(xkeyboard.caps_lock_is_enabled_);
 
   *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);
   IntegerPrefMember control;
   control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kControlKey);
 
   EventRewriter rewriter;
   rewriter.set_pref_service_for_testing(&prefs);
 
@@ skipping 555 matching lines @@
   // flag in the event is True.
   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CONTROL,
                                       ui::EF_CONTROL_DOWN,
                                       ui::ET_KEY_PRESSED,
                                       keycode_control_l_,
                                       0U,
                                       KeyPress),
             rewritten_event);
 }
 #endif  // OS_CHROMEOS