We should switch the keyboard layout to the layout the user set according to

chrome/browser/ui/webui/chromeos/login/signin_screen_handler.cc

 // Copyright (c) 2013 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/webui/chromeos/login/signin_screen_handler.h"
 
 #include "base/callback.h"
+#include "base/chromeos/chromeos_version.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
+#include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part_chromeos.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
+#include "chrome/browser/chromeos/input_method/input_method_util.h"
 #include "chrome/browser/chromeos/kiosk_mode/kiosk_mode_settings.h"
 #include "chrome/browser/chromeos/login/hwid_checker.h"
 #include "chrome/browser/chromeos/login/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/screen_locker.h"
 #include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/webui_login_display.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/net/network_portal_detector.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
+#include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chromeos/login/error_screen_handler.h"
 #include "chrome/browser/ui/webui/chromeos/login/native_window_delegate.h"
 #include "chrome/browser/ui/webui/chromeos/login/network_state_informer.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chromeos/chromeos_switches.h"
@@ skipping 52 matching lines @@
 // The Task posted to PostTaskAndReply in StartClearingDnsCache on the IO
 // thread.
 void ClearDnsCache(IOThread* io_thread) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (browser_shutdown::IsTryingToQuit())
     return;
 
   io_thread->ClearHostCache();
 }
 
+static bool Contains(const std::vector<std::string>& container,

[Nikita (slow), 2013/07/15 12:56:38]

nit: no need to mark function static. Usually such utility functions are just
declared in unnamed namespace

[Alexander Alekseev, 2013/07/22 14:24:21]

Both gcc/clang do not warn on unused non-static functions in unnamed namespaces.
Don't know why. So let's use static inside unnamed namespaces.

+                     const std::string& value) {
+  return std::find(container.begin(), container.end(), value) !=
+         container.end();
+}
+
 }  // namespace
 
 namespace chromeos {
 
 namespace {
 
 const char kNetworkStateOffline[] = "offline";
 const char kNetworkStateOnline[] = "online";
 const char kNetworkStateCaptivePortal[] = "behind captive portal";
 const char kNetworkStateConnecting[] = "connecting";
@@ skipping 689 matching lines @@
   AddCallback("unlockOnLoginSuccess",
               &SigninScreenHandler::HandleUnlockOnLoginSuccess);
   AddCallback("frameLoadingCompleted",
               &SigninScreenHandler::HandleFrameLoadingCompleted);
   AddCallback("showLoadingTimeoutError",
               &SigninScreenHandler::HandleShowLoadingTimeoutError);
   AddCallback("updateOfflineLogin",
               &SigninScreenHandler::HandleUpdateOfflineLogin);
 }
 
+void SigninScreenHandler::RegisterPrefs(PrefRegistrySimple* registry) {
+  registry->RegisterDictionaryPref(prefs::kUsersLRUInputMethod);
+}
+
 void SigninScreenHandler::HandleGetUsers() {
   SendUserList(false);
 }
 
 void SigninScreenHandler::ClearAndEnablePassword() {
   CallJS("cr.ui.Oobe.resetSigninUI", false);
 }
 
 void SigninScreenHandler::ClearUserPodPassword() {
   CallJS("cr.ui.Oobe.clearUserPodPassword");
@@ skipping 136 matching lines @@
   }
 }
 
 void SigninScreenHandler::OnDnsCleared() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   dns_clear_task_running_ = false;
   dns_cleared_ = true;
   ShowSigninScreenIfReady();
 }
 
+void SigninScreenHandler::SetUserInputMethodHWDefault() {
+  chromeos::input_method::InputMethodManager* manager =
+      chromeos::input_method::InputMethodManager::Get();
+  manager->ChangeInputMethod(
+      manager->GetInputMethodUtil()->GetHardwareInputMethodId());
+}
+
+static bool SetUserInputMethodImpl(

[Nikita (slow), 2013/07/15 12:56:38]

Please move this helper method to unnamed namespace in this file and drop
static.
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Nonmember,_Sta...

[Alexander Alekseev, 2013/07/22 14:24:21]

Moved to unnamed namespace and left it static, because compilers do not warn on
unused non-static functions in unnamed namespaces.

+    const std::string& username,
+    chromeos::input_method::InputMethodManager* manager) {
+  PrefService* const local_state = g_browser_process->local_state();
+
+  const base::DictionaryValue* users_lru_input_methods =
+      local_state->GetDictionary(prefs::kUsersLRUInputMethod);
+
+  if (users_lru_input_methods == NULL) {
+    DLOG(WARNING) << "SetUserInputMethod('" << username
+                  << "'): no kUsersLRUInputMethod";
+    return false;
+  }
+
+  std::string input_method;
+
+  if (!users_lru_input_methods->GetStringWithoutPathExpansion(username,
+                                                              &input_method)) {
+    DLOG(INFO) << "SetUserInputMethod('" << username
+               << "'): no input method for this user";
+    return false;
+  }
+
+  if (input_method.empty())
+    return false;
+
+  if (!manager->IsFullLatinKeyboard(input_method)) {
+    LOG(WARNING) << "SetUserInputMethod('" << username
+                 << "'): stored user LRU input method '" << input_method
+                 << "' is no longer Full Latin Keyboard Language"
+                 << " (entry dropped). Use hardware default instead.";
+
+    DictionaryPrefUpdate updater(local_state, prefs::kUsersLRUInputMethod);
+
+    base::DictionaryValue* const users_lru_input_methods = updater.Get();
+    if (users_lru_input_methods != NULL) {
+      users_lru_input_methods->SetStringWithoutPathExpansion(username, "");
+    }
+    return false;
+  }
+
+  if (!Contains(manager->GetActiveInputMethodIds(), input_method)) {
+    if (!manager->EnableInputMethod(input_method)) {
+      DLOG(ERROR) << "SigninScreenHandler::SetUserInputMethod('" << username
+                  << "'): user input method '" << input_method
+                  << "' is not enabled and enabling failed (ignored!).";
+    }
+  }
+  manager->ChangeInputMethod(input_method);
+
+  return true;
+}
+
+// Update keyboard layout to least recently used by the user.
+void SigninScreenHandler::SetUserInputMethod(const std::string& username) {
+  chromeos::input_method::InputMethodManager* const manager =
+      chromeos::input_method::InputMethodManager::Get();
+
+  const chromeos::input_method::InputMethodUtil& ime_util =
+      *manager->GetInputMethodUtil();
+
+  const bool succeed = SetUserInputMethodImpl(username, manager);
+
+  // This is also a case when LRU layout is set only for a few local users,
+  // thus others need to be switched to default locale.
+  // Otherwise they will end up using another user's locale to log in.
+  if (!succeed) {
+    DLOG(INFO) << "SetUserInputMethod('" << username
+               << "'): failed to set user layout. Switching to default '"
+               << ime_util.GetHardwareInputMethodId() << "'";
+
+    SetUserInputMethodHWDefault();
+  }
+}
+
 void SigninScreenHandler::ShowSigninScreenIfReady() {
   if (!dns_cleared_ || !cookies_cleared_ || !delegate_)
     return;
 
   std::string active_network =
       network_state_informer_->active_network_service_path();
   if (gaia_silent_load_ &&
       (!network_state_informer_->is_online() ||
        gaia_silent_load_network_ != active_network)) {
     // Network has changed. Force Gaia reload.
     gaia_silent_load_ = false;
     // Gaia page will be realoded, so focus isn't stolen anymore.
     focus_stolen_ = false;
   }
 
   // Note that LoadAuthExtension clears |email_|.
   if (email_.empty())
     delegate_->LoadSigninWallpaper();
   else
     delegate_->LoadWallpaper(email_);
 
+  // Set Least Recently Used input method for the user.
+  if (!email_.empty())
+    SetUserInputMethod(email_);
+
   LoadAuthExtension(!gaia_silent_load_, false, false);
   UpdateUIState(UI_STATE_GAIA_SIGNIN, NULL);
 
   if (gaia_silent_load_) {
     // The variable is assigned to false because silently loaded Gaia page was
     // used.
     gaia_silent_load_ = false;
     if (focus_stolen_)
       HandleLoginWebuiReady();
   }
@@ skipping 192 matching lines @@
   if (gaia_silent_load_ && email_.empty()) {
     dns_cleared_ = true;
     cookies_cleared_ = true;
     ShowSigninScreenIfReady();
   } else {
     StartClearingDnsCache();
     StartClearingCookies(base::Bind(
         &SigninScreenHandler::ShowSigninScreenIfReady,
         weak_factory_.GetWeakPtr()));
   }
+  SetUserInputMethodHWDefault();
 }
 
 void SigninScreenHandler::HandleToggleEnrollmentScreen() {
   if (delegate_)
     delegate_->ShowEnterpriseEnrollmentScreen();
 }
 
 void SigninScreenHandler::HandleToggleKioskEnableScreen() {
   if (delegate_ &&
       !g_browser_process->browser_policy_connector()->IsEnterpriseManaged()) {
@@ skipping 460 matching lines @@
   rvh->ExecuteJavascriptInWebFrame(
       ASCIIToUTF16("//iframe[@id='signin-frame']\n//iframe"),
       ASCIIToUTF16(code));
 
   // Test properties are cleared in HandleCompleteLogin because the form
   // submission might fail and login will not be attempted after reloading
   // if they are cleared here.
 }
 
 }  // namespace chromeos