Allow Caps Lock to be remapped [part 1 of 2]

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/stringprintf.h"
 #include "chrome/browser/api/prefs/pref_member.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_pref_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/events/event.h"
 
 #if defined(OS_CHROMEOS)
 #include <X11/keysym.h>
+#include <X11/XF86keysym.h>
 #include <X11/Xlib.h>
 
 #include "chrome/browser/chromeos/input_method/mock_input_method_manager.h"
 #include "chrome/browser/chromeos/input_method/mock_xkeyboard.h"
 #include "chrome/browser/chromeos/login/mock_user_manager.h"
 #include "chrome/browser/chromeos/preferences.h"
 #include "ui/base/x/x11_util.h"
 
 namespace {
 
@@ skipping 77 matching lines @@
         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_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() {
     // 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 43 matching lines @@
   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_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
 #else
 class EventRewriterTest : public testing::Test {
  public:
   EventRewriterTest() {}
   virtual ~EventRewriterTest() {}
@@ skipping 1284 matching lines @@
                                       KeyRelease),
             GetRewrittenEventAsString(&rewriter,
                                       ui::VKEY_CAPITAL,
                                       ui::EF_CAPS_LOCK_DOWN,
                                       ui::ET_KEY_RELEASED,
                                       keycode_caps_lock_,
                                       LockMask));
   EXPECT_FALSE(xkeyboard.caps_lock_is_enabled_);
 }
 
-TEST_F(EventRewriterTest, TestRewriteFn) {
+TEST_F(EventRewriterTest, DISABLED_TestRewriteCapsLock) {
+  // It seems that the X server running on build servers is too old and does not
+  // support F16 (i.e. 'XKeysymToKeycode(display_, XF86XK_Launch7)' call).
+  // TODO(yusukes): Reenable the test once build servers are upgraded.

[Daniel Erat, 2012/10/30 18:16:34]

nit: mind filing a bug to track this, if you haven't already?

[Yusuke Sato, 2012/10/30 19:11:33]

Done: http://code.google.com/p/chromium/issues/detail?id=158585

+
   TestingPrefService 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);
+  EXPECT_FALSE(xkeyboard.caps_lock_is_enabled_);
+
+  // On Chrome OS, CapsLock is mapped to F16 with Mod3Mask.
+  EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_CAPITAL,
+                                      ui::EF_CAPS_LOCK_DOWN,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_caps_lock_,
+                                      0U,
+                                      KeyPress),
+            GetRewrittenEventAsString(&rewriter,
+                                      ui::VKEY_F16,
+                                      0,
+                                      ui::ET_KEY_PRESSED,
+                                      keycode_launch7_,
+                                      0U));
+
+  EXPECT_TRUE(xkeyboard.caps_lock_is_enabled_);
+}
+
+TEST_F(EventRewriterTest, TestRewriteCapsLockToControl) {
+  TestingPrefService prefs;
+  chromeos::Preferences::RegisterUserPrefs(&prefs);
+  IntegerPrefMember control;
+  control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs, NULL);
+  control.SetValue(chromeos::input_method::kControlKey);
+
   EventRewriter rewriter;
   rewriter.set_pref_service_for_testing(&prefs);
 
-  // Press F15+a. Confirm that Mod3Mask is rewritten to ControlMask.
-  // On Chrome OS, F15 works as a modifier (Mod3). http://crosbug/p/14339
+  // Press CapsLock+a. Confirm that Mod3Mask is rewritten to ControlMask.
+  // On Chrome OS, CapsLock works as a Mod3 modifier.
   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
                                       ui::EF_CONTROL_DOWN,
                                       ui::ET_KEY_PRESSED,
                                       keycode_a_,
                                       ControlMask,
                                       KeyPress),
             GetRewrittenEventAsString(&rewriter,
                                       ui::VKEY_A,
                                       0,
                                       ui::ET_KEY_PRESSED,
                                       keycode_a_,
                                       Mod3Mask));
 
-  // Press Control+F15+a. Confirm that Mod3Mask is rewritten to ControlMask.
+  // Press Control+CapsLock+a. Confirm that Mod3Mask is rewritten to ControlMask
   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
                                       ui::EF_CONTROL_DOWN,
                                       ui::ET_KEY_PRESSED,
                                       keycode_a_,
                                       ControlMask,
                                       KeyPress),
             GetRewrittenEventAsString(&rewriter,
                                       ui::VKEY_A,
                                       ui::EF_CONTROL_DOWN,
                                       ui::ET_KEY_PRESSED,
                                       keycode_a_,
                                       Mod3Mask | ControlMask));
 
-  // Press Alt+F15+a. Confirm that Mod3Mask is rewritten to ControlMask.
+  // Press Alt+CapsLock+a. Confirm that Mod3Mask is rewritten to ControlMask.
   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
                                       ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN,
                                       ui::ET_KEY_PRESSED,
                                       keycode_a_,
                                       Mod1Mask | ControlMask,
                                       KeyPress),
             GetRewrittenEventAsString(&rewriter,
                                       ui::VKEY_A,
                                       ui::EF_ALT_DOWN,
                                       ui::ET_KEY_PRESSED,
                                       keycode_a_,
                                       Mod1Mask | Mod3Mask));
 }
 
-TEST_F(EventRewriterTest, TestRewriteFnMod3InUse) {
+TEST_F(EventRewriterTest, TestRewriteCapsLockMod3InUse) {
+  // Remap CapsLock to Control.
   TestingPrefService prefs;
+  chromeos::Preferences::RegisterUserPrefs(&prefs);
+  IntegerPrefMember control;
+  control.Init(prefs::kLanguageRemapCapsLockKeyTo, &prefs, NULL);
+  control.SetValue(chromeos::input_method::kControlKey);
+
   EventRewriter rewriter;
   rewriter.set_pref_service_for_testing(&prefs);
   input_method_manager_mock_->SetCurrentInputMethodId("xkb:de:neo:ger");
 
-  // Press F15+a. Confirm that Mod3Mask is NOT rewritten to ControlMask when
-  // Mod3Mask is already in use by the current XKB layout.
+  // Press CapsLock+a. Confirm that Mod3Mask is NOT rewritten to ControlMask
+  // when Mod3Mask is already in use by the current XKB layout.
   EXPECT_EQ(GetExpectedResultAsString(ui::VKEY_A,
                                       0,
                                       ui::ET_KEY_PRESSED,
                                       keycode_a_,
                                       Mod3Mask,
                                       KeyPress),
             GetRewrittenEventAsString(&rewriter,
                                       ui::VKEY_A,
                                       0,
                                       ui::ET_KEY_PRESSED,
@@ skipping 179 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