Move modifier remapping code from X to Ash

chrome/browser/ui/views/ash/key_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/views/ash/key_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/event.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/keycodes/keyboard_code_conversion.h"
 
 #if defined(OS_CHROMEOS)
 #include <X11/extensions/XInput2.h>
 #include <X11/keysym.h>
 #include <X11/Xlib.h>
 
 #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/xinput_hierarchy_changed_event_listener.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;
 
+#if defined(OS_CHROMEOS)
+// A key code and a flag we should use when a key is remapped to |remap_to|.
+const struct ModifierRemapping {
+  int remap_to;
+  int flag;
+  unsigned int native_flag;
+  ui::KeyboardCode keycode;
+  unsigned int native_keysyms[4];  // left, right, shift+left, shift+right.

[Daniel Erat, 2012/05/23 16:37:32]

nit: use KeySym instead?

[Yusuke Sato, 2012/05/24 08:24:42]

Done.

+} kModifierRemappings[] = {
+  { chromeos::input_method::kSearchKey, 0, Mod4Mask, ui::VKEY_LWIN,
+    { XK_Super_L, XK_Super_L, XK_Super_L, XK_Super_L}},
+  { chromeos::input_method::kControlKey, ui::EF_CONTROL_DOWN, ControlMask,
+    ui::VKEY_CONTROL,
+    { 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 }},
+};
+
+// A structure for converting |native_flag| to a pair of |flag| and |key_name|.
+const struct ModifierFlagToPrefName {
+  unsigned int native_flag;

[Daniel Erat, 2012/05/23 16:37:32]

nit: native_modifiers?

[Yusuke Sato, 2012/05/24 08:24:42]

Done.

+  int flag;
+  const char* key_name;

[Daniel Erat, 2012/05/23 16:37:32]

nit: pref_name?

[Yusuke Sato, 2012/05/24 08:24:42]

Done.

+} kModifierFlagToPrefName[] = {
+  { Mod4Mask, 0, prefs::kLanguageXkbRemapSearchKeyTo },
+  { ControlMask, ui::EF_CONTROL_DOWN, prefs::kLanguageXkbRemapControlKeyTo },
+  { Mod1Mask, ui::EF_ALT_DOWN, prefs::kLanguageXkbRemapAltKeyTo },
+};
+
+// Gets a remapped key for |key_name| key. For example, to find out which
+// key Search is currently remapped to, call the function with
+// prefs::kLanguageXkbRemapSearchKeyTo.
+const ModifierRemapping* GetRemappedKey(const std::string& key_name,
+                                        PrefService* pref_service) {

[Daniel Erat, 2012/05/23 16:37:32]

nit: const PrefService&

[Yusuke Sato, 2012/05/24 08:24:42]

Done.

+  if (!pref_service || !pref_service->FindPreference(key_name.c_str()))
+    return NULL;  // The |key_name| hasn't been registered. On login screen?
+  const int value = pref_service->GetInteger(key_name.c_str());
+  for (size_t i = 0; i < arraysize(kModifierRemappings); ++i) {
+    if (value == kModifierRemappings[i].remap_to)
+      return &kModifierRemappings[i];
+  }
+  return NULL;
+}
+
+bool IsRight(unsigned int native_keysym) {

[Daniel Erat, 2012/05/23 16:37:32]

nit: KeySym

[Yusuke Sato, 2012/05/24 08:24:42]

Done.

+  switch (native_keysym) {
+    case XK_Alt_R:
+    case XK_Control_R:
+    case XK_Hyper_R:
+    case XK_Meta_R:
+    case XK_Shift_R:
+    case XK_Super_R:
+      return true;
+  }
+  return false;
+}
+#endif
+
+PrefService* GetPrefService() {

[Daniel Erat, 2012/05/23 16:37:32]

nit: const PrefService* ?

[Yusuke Sato, 2012/05/24 08:24:42]

Done.

+  Profile* profile = ProfileManager::GetDefaultProfile();
+  if (profile)
+    return profile->GetPrefs();
+  return NULL;
+}
+
 }  // namespace
 
-KeyRewriter::KeyRewriter() : last_device_id_(kBadDeviceId) {
+KeyRewriter::KeyRewriter()
+    : last_device_id_(kBadDeviceId),
+#if defined(OS_CHROMEOS)
+      xkeyboard_(NULL),
+#endif
+      pref_service_(NULL) {
   // The ash shell isn't instantiated for our unit tests.
   if (ash::Shell::HasInstance())
     ash::Shell::GetInstance()->GetRootWindow()->AddRootWindowObserver(this);
 #if defined(OS_CHROMEOS)
   if (base::chromeos::IsRunningOnChromeOS()) {
     chromeos::XInputHierarchyChangedEventListener::GetInstance()
         ->AddObserver(this);
   }
   RefreshKeycodes();
 #endif
@@ skipping 104 matching lines @@
     DeviceAdded(device_id);
   }
 
   last_device_id_ = device_id;
 }
 
 void KeyRewriter::RefreshKeycodes() {
   Display* display = ui::GetXDisplay();
   control_l_xkeycode_ = XKeysymToKeycode(display, XK_Control_L);
   control_r_xkeycode_ = XKeysymToKeycode(display, XK_Control_R);
+  alt_l_xkeycode_ = XKeysymToKeycode(display, XK_Alt_L);
+  alt_r_xkeycode_ = XKeysymToKeycode(display, XK_Alt_R);
+  meta_l_xkeycode_ = XKeysymToKeycode(display, XK_Meta_L);
+  meta_r_xkeycode_ = XKeysymToKeycode(display, XK_Meta_R);
+  windows_l_xkeycode_ = XKeysymToKeycode(display, XK_Super_L);
+  caps_lock_xkeycode_ = XKeysymToKeycode(display, XK_Caps_Lock);
+  void_symbol_xkeycode_ = XKeysymToKeycode(display, XK_VoidSymbol);
   kp_0_xkeycode_ = XKeysymToKeycode(display, XK_KP_0);
   kp_1_xkeycode_ = XKeysymToKeycode(display, XK_KP_1);
   kp_2_xkeycode_ = XKeysymToKeycode(display, XK_KP_2);
   kp_3_xkeycode_ = XKeysymToKeycode(display, XK_KP_3);
   kp_4_xkeycode_ = XKeysymToKeycode(display, XK_KP_4);
   kp_5_xkeycode_ = XKeysymToKeycode(display, XK_KP_5);
   kp_6_xkeycode_ = XKeysymToKeycode(display, XK_KP_6);
   kp_7_xkeycode_ = XKeysymToKeycode(display, XK_KP_7);
   kp_8_xkeycode_ = XKeysymToKeycode(display, XK_KP_8);
   kp_9_xkeycode_ = XKeysymToKeycode(display, XK_KP_9);
   kp_decimal_xkeycode_ = XKeysymToKeycode(display, XK_KP_Decimal);
 }
+
+unsigned int KeyRewriter::NativeKeySymToNativeKeycode(int keysym) {

[Daniel Erat, 2012/05/23 16:37:32]

nit: KeySym

[Yusuke Sato, 2012/05/24 08:24:42]

Done.

+  switch (keysym) {
+    case XK_Control_L:
+      return control_l_xkeycode_;
+    case XK_Control_R:
+      return control_r_xkeycode_;
+    case XK_Alt_L:
+      return alt_l_xkeycode_;
+    case XK_Alt_R:
+      return alt_r_xkeycode_;
+    case XK_Meta_L:
+      return meta_l_xkeycode_;
+    case XK_Meta_R:
+      return meta_r_xkeycode_;
+    case XK_Super_L:
+      return windows_l_xkeycode_;
+    case XK_Caps_Lock:
+      return caps_lock_xkeycode_;
+    case XK_VoidSymbol:
+      return void_symbol_xkeycode_;
+    case XK_KP_0:
+      return kp_0_xkeycode_;
+    case XK_KP_1:
+      return kp_1_xkeycode_;
+    case XK_KP_2:
+      return kp_2_xkeycode_;
+    case XK_KP_3:
+      return kp_3_xkeycode_;
+    case XK_KP_4:
+      return kp_4_xkeycode_;
+    case XK_KP_5:
+      return kp_5_xkeycode_;
+    case XK_KP_6:
+      return kp_6_xkeycode_;
+    case XK_KP_7:
+      return kp_7_xkeycode_;
+    case XK_KP_8:
+      return kp_8_xkeycode_;
+    case XK_KP_9:
+      return kp_9_xkeycode_;
+    case XK_KP_Decimal:
+      return kp_decimal_xkeycode_;
+  }
+  return 0U;
+}
 #endif
 
 void KeyRewriter::Rewrite(aura::KeyEvent* event) {
   RewriteCommandToControl(event);
+  RewriteModifiers(event);
   RewriteNumPadKeys(event);
-  // TODO(yusukes): Implement crbug.com/115112 (Search/Ctrl/Alt remapping) and
-  // crosbug.com/27167 (allow sending function keys) here.
+  // TODO(yusukes): Implement crosbug.com/27167 (allow sending function keys).
 }
 
 bool KeyRewriter::RewriteCommandToControl(aura::KeyEvent* event) {
   bool rewritten = false;
   if (last_device_id_ == kBadDeviceId)
     return rewritten;
 
   // Check which device generated |event|.
   std::map<int, DeviceType>::const_iterator iter =
       device_id_to_type_.find(last_device_id_);
@@ skipping 38 matching lines @@
   }
 
   DCHECK_NE(ui::VKEY_LWIN, ui::KeyboardCodeFromXKeyEvent(xev));
   DCHECK_NE(ui::VKEY_RWIN, ui::KeyboardCodeFromXKeyEvent(xev));
 #else
   // TODO(yusukes): Support Ash on other platforms if needed.
 #endif
   return rewritten;
 }
 
+bool KeyRewriter::RewriteModifiers(aura::KeyEvent* event) {
+  bool rewritten = false;

[Daniel Erat, 2012/05/23 16:37:32]

nit: maybe remove this variable and just return false when pref_service is NULL
or OS_CHROMEOS isn't defined and true otherwise?  or are you planning to have
more complicated logic later where this variable is conditionally set at
different places in the body of this method?  right now, it looks like it's only
true on chrome os.

[Yusuke Sato, 2012/05/24 08:24:42]

Sure, removed the variable.

+  PrefService* pref_service = pref_service_ ? pref_service_ : GetPrefService();
+  if (!pref_service)
+    return rewritten;
+
+#if defined(OS_CHROMEOS)
+  XEvent* xev = event->native_event();
+  XKeyEvent* xkey = &(xev->xkey);
+  KeySym keysym = XLookupKeysym(xkey, 0);
+
+  ui::KeyboardCode remapped_keycode = event->key_code();
+  unsigned int remapped_native_keycode = xkey->keycode;

[Daniel Erat, 2012/05/23 16:37:32]

nit: KeyCode

[Yusuke Sato, 2012/05/24 08:24:42]

Done.

+  int remapped_flags = 0;
+  unsigned int remapped_native_flags = 0U;
+
+  // First, remap |keysym|.
+  const char* key_name = NULL;
+  switch (keysym) {
+    case XK_Super_L:
+      key_name = prefs::kLanguageXkbRemapSearchKeyTo;
+      break;
+    case XK_Control_L:
+    case XK_Control_R:
+      key_name = prefs::kLanguageXkbRemapControlKeyTo;
+      break;
+    case XK_Alt_L:
+    case XK_Alt_R:
+    case XK_Meta_L:
+    case XK_Meta_R:
+      key_name = prefs::kLanguageXkbRemapAltKeyTo;
+      break;

[Daniel Erat, 2012/05/23 16:37:32]

nit: add a no-op default?  think that some compilers will warn if you don't.

[Yusuke Sato, 2012/05/24 08:24:42]

Done.

+  }
+  if (key_name) {
+    const ModifierRemapping* remapped_key =
+        GetRemappedKey(key_name, pref_service);
+    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.
+  for (size_t i = 0; i < arraysize(kModifierFlagToPrefName); ++i) {
+    if (xkey->state & kModifierFlagToPrefName[i].native_flag) {
+      const ModifierRemapping* remapped_key =
+          GetRemappedKey(kModifierFlagToPrefName[i].key_name, pref_service);
+      if (remapped_key) {
+        remapped_flags |= remapped_key->flag;
+        remapped_native_flags |= remapped_key->native_flag;
+      } else {
+        remapped_flags |= kModifierFlagToPrefName[i].flag;
+        remapped_native_flags |= kModifierFlagToPrefName[i].native_flag;
+      }
+    }
+  }
+  remapped_flags = (event->flags() & ~(ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN)) |
+      remapped_flags;
+  remapped_native_flags = (xkey->state & ~(Mod4Mask | ControlMask | Mod1Mask)) |
+      remapped_native_flags;
+
+  // 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
+  // keyboard is pressed) since X can handle that case.
+  if ((event->type() == ui::ET_KEY_PRESSED) &&
+      (event->key_code() != ui::VKEY_CAPITAL) &&
+      (remapped_keycode == ui::VKEY_CAPITAL)) {
+    chromeos::input_method::XKeyboard* xkeyboard = xkeyboard_ ?
+        xkeyboard_ : InputMethodManager::GetInstance()->GetXKeyboard();
+    xkeyboard->SetCapsLockEnabled(!xkeyboard->CapsLockIsEnabled());
+  }
+
+  OverwriteEvent(event,
+                 remapped_native_keycode, remapped_native_flags,
+                 remapped_keycode, remapped_flags);
+  rewritten = true;
+#else
+  // TODO(yusukes): Support Ash on other platforms if needed.
+#endif
+  return rewritten;
+}
+
 bool KeyRewriter::RewriteNumPadKeys(aura::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 94 matching lines @@
   const DeviceType type = KeyRewriter::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;
 }