Allow Caps Lock to be remapped [part 2 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 "base/command_line.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"
 #include "chrome/browser/chromeos/xinput_hierarchy_changed_event_listener.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "ui/base/keycodes/keyboard_code_conversion_x.h"
 #include "ui/base/x/x11_util.h"
 
 using chromeos::input_method::InputMethodManager;
 #endif
 
 namespace {
 
 const int kBadDeviceId = -1;
@@ skipping 16 matching lines @@
     { XK_Control_L, XK_Control_R, XK_Control_L, XK_Control_R }},
   { chromeos::input_method::kAltKey, ui::EF_ALT_DOWN, Mod1Mask,
     ui::VKEY_MENU, { XK_Alt_L, XK_Alt_R, XK_Meta_L, XK_Meta_R }},
   { chromeos::input_method::kVoidKey, 0, 0U, ui::VKEY_UNKNOWN,
     { XK_VoidSymbol, XK_VoidSymbol, XK_VoidSymbol, XK_VoidSymbol }},
   { chromeos::input_method::kCapsLockKey, 0, 0U, ui::VKEY_CAPITAL,
     { XK_Caps_Lock, XK_Caps_Lock, XK_Caps_Lock, XK_Caps_Lock }},
 };
 
 const ModifierRemapping* kModifierRemappingCtrl = &kModifierRemappings[1];
+const ModifierRemapping* kModifierRemappingCapsLock = &kModifierRemappings[4];
 
 // 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.
@@ skipping 26 matching lines @@
     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.
+bool HasChromeOSKeyboard() {
+  return CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kHasChromeOSKeyboard);
+}
+
+bool IsMod3InUse() {

[Daniel Erat, 2012/11/01 19:13:06]

nit: IsMod3UsedByCurrentInputMethod() may be a bit clearer

[Yusuke Sato, 2012/11/01 19:25:27]

Thanks, done.

+  // 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() !=
+  return InputMethodManager::GetInstance()->GetCurrentInputMethod().id() ==
       kNeo2LayoutId;
 }
 #endif
 
 const PrefService* GetPrefService() {
   Profile* profile = ProfileManager::GetDefaultProfile();
   if (profile)
     return profile->GetPrefs();
   return NULL;
 }
@@ skipping 256 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();
+  // When a Chrome OS keyboard is available, the configuration UI for Caps Lock
+  // is not shown. Therefore, ignore the kLanguageRemapCapsLockKeyTo syncable
+  // pref. If Mod3 is in use, don't check the pref either.
+  const bool skip_mod3 = HasChromeOSKeyboard() || IsMod3InUse();
+
   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.
@@ skipping 47 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;
+  const ModifierRemapping* remapped_key = NULL;
   switch (keysym) {
-    // XF86XK_Launch7 (F16) with Mod3Mask is sent when Caps Lock is pressed.
+    // On Chrome OS, XF86XK_Launch7 (F16) with Mod3Mask is sent when Caps Lock
+    // is pressed (with one exception: when IsMod3InUse() is true, the key
+    // generates XK_ISO_Level3_Shift with Mod3Mask, not XF86XK_Launch7).
     case XF86XK_Launch7:
-      pref_name = skip_mod3 ? NULL : prefs::kLanguageRemapCapsLockKeyTo;
+      // When a Chrome OS keyboard is available, the configuration UI for Caps
+      // Lock is not shown. Therefore, ignore the kLanguageRemapCapsLockKeyTo
+      // syncable pref.
+      if (HasChromeOSKeyboard())
+        remapped_key = kModifierRemappingCapsLock;
+      else
+        remapped_key =
+            GetRemappedKey(prefs::kLanguageRemapCapsLockKeyTo, *pref_service);
       break;
     case XK_Super_L:
     case XK_Super_R:
-      pref_name = prefs::kLanguageRemapSearchKeyTo;
+      // Rewrite Command-L/R key presses on an Apple keyboard to Control-L/R.
+      if (IsAppleKeyboard())
+        remapped_key = kModifierRemappingCtrl;
+      else
+        remapped_key =
+            GetRemappedKey(prefs::kLanguageRemapSearchKeyTo, *pref_service);
       break;
     case XK_Control_L:
     case XK_Control_R:
-      pref_name = prefs::kLanguageRemapControlKeyTo;
+      remapped_key =
+          GetRemappedKey(prefs::kLanguageRemapControlKeyTo, *pref_service);
       break;
     case XK_Alt_L:
     case XK_Alt_R:
     case XK_Meta_L:
     case XK_Meta_R:
-      pref_name = prefs::kLanguageRemapAltKeyTo;
+      remapped_key =
+          GetRemappedKey(prefs::kLanguageRemapAltKeyTo, *pref_service);
       break;
     default:
       break;
   }
-  if (pref_name) {
-    const ModifierRemapping* remapped_key =
-        GetRemappedKey(pref_name, *pref_service);
-    // Rewrite Command-L/R key presses on an Apple keyboard to Control-L/R.
-    if (IsAppleKeyboard() && (keysym == XK_Super_L || keysym == XK_Super_R))
-      remapped_key = kModifierRemappingCtrl;
-    if (remapped_key) {
-      remapped_keycode = remapped_key->keycode;
-      const size_t level = (event->IsShiftDown() ? (1 << 1) : 0) +
-          (IsRight(keysym) ? (1 << 0) : 0);
-      const KeySym native_keysym = remapped_key->native_keysyms[level];
-      remapped_native_keycode = NativeKeySymToNativeKeycode(native_keysym);
-    }
+
+  if (remapped_key) {
+    remapped_keycode = remapped_key->keycode;
+    const size_t level = (event->IsShiftDown() ? (1 << 1) : 0) +
+        (IsRight(keysym) ? (1 << 0) : 0);
+    const KeySym native_keysym = remapped_key->native_keysyms[level];
+    remapped_native_keycode = NativeKeySymToNativeKeycode(native_keysym);
   }
 
   // Next, remap modifier bits.
   int remapped_flags = 0;
   unsigned int remapped_native_modifiers = 0U;
   GetRemappedModifierMasks(event->flags(), xkey->state,
                            &remapped_flags, &remapped_native_modifiers);
 
   // Toggle Caps Lock if the remapped key is ui::VKEY_CAPITAL, but do nothing if
   // the original key is ui::VKEY_CAPITAL (i.e. a Caps Lock key on an external
@@ skipping 213 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;
 }