Add Search-. as a shortcut for the Insert key when Search is acting as a Function key.

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/stringprintf.h"
 #include "chrome/browser/api/prefs/pref_member.h"
@@ skipping 138 matching lines @@
         keycode_3_(XKeysymToKeycode(display_, XK_3)),
         keycode_4_(XKeysymToKeycode(display_, XK_4)),
         keycode_5_(XKeysymToKeycode(display_, XK_5)),
         keycode_6_(XKeysymToKeycode(display_, XK_6)),
         keycode_7_(XKeysymToKeycode(display_, XK_7)),
         keycode_8_(XKeysymToKeycode(display_, XK_8)),
         keycode_9_(XKeysymToKeycode(display_, XK_9)),
         keycode_0_(XKeysymToKeycode(display_, XK_0)),
         keycode_minus_(XKeysymToKeycode(display_, XK_minus)),
         keycode_equal_(XKeysymToKeycode(display_, XK_equal)),
+        keycode_period_(XKeysymToKeycode(display_, XK_period)),
+        keycode_insert_(XKeysymToKeycode(display_, XK_Insert)),
         input_method_manager_mock_(NULL) {
   }
   virtual ~EventRewriterTest() {}
 
   virtual void SetUp() {
     // Mocking user manager because the real one needs to be called on UI thread
     EXPECT_CALL(*user_manager_mock_.user_manager(), IsLoggedInAsGuest())
         .WillRepeatedly(testing::Return(false));
     input_method_manager_mock_ =
         new chromeos::input_method::MockInputMethodManager;
@@ skipping 81 matching lines @@
   const KeyCode keycode_3_;
   const KeyCode keycode_4_;
   const KeyCode keycode_5_;
   const KeyCode keycode_6_;
   const KeyCode keycode_7_;
   const KeyCode keycode_8_;
   const KeyCode keycode_9_;
   const KeyCode keycode_0_;
   const KeyCode keycode_minus_;
   const KeyCode keycode_equal_;
+  const KeyCode keycode_period_;
+  const KeyCode keycode_insert_;
   chromeos::ScopedMockUserManagerEnabler user_manager_mock_;
   chromeos::input_method::MockInputMethodManager* input_method_manager_mock_;
 };
 
 }  // namespace
 #else
 class EventRewriterTest : public testing::Test {
  public:
   EventRewriterTest() {}
   virtual ~EventRewriterTest() {}
@@ skipping 1477 matching lines @@
             GetRewrittenEventAsString(&rewriter,
                                       ui::VKEY_A,
                                       0,
                                       ui::ET_KEY_PRESSED,
                                       keycode_a_,
                                       Mod3Mask));
 
   input_method_manager_mock_->SetCurrentInputMethodId("xkb:us::eng");
 }
 
-TEST_F(EventRewriterTest, TestRewriteBackspaceAndArrowKeys) {
+TEST_F(EventRewriterTest, TestRewriteExtendedKeys) {
   TestingPrefService prefs;
   chromeos::Preferences::RegisterUserPrefs(&prefs);
   EventRewriter rewriter;
   rewriter.set_pref_service_for_testing(&prefs);
 
   // On non-chromebooks, the keyboard doesn't need to be remapped.
 
   struct {
     ui::KeyboardCode input;
     KeyCode input_native;
@@ skipping 16 matching lines @@
       ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask,
       ui::VKEY_UP, keycode_up_,
       ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask, },
     { ui::VKEY_DOWN, keycode_down_,
       ui::EF_ALT_DOWN, Mod1Mask,
       ui::VKEY_DOWN, keycode_down_,
       ui::EF_ALT_DOWN, Mod1Mask, },
     { ui::VKEY_LEFT, keycode_left_, 0, 0,
       ui::VKEY_LEFT, keycode_left_, 0, 0 },
     { ui::VKEY_RIGHT, keycode_right_, 0, 0,
-      ui::VKEY_RIGHT, keycode_right_, 0, 0 }
+      ui::VKEY_RIGHT, keycode_right_, 0, 0 },
+    { ui::VKEY_OEM_PERIOD, keycode_period_, 0, 0,
+      ui::VKEY_OEM_PERIOD, keycode_period_, 0, 0 }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(default_tests); ++i) {
     EXPECT_EQ(GetExpectedResultAsString(default_tests[i].output,
                                         default_tests[i].output_mods,
                                         ui::ET_KEY_PRESSED,
                                         default_tests[i].output_native,
                                         default_tests[i].output_native_mods,
                                         KeyPress),
               GetRewrittenEventAsString(&rewriter,
@@ skipping 91 matching lines @@
       0, 0, },
     // Ctrl+Alt+Up -> Home
     { ui::VKEY_UP, keycode_up_,
       ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask,
       ui::VKEY_HOME, keycode_home_,
       0, 0, },
     // Ctrl+Alt+Down -> End
     { ui::VKEY_DOWN, keycode_down_,
       ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, Mod1Mask | ControlMask,
       ui::VKEY_END, keycode_end_,
-      0, 0, }
+      0, 0, },
+    // Period -> Period
+    { ui::VKEY_OEM_PERIOD, keycode_period_, 0, 0,
+      ui::VKEY_OEM_PERIOD, keycode_period_, 0, 0 }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(chromeos_tests); ++i) {
     EXPECT_EQ(GetExpectedResultAsString(chromeos_tests[i].output,
                                         chromeos_tests[i].output_mods,
                                         ui::ET_KEY_PRESSED,
                                         chromeos_tests[i].output_native,
                                         chromeos_tests[i].output_native_mods,
                                         KeyPress),
               GetRewrittenEventAsString(&rewriter,
@@ skipping 130 matching lines @@
       ui::EF_CONTROL_DOWN, ControlMask },
     // Search+Right -> End
     { ui::VKEY_RIGHT, keycode_right_,
       0, Mod4Mask,
       ui::VKEY_END, keycode_end_,
       0, 0, },
     // Control+Search+Right -> End
     { ui::VKEY_RIGHT, keycode_right_,
       ui::EF_CONTROL_DOWN, Mod4Mask | ControlMask,
       ui::VKEY_END, keycode_end_,
+      ui::EF_CONTROL_DOWN, ControlMask },
+    // Search+Period -> Insert
+    { ui::VKEY_OEM_PERIOD, keycode_period_, 0, Mod4Mask,
+      ui::VKEY_INSERT, keycode_insert_, 0, 0 },
+    // Control+Search+Period -> Control+Insert
+    { ui::VKEY_OEM_PERIOD, keycode_period_,
+      ui::EF_CONTROL_DOWN, Mod4Mask | ControlMask,
+      ui::VKEY_INSERT, keycode_insert_,
       ui::EF_CONTROL_DOWN, ControlMask }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(search_tests); ++i) {
     EXPECT_EQ(GetExpectedResultAsString(search_tests[i].output,
                                         search_tests[i].output_mods,
                                         ui::ET_KEY_PRESSED,
                                         search_tests[i].output_native,
                                         search_tests[i].output_native_mods,
                                         KeyPress),
@@ skipping 299 matching lines @@
                                         search_key_tests[i].input,
                                         ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
                                         ui::ET_KEY_PRESSED,
                                         search_key_tests[i].input_native,
                                         Mod4Mask | ControlMask | Mod1Mask));
   }
 
   *CommandLine::ForCurrentProcess() = original_cl;
 }
 
-TEST_F(EventRewriterTest, TestRewriteBackspaceAndArrowKeysWithSearchRemapped) {
+TEST_F(EventRewriterTest, TestRewriteExtendedKeysWithSearchRemapped) {
   const CommandLine original_cl(*CommandLine::ForCurrentProcess());
 
   // Remap Search to Control.
   TestingPrefService prefs;
   chromeos::Preferences::RegisterUserPrefs(&prefs);
   IntegerPrefMember search;
   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs, NULL);
   search.SetValue(chromeos::input_method::kControlKey);
 
   EventRewriter rewriter;
@@ skipping 65 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