Reapply Caps Lock and Num Lock to core keyboard whenever new X input device is added

chrome/browser/chromeos/input_method/xkeyboard.cc

 // Copyright (c) 2011 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/chromeos/input_method/xkeyboard.h"
 
 #include <queue>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 78 matching lines @@
   "xkb:us:altgr-intl:eng",
   "xkb:us:intl:eng",
 };
 
 // These are the overlay names with caps lock remapped
 const char* kCapsLockRemapped[] = {
   "xkb:de:neo:ger",
   "xkb:us:colemak:eng",
 };
 
+// A string for obtaining a mask value for Num Lock.
+const char kNumLockVirtualModifierString[] = "NumLock";
+
 }  // namespace
 
 XKeyboard::XKeyboard(const InputMethodUtil& util)
     : is_running_on_chrome_os_(
         system::runtime_environment::IsRunningOnChromeOS()) {
+  num_lock_mask_ = GetNumLockMask();
+  current_num_lock_status_ = NumLockIsEnabled(num_lock_mask_);
+  current_caps_lock_status_ = CapsLockIsEnabled();
+
   for (size_t i = 0; i < arraysize(kCustomizableKeys); ++i) {
     ModifierKey key = kCustomizableKeys[i];
     current_modifier_map_.push_back(ModifierKeyPair(key, key));
   }
+
   std::string layout;
   for (size_t i = 0; i < arraysize(kKeepRightAltInputMethods); ++i) {
     layout = util.GetKeyboardLayoutName(kKeepRightAltInputMethods[i]);
     // The empty check is necessary since TOUCH_UI build does not support some
     // of the kKeepRightAltInputMethods elements. For example, when TOUCH_UI is
     // defined, util.GetKeyboardLayoutName("xkb:us:intl:eng") would return "".
     if (!layout.empty()) {
       keep_right_alt_xkb_layout_names_.insert(layout);
     }
   }
   for (size_t i = 0; i < arraysize(kCapsLockRemapped); ++i) {
     layout = util.GetKeyboardLayoutName(kCapsLockRemapped[i]);
     // The empty check is for TOUCH_UI build. See above.
     if (!layout.empty()) {
       caps_lock_remapped_xkb_layout_names_.insert(layout);
     }
   }
 }
 
 XKeyboard::~XKeyboard() {
 }
 
+// static
+unsigned int XKeyboard::GetNumLockMask() {
+  static const unsigned int kBadMask = 0;
+
+  unsigned int real_mask = kBadMask;
+  XkbDescPtr xkb_desc =
+      XkbGetKeyboard(ui::GetXDisplay(), XkbAllComponentsMask, XkbUseCoreKbd);
+  if (!xkb_desc) {
+    return kBadMask;
+  }
+
+  if (xkb_desc->dpy && xkb_desc->names && xkb_desc->names->vmods) {
+    const std::string string_to_find(kNumLockVirtualModifierString);
+    for (size_t i = 0; i < XkbNumVirtualMods; ++i) {
+      const unsigned int virtual_mod_mask = 1U << i;
+      const char* virtual_mod_str =
+          XGetAtomName(xkb_desc->dpy, xkb_desc->names->vmods[i]);
+      if (!virtual_mod_str) {
+        continue;
+      }
+      if (string_to_find == virtual_mod_str) {
+        if (!XkbVirtualModsToReal(xkb_desc, virtual_mod_mask, &real_mask)) {
+          LOG(ERROR) << "XkbVirtualModsToReal failed";
+          real_mask = kBadMask;  // reset the return value, just in case.
+        }
+        break;
+      }
+    }
+  }
+  XkbFreeKeyboard(xkb_desc, 0, True /* free all components */);
+
+  // Some code in Chrome, e.g. web_input_event_aurax11.cc, assume that Mod2Mask
+  // is always assigned to Num Lock.
+  // TODO(yusukes): Check the assumption is really okay. If not, modify such
+  // code, and then remove the CHECK below.
+  CHECK(real_mask == Mod2Mask);
+
+  return real_mask;
+}
+
 bool XKeyboard::SetLayoutInternal(const std::string& layout_name,
                                   const ModifierMap& modifier_map,
                                   bool force) {
   if (!is_running_on_chrome_os_) {
     // We should not try to change a layout on Linux or inside ui_tests. Just
     // return true.
     return true;
   }
 
   const std::string layout_to_set = CreateFullXkbLayoutName(
@@ skipping 180 matching lines @@
 }
 
 // static
 bool XKeyboard::CapsLockIsEnabled() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   XkbStateRec status;
   XkbGetState(ui::GetXDisplay(), XkbUseCoreKbd, &status);
   return status.locked_mods & LockMask;
 }
 
-// static
 void XKeyboard::SetCapsLockEnabled(bool enable_caps_lock) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   XkbLockModifiers(ui::GetXDisplay(), XkbUseCoreKbd, LockMask,
                    enable_caps_lock ? LockMask : 0);
+  current_caps_lock_status_ = enable_caps_lock;
 }
 
 // static
+bool XKeyboard::NumLockIsEnabled(unsigned int num_lock_mask) {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (!num_lock_mask) {
+    LOG(ERROR) << "Cannot get Num Lock status. Mask unknown.";
+    return true;
+  }
+  XkbStateRec status;
+  XkbGetState(ui::GetXDisplay(), XkbUseCoreKbd, &status);
+  return status.locked_mods & num_lock_mask;
+}
+
+void XKeyboard::SetNumLockEnabled(bool enable_num_lock) {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (!num_lock_mask_) {
+    LOG(ERROR) << "Cannot set Num Lock status. Mask unknown.";
+    return;
+  }
+  XkbLockModifiers(ui::GetXDisplay(), XkbUseCoreKbd, num_lock_mask_,
+                   enable_num_lock ? num_lock_mask_ : 0);
+  current_num_lock_status_ = enable_num_lock;
+}
+
+// static
 bool XKeyboard::ContainsModifierKeyAsReplacement(
     const ModifierMap& modifier_map, ModifierKey key) {
   for (size_t i = 0; i < modifier_map.size(); ++i) {
     if (modifier_map[i].replacement == key) {
       return true;
     }
   }
   return false;
 }
 
 bool XKeyboard::SetCurrentKeyboardLayoutByName(const std::string& layout_name) {
   if (SetLayoutInternal(layout_name, current_modifier_map_, false)) {
     current_layout_name_ = layout_name;
     return true;
   }
   return false;
 }
 
 bool XKeyboard::ReapplyCurrentKeyboardLayout() {
   if (current_layout_name_.empty()) {
     LOG(ERROR) << "Can't reapply XKB layout: layout unknown";
     return false;
   }
   return SetLayoutInternal(
       current_layout_name_, current_modifier_map_, true /* force */);
 }
 
+void XKeyboard::ReapplyCurrentModifierLockStatus() {
+  SetCapsLockEnabled(current_caps_lock_status_);

[Daniel Kurtz, 2011/11/04 11:49:18]

Save yourself a round trip to the server by applying both states together in a
single call to XkbLockModifiers().

[Yusuke Sato, 2011/11/07 04:31:28]

Done.

+  SetNumLockEnabled(current_num_lock_status_);
+}
+
 bool XKeyboard::RemapModifierKeys(const ModifierMap& modifier_map) {
   const std::string layout_name = current_layout_name_.empty() ?
       kDefaultLayoutName : current_layout_name_;
   if (SetLayoutInternal(layout_name, modifier_map, false)) {
     current_layout_name_ = layout_name;
     current_modifier_map_ = modifier_map;
     return true;
   }
   return false;
 }
@@ skipping 20 matching lines @@
     case kCapsLockKey:
       return "capslock";
     case kNumModifierKeys:
       break;
   }
   return "";
 }
 
 }  // namespace input_method
 }  // namespace chromeos