Deactivate all input methods (except keyboard layouts) when screen is locked.

chrome/browser/chromeos/login/screen_locker.cc

 // Copyright (c) 2010 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/login/screen_locker.h"
 
+#include <string>
+#include <vector>
+
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/message_loop.h"
 #include "base/singleton.h"
+#include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_list.h"
+#include "chrome/browser/chromeos/cros/language_library.h"
 #include "chrome/browser/chromeos/cros/screen_lock_library.h"
+#include "chrome/browser/chromeos/language_preferences.h"
 #include "chrome/browser/chromeos/login/authenticator.h"
 #include "chrome/browser/chromeos/login/background_view.h"
 #include "chrome/browser/chromeos/login/login_utils.h"
 #include "chrome/browser/chromeos/login/message_bubble.h"
 #include "chrome/browser/chromeos/login/screen_lock_view.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/common/notification_service.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "views/screen.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget_gtk.h"
 
 #include "chrome/browser/chromeos/wm_ipc.h"
 #include "third_party/cros/chromeos_wm_ipc_enums.h"
 
 namespace {
 // The maxium times that the screen locker should try to grab input,
 // and its interval. It has to be able to grab all inputs in 30 seconds,
 // otherwise chromium process fails and the session is terminated.
 const int64 kRetryGrabIntervalMs = 500;
 const int kGrabFailureLimit = 60;
+// Each keyboard layout has a dummy input method ID which starts with "xkb:".
+const char kValidInputMethodPrefix[] = "xkb:";
 
 // Observer to start ScreenLocker when the screen lock
 class ScreenLockObserver : public chromeos::ScreenLockLibrary::Observer,
                            public NotificationObserver {
  public:
   ScreenLockObserver() {
     registrar_.Add(this, NotificationType::LOGIN_USER_CHANGED,
                    NotificationService::AllSources());
   }
 
   // NotificationObserver overrides:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
     if (type == NotificationType::LOGIN_USER_CHANGED) {
       // Register Screen Lock after login screen to make sure
       // we don't show the screen lock on top of the login screen by accident.
       if (chromeos::CrosLibrary::Get()->EnsureLoaded())
         chromeos::CrosLibrary::Get()->GetScreenLockLibrary()->AddObserver(this);
     }
   }
 
   virtual void LockScreen(chromeos::ScreenLockLibrary* obj) {
+    SetupInputMethodsForScreenLocker();
     chromeos::ScreenLocker::Show();
   }
 
   virtual void UnlockScreen(chromeos::ScreenLockLibrary* obj) {
+    RestoreInputMethods();
     chromeos::ScreenLocker::Hide();
   }
 
   virtual void UnlockScreenFailed(chromeos::ScreenLockLibrary* obj) {
     chromeos::ScreenLocker::UnlockScreenFailed();
   }
 
  private:
+  // Temporarily deactivates all input methods (e.g. Chinese, Japanese, Arabic)
+  // since they are not necessary to input a login password. Users are still
+  // able to use/switch active keyboard layouts (e.g. US qwerty, US dvorak,
+  // French).
+  void SetupInputMethodsForScreenLocker() {
+    if (chromeos::CrosLibrary::Get()->EnsureLoaded() &&
+        // The LockScreen function is also called when the OS is suspended, and
+        // in that case |saved_active_input_method_list_| might be non-empty.
+        saved_active_input_method_list_.empty()) {
+      chromeos::LanguageLibrary* language =
+          chromeos::CrosLibrary::Get()->GetLanguageLibrary();
+      saved_current_input_method_id_ = language->current_input_method().id;
+      // TODO(yusukes): save/restore previous input method ID.
+      scoped_ptr<chromeos::InputMethodDescriptors> active_input_method_list(
+          language->GetActiveInputMethods());
+
+      chromeos::ImeConfigValue value;
+      value.type = chromeos::ImeConfigValue::kValueTypeStringList;
+      for (size_t i = 0; i < active_input_method_list->size(); ++i) {
+        const std::string& input_method_id = active_input_method_list->at(i).id;
+        saved_active_input_method_list_.push_back(input_method_id);
+        // |active_input_method_list| contains both input method descriptions
+        // and keyboard layout descriptions.
+        if (!StartsWithASCII(input_method_id, kValidInputMethodPrefix, true))
+          continue;
+        value.string_list_value.push_back(input_method_id);
+      }
+      if (value.string_list_value.empty()) {
+        value.string_list_value.push_back(kFallbackInputMethodId);  // US qwerty
+      }
+      language->SetImeConfig(chromeos::kGeneralSectionName,
+                             chromeos::kPreloadEnginesConfigName,
+                             value);
+    }
+  }
+
+  void RestoreInputMethods() {
+    if (chromeos::CrosLibrary::Get()->EnsureLoaded() &&
+        !saved_active_input_method_list_.empty()) {
+      chromeos::LanguageLibrary* language =
+          chromeos::CrosLibrary::Get()->GetLanguageLibrary();
+
+      chromeos::ImeConfigValue value;
+      value.type = chromeos::ImeConfigValue::kValueTypeStringList;
+      value.string_list_value = saved_active_input_method_list_;
+      language->SetImeConfig(chromeos::kGeneralSectionName,
+                             chromeos::kPreloadEnginesConfigName,
+                             value);
+      language->ChangeInputMethod(saved_current_input_method_id_);
+
+      saved_current_input_method_id_.clear();
+      saved_active_input_method_list_.clear();
+    }
+  }
+
   NotificationRegistrar registrar_;
+  std::string saved_current_input_method_id_;
+  std::vector<std::string> saved_active_input_method_list_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenLockObserver);
 };
 
 // A child widget that grabs both keyboard and pointer input.
 // TODO(oshima): catch grab-broke event and quit if it ever happenes.
 class GrabWidget : public views::WidgetGtk {
  public:
   explicit GrabWidget(chromeos::ScreenLocker* screen_locker)
       : views::WidgetGtk(views::WidgetGtk::TYPE_CHILD),
@@ skipping 333 matching lines @@
     LOG(INFO) << "Screen is unlocked";
   }
 }
 
 // static
 void ScreenLocker::InitClass() {
   Singleton<ScreenLockObserver>::get();
 }
 
 }  // namespace chromeos