Add power-user keyboard mode for ChromeOS with Search key acting as a typical Fn 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 92 matching lines @@
         keycode_num_pad_prior_(XKeysymToKeycode(display_, XK_KP_Prior)),
         keycode_num_pad_right_(XKeysymToKeycode(display_, XK_KP_Right)),
         keycode_num_pad_up_(XKeysymToKeycode(display_, XK_KP_Up)),
         keycode_super_l_(XKeysymToKeycode(display_, XK_Super_L)),
         keycode_super_r_(XKeysymToKeycode(display_, XK_Super_R)),
         keycode_void_symbol_(XKeysymToKeycode(display_, XK_VoidSymbol)),
         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_launch7_(XKeysymToKeycode(display_, XF86XK_Launch7)),
         input_method_manager_mock_(NULL) {
   }
   virtual ~EventRewriterTest() {}
 
   virtual void SetUp() {
@@ skipping 44 matching lines @@
   const KeyCode keycode_num_pad_prior_;
   const KeyCode keycode_num_pad_right_;
   const KeyCode keycode_num_pad_up_;
   const KeyCode keycode_super_l_;
   const KeyCode keycode_super_r_;
   const KeyCode keycode_void_symbol_;
   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_launch7_;  // F16
   chromeos::ScopedMockUserManagerEnabler user_manager_mock_;
   chromeos::input_method::MockInputMethodManager* input_method_manager_mock_;
 };
 
 }  // namespace
@@ skipping 52 matching lines @@
   EXPECT_EQ(EventRewriter::kDeviceAppleKeyboard,
             rewriter.DeviceAddedForTesting(1, "Apple Keyboard"));
   EXPECT_EQ(2U, rewriter.device_id_to_type_for_testing().size());
   // Try to reuse the first ID.
   EXPECT_EQ(EventRewriter::kDeviceAppleKeyboard,
             rewriter.DeviceAddedForTesting(0, "Apple Keyboard"));
   EXPECT_EQ(2U, rewriter.device_id_to_type_for_testing().size());
 }
 
 #if defined(OS_CHROMEOS)
 TEST_F(EventRewriterTest, TestRewriteCommandToControl) {

[Yusuke Sato, 2012/11/26 06:09:38]

This test seems red:
http://build.chromium.org/p/tryserver.chromium/buildstatus?builder=linux_chro...

Please fix.

   // First, test with a PC keyboard.
   TestingPrefService prefs;
   EventRewriter rewriter;
   rewriter.DeviceAddedForTesting(0, "PC Keyboard");
   rewriter.set_last_device_id_for_testing(0);
   rewriter.set_pref_service_for_testing(&prefs);
 
   // XK_a, Alt modifier.
   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
                                       ui::EF_ALT_DOWN,
@@ skipping 1411 matching lines @@
                                       0,
                                       ui::ET_KEY_PRESSED,
                                       keycode_a_,
                                       Mod3Mask));
 
   input_method_manager_mock_->SetCurrentInputMethodId("xkb:us::eng");
 }
 
 TEST_F(EventRewriterTest, TestRewriteBackspaceAndArrowKeys) {
   TestingPrefService prefs;
+  chromeos::Preferences::RegisterUserPrefs(&prefs);
   EventRewriter rewriter;
   rewriter.set_pref_service_for_testing(&prefs);
 
   // Alt+Backspace -> Delete
   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_DELETE,
                                       0,
                                       ui::ET_KEY_PRESSED,
                                       keycode_delete_,
                                       0U,
                                       KeyPress),
@@ skipping 81 matching lines @@
                                       keycode_end_,
                                       ShiftMask,
                                       KeyPress),
             GetRewrittenEventAsString(&rewriter,
                                       ui::VKEY_DOWN,
                                       ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN |
                                       ui::EF_CONTROL_DOWN,
                                       ui::ET_KEY_PRESSED,
                                       keycode_down_,
                                       ShiftMask | Mod1Mask | ControlMask));
+
+  // Make Search key act like a Function key for accessing extended key
+  // bindings.
+  BooleanPrefMember search_key_as_function_key;
+  search_key_as_function_key.Init(prefs::kLanguageSearchKeyActsAsFunctionKey,
+                                  &prefs, NULL);
+  search_key_as_function_key.SetValue(true);
+
+  // Alt+Backspace -> Alt+Backspace
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_BACK,
+                                      ui::EF_ALT_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_backspace_,
+                                      Mod1Mask,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_BACK,
+                                      ui::EF_ALT_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_backspace_,
+                                      Mod1Mask));
+
+  // Search+Backspace -> Delete
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_DELETE,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_delete_,
+                                      0U,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_BACK,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_backspace_,
+                                      Mod4Mask));
+
+  // Ctrl+Search+Backspace -> Ctrl+Delete
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_DELETE,
+                                      ui::EF_CONTROL_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_delete_,
+                                      ControlMask,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_BACK,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_backspace_,
+                                      Mod4Mask | ControlMask));
+
+  // Alt+Search+Backspace -> Alt+Delete
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_DELETE,
+                                      ui::EF_ALT_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_delete_,
+                                      Mod1Mask,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_BACK,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_backspace_,
+                                      Mod4Mask | Mod1Mask));
+
+  // Alt+Up -> Alt+Up
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_UP,
+                                      ui::EF_ALT_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_up_,
+                                      Mod1Mask,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_UP,
+                                      ui::EF_ALT_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_up_,
+                                      Mod1Mask));
+
+  // Search+Up -> Prior
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_PRIOR,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_prior_,
+                                      0U,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_UP,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_up_,
+                                      Mod4Mask));
+
+  // Alt+Down -> Alt+Down
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_DOWN,
+                                      ui::EF_ALT_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_down_,
+                                      Mod1Mask,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_DOWN,
+                                      ui::EF_ALT_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_down_,
+                                      Mod1Mask));
+
+  // Search+Down -> Next
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_NEXT,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_next_,
+                                      0U,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_DOWN,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_down_,
+                                      Mod4Mask));
+
+  // Ctrl+Alt+Up -> Ctrl+Alt+Up
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_UP,
+                                      ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_up_,
+                                      Mod1Mask | ControlMask,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_UP,
+                                      ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_up_,
+                                      Mod1Mask | ControlMask));
+
+  // Search+Left -> Home
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_HOME,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_home_,
+                                      0U,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_LEFT,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_left_,
+                                      Mod4Mask));
+
+  // Ctrl+Alt+Down -> Ctrl+Alt+Down
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_DOWN,
+                                      ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_down_,
+                                      Mod1Mask | ControlMask,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_DOWN,
+                                      ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_down_,
+                                      Mod1Mask | ControlMask));
+
+  // Search+Right -> End
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_END,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_end_,
+                                      0U,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_RIGHT,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_right_,
+                                      Mod4Mask));
+
+  // Ctrl+Search+Left -> Control+Home
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_HOME,
+                                      ui::EF_CONTROL_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_home_,
+                                      ControlMask,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_LEFT,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_left_,
+                                      Mod4Mask | ControlMask));
+
+  // Ctrl+Search+Right -> Control+End
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_END,
+                                      ui::EF_CONTROL_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_end_,
+                                      ControlMask,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_RIGHT,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_right_,
+                                      Mod4Mask | ControlMask));
 }
 
 TEST_F(EventRewriterTest, TestRewriteBackspaceAndArrowKeysWithSearchRemapped) {
   // Remap Search to Control.
   TestingPrefService prefs;
   chromeos::Preferences::RegisterUserPrefs(&prefs);
   IntegerPrefMember search;
   search.Init(prefs::kLanguageRemapSearchKeyTo, &prefs, NULL);
   search.SetValue(chromeos::input_method::kControlKey);
 
@@ skipping 60 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