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

chrome/browser/ui/ash/event_rewriter.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 <vector>
 
 #include "ash/shell.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/events/event.h"
 #include "ui/base/keycodes/keyboard_code_conversion.h"
 
 #if defined(OS_CHROMEOS)
 #include <X11/extensions/XInput2.h>
 #include <X11/keysym.h>
+#include <X11/XF86keysym.h>
 #include <X11/Xlib.h>
 
 // Get rid of a macro from Xlib.h that conflicts with OwnershipService class.
 #undef Status
 
 #include "base/chromeos/chromeos_version.h"
 #include "chrome/browser/chromeos/input_method/input_method_manager.h"
 #include "chrome/browser/chromeos/input_method/xkeyboard.h"
 #include "chrome/browser/chromeos/login/base_login_display_host.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
@@ skipping 35 matching lines @@
 
 const ModifierRemapping* kModifierRemappingCtrl = &kModifierRemappings[1];
 
 // A structure for converting |native_modifier| to a pair of |flag| and
 // |pref_name|.
 const struct ModifierFlagToPrefName {
   unsigned int native_modifier;
   int flag;
   const char* pref_name;
 } kModifierFlagToPrefName[] = {
+  // TODO(yusukes): When the device has a Chrome keyboard (i.e. the one without
+  // Caps Lock), we should not check kLanguageRemapCapsLockKeyTo.
+  { Mod3Mask, 0, prefs::kLanguageRemapCapsLockKeyTo },
   { Mod4Mask, 0, prefs::kLanguageRemapSearchKeyTo },
   { ControlMask, ui::EF_CONTROL_DOWN, prefs::kLanguageRemapControlKeyTo },
   { Mod1Mask, ui::EF_ALT_DOWN, prefs::kLanguageRemapAltKeyTo },
 };
 
 // Gets a remapped key for |pref_name| key. For example, to find out which
 // key Search is currently remapped to, call the function with
 // prefs::kLanguageRemapSearchKeyTo.
 const ModifierRemapping* GetRemappedKey(const std::string& pref_name,
                                         const PrefService& pref_service) {
@@ skipping 14 matching lines @@
     case XK_Hyper_R:
     case XK_Meta_R:
     case XK_Shift_R:
     case XK_Super_R:
       return true;
     default:
       break;
   }
   return false;
 }
+
+bool ShouldRemapCapsLock() {
+  // 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 Mod3Mask
+  // when Neo2 is in use.
+  // TODO(yusukes): Remove the restriction.
+  return InputMethodManager::GetInstance()->GetCurrentInputMethod().id() !=
+      kNeo2LayoutId;
+}
 #endif
 
 const PrefService* GetPrefService() {
   Profile* profile = ProfileManager::GetDefaultProfile();
   if (profile)
     return profile->GetPrefs();
   return NULL;
 }
 
 }  // namespace
@@ skipping 215 matching lines @@
 #endif
 
 void EventRewriter::Rewrite(ui::KeyEvent* event) {
 #if defined(OS_CHROMEOS)
   // Do not rewrite an event sent by ui_controls::SendKeyPress(). See
   // crbug.com/136465.
   if (event->native_event()->xkey.send_event)
     return;
 #endif
   RewriteModifiers(event);
-  // This should be called after RewriteModifiers(). Otherwise, remapped
-  // Mod3Mask might be re-remapped.
-  RewriteFnKey(event);
   RewriteNumPadKeys(event);
   RewriteBackspaceAndArrowKeys(event);
   // TODO(yusukes): Implement crosbug.com/27167 (allow sending function keys).
 }
 
 bool EventRewriter::IsAppleKeyboard() const {
   if (last_device_id_ == kBadDeviceId)
     return false;
 
   // Check which device generated |event|.
@@ skipping 19 matching lines @@
   if (chromeos::UserManager::Get()->IsLoggedInAsGuest() &&
       chromeos::BaseLoginDisplayHost::default_host()) {
     return;
   }
 
   const PrefService* pref_service =
       pref_service_ ? pref_service_ : GetPrefService();
   if (!pref_service)
     return;
 
+  const bool skip_mod3 = !ShouldRemapCapsLock();
   for (size_t i = 0; i < arraysize(kModifierFlagToPrefName); ++i) {
+    if (skip_mod3 &&
+        (kModifierFlagToPrefName[i].native_modifier == Mod3Mask)) {
+      continue;
+    }
     if (original_native_modifiers &
         kModifierFlagToPrefName[i].native_modifier) {
       const ModifierRemapping* remapped_key =
           GetRemappedKey(kModifierFlagToPrefName[i].pref_name, *pref_service);
       // Rewrite Command-L/R key presses on an Apple keyboard to Control-L/R.
       if (IsAppleKeyboard() &&
           (kModifierFlagToPrefName[i].native_modifier == Mod4Mask)) {
         remapped_key = kModifierRemappingCtrl;
       }
       if (remapped_key) {
         *remapped_flags |= remapped_key->flag;
         *remapped_native_modifiers |= remapped_key->native_modifier;
       } else {
         *remapped_flags |= kModifierFlagToPrefName[i].flag;
         *remapped_native_modifiers |=
             kModifierFlagToPrefName[i].native_modifier;
       }
     }
   }
 
   *remapped_flags =
       (original_flags & ~(ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN)) |
       *remapped_flags;
+
+  unsigned int native_mask = Mod4Mask | ControlMask | Mod1Mask;
+  if (!skip_mod3)
+    native_mask |= Mod3Mask;
   *remapped_native_modifiers =
-      (original_native_modifiers & ~(Mod4Mask | ControlMask | Mod1Mask)) |
+      (original_native_modifiers & ~native_mask) |
       *remapped_native_modifiers;
 #endif
 }
 
 bool EventRewriter::RewriteModifiers(ui::KeyEvent* event) {
   // Do nothing if we have just logged in as guest but have not restarted chrome
   // process yet (so we are still on the login screen). In this situations we
   // have no user profile so can not do anything useful.
   // Note that currently, unlike other accounts, when user logs in as guest, we
   // restart chrome process. In future this is to be changed.
@@ skipping 13 matching lines @@
   DCHECK_EQ(chromeos::input_method::kControlKey,
             kModifierRemappingCtrl->remap_to);
 
   XEvent* xev = event->native_event();
   XKeyEvent* xkey = &(xev->xkey);
   KeySym keysym = XLookupKeysym(xkey, 0);
 
   ui::KeyboardCode remapped_keycode = event->key_code();
   KeyCode remapped_native_keycode = xkey->keycode;
 
+  const bool skip_mod3 = !ShouldRemapCapsLock();
+
   // First, remap |keysym|.
   const char* pref_name = NULL;
   switch (keysym) {
+    // XF86XK_Launch7 (F16) with Mod3Mask is sent when Caps Lock is pressed.
+    case XF86XK_Launch7:
+      pref_name = skip_mod3 ? NULL : prefs::kLanguageRemapCapsLockKeyTo;
+      break;
     case XK_Super_L:
     case XK_Super_R:
       pref_name = prefs::kLanguageRemapSearchKeyTo;
       break;
     case XK_Control_L:
     case XK_Control_R:
       pref_name = prefs::kLanguageRemapControlKeyTo;
       break;
     case XK_Alt_L:
     case XK_Alt_R:
@@ skipping 39 matching lines @@
   OverwriteEvent(event,
                  remapped_native_keycode, remapped_native_modifiers,
                  remapped_keycode, remapped_flags);
   return true;
 #else
   // TODO(yusukes): Support Ash on other platforms if needed.
   return false;
 #endif
 }
 
-bool EventRewriter::RewriteFnKey(ui::KeyEvent* event) {
-#if defined(OS_CHROMEOS)
-  // Since both German Neo2 XKB layout and F15 depend on Mod3Mask, it's not
-  // possible to make both features work. For now, we don't remap Mod3Mask to
-  // ControlMask when Neo2 is in use.
-  // TODO(yusukes): Remove the restriction.
-  if (InputMethodManager::GetInstance()->GetCurrentInputMethod().id() ==
-      kNeo2LayoutId) {
-    return false;
-  }
-
-  XEvent* xev = event->native_event();
-  XKeyEvent* xkey = &(xev->xkey);
-
-  int remapped_flags = event->flags();
-  unsigned int remapped_native_modifiers = xkey->state;
-
-  // TODO(yusukes): Add a pref entry for specifying how to remap Fn key, and
-  // check it here if not in guest mode.
-  if (xkey->state & Mod3Mask) {
-    remapped_flags |= ui::EF_CONTROL_DOWN;
-    remapped_native_modifiers =
-        (remapped_native_modifiers & ~Mod3Mask) | ControlMask;
-  }
-
-  OverwriteEvent(event,
-                 xkey->keycode, remapped_native_modifiers,
-                 event->key_code(), remapped_flags);
-  return true;
-#else
-  // TODO(yusukes): Support Ash on other platforms if needed.
-  return false;
-#endif
-}
-
 bool EventRewriter::RewriteNumPadKeys(ui::KeyEvent* event) {
   bool rewritten = false;
 #if defined(OS_CHROMEOS)
   XEvent* xev = event->native_event();
   XKeyEvent* xkey = &(xev->xkey);
 
   const KeySym keysym = XLookupKeysym(xkey, 0);
   switch (keysym) {
     case XK_KP_Insert:
       OverwriteEvent(event, kp_0_xkeycode_, xkey->state | Mod2Mask,
@@ skipping 184 matching lines @@
   const DeviceType type = EventRewriter::GetDeviceType(device_name);
   if (type == kDeviceAppleKeyboard) {
     VLOG(1) << "Apple keyboard '" << device_name << "' connected: "
             << "id=" << device_id;
   }
   // Always overwrite the existing device_id since the X server may reuse a
   // device id for an unattached device.
   device_id_to_type_[device_id] = type;
   return type;
 }