Rename LRU Input Method to Last Input Method

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 <stddef.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 186 matching lines @@
   return network->name();
 }
 
 static bool SetUserInputMethodImpl(
     const std::string& username,
     const std::string& user_input_method,
     input_method::InputMethodManager::State* ime_state) {
   if (!chromeos::input_method::InputMethodManager::Get()->IsLoginKeyboard(
           user_input_method)) {
     LOG(WARNING) << "SetUserInputMethod('" << username
-                 << "'): stored user LRU input method '" << user_input_method
+                 << "'): stored user last input method '" << user_input_method
                  << "' is no longer Full Latin Keyboard Language"
                  << " (entry dropped). Use hardware default instead.";
 
     PrefService* const local_state = g_browser_process->local_state();
-    DictionaryPrefUpdate updater(local_state, prefs::kUsersLRUInputMethod);
+    DictionaryPrefUpdate updater(local_state, prefs::kUsersLastInputMethod);
 
-    base::DictionaryValue* const users_lru_input_methods = updater.Get();
-    if (users_lru_input_methods != nullptr) {
-      users_lru_input_methods->SetStringWithoutPathExpansion(username, "");
+    base::DictionaryValue* const users_last_input_methods = updater.Get();
+    if (users_last_input_methods != nullptr) {
+      users_last_input_methods->SetStringWithoutPathExpansion(username, "");
     }
     return false;
   }
 
   if (!Contains(ime_state->GetActiveInputMethodIds(), user_input_method)) {
     if (!ime_state->EnableInputMethod(user_input_method)) {
       DLOG(ERROR) << "SigninScreenHandler::SetUserInputMethod('" << username
                   << "'): user input method '" << user_input_method
                   << "' is not enabled and enabling failed (ignored!).";
     }
@@ skipping 129 matching lines @@
   StopEnforcingPolicyInputMethods();
   weak_factory_.InvalidateWeakPtrs();
   if (delegate_)
     delegate_->SetWebUIHandler(nullptr);
   network_state_informer_->RemoveObserver(this);
   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(nullptr);
   proximity_auth::ScreenlockBridge::Get()->SetFocusedUser(EmptyAccountId());
 }
 
 // static
-std::string SigninScreenHandler::GetUserLRUInputMethod(
+std::string SigninScreenHandler::GetUserLastInputMethod(
     const std::string& username) {
   PrefService* const local_state = g_browser_process->local_state();
-  const base::DictionaryValue* users_lru_input_methods =
-      local_state->GetDictionary(prefs::kUsersLRUInputMethod);
+  const base::DictionaryValue* users_last_input_methods =
+      local_state->GetDictionary(prefs::kUsersLastInputMethod);
 
-  if (!users_lru_input_methods) {
-    DLOG(WARNING) << "GetUserLRUInputMethod('" << username
-                  << "'): no kUsersLRUInputMethod";
+  if (!users_last_input_methods) {
+    DLOG(WARNING) << "GetUserLastInputMethod('" << username
+                  << "'): no kUsersLastInputMethod";
     return std::string();
   }
 
   std::string input_method;
 
-  if (!users_lru_input_methods->GetStringWithoutPathExpansion(username,
-                                                              &input_method)) {
-    DVLOG(0) << "GetUserLRUInputMethod('" << username
+  if (!users_last_input_methods->GetStringWithoutPathExpansion(username,
+                                                               &input_method)) {
+    DVLOG(0) << "GetUserLastInputMethod('" << username
              << "'): no input method for this user";
     return std::string();
   }
 
   return input_method;
 }
 
 // static
 // Update keyboard layout to least recently used by the user.
 void SigninScreenHandler::SetUserInputMethod(
     const std::string& username,
     input_method::InputMethodManager::State* ime_state) {
   bool succeed = false;
 
-  const std::string input_method = GetUserLRUInputMethod(username);
+  const std::string input_method = GetUserLastInputMethod(username);
 
   EnforcePolicyInputMethods(input_method);
 
   if (!input_method.empty())
     succeed = SetUserInputMethodImpl(username, input_method, ime_state);
 
-  // This is also a case when LRU layout is set only for a few local users,
+  // This is also a case when last 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) {
     DVLOG(0) << "SetUserInputMethod('" << username
              << "'): failed to set user layout. Switching to default.";
 
     ime_state->SetInputMethodLoginDefault();
   }
 }
 
@@ skipping 560 matching lines @@
   }
 }
 
 gfx::NativeWindow SigninScreenHandler::GetNativeWindow() {
   if (native_window_delegate_)
     return native_window_delegate_->GetNativeWindow();
   return nullptr;
 }
 
 void SigninScreenHandler::RegisterPrefs(PrefRegistrySimple* registry) {
-  registry->RegisterDictionaryPref(prefs::kUsersLRUInputMethod);
+  registry->RegisterDictionaryPref(prefs::kUsersLastInputMethod);
 }
 
 void SigninScreenHandler::OnCurrentScreenChanged(OobeScreen current_screen,
                                                  OobeScreen new_screen) {
   if (new_screen == OobeScreen::SCREEN_ACCOUNT_PICKER) {
     // Restore active IME state if returning to user pod row screen.
     input_method::InputMethodManager::Get()->SetState(ime_state_);
   }
 }
 
@@ skipping 616 matching lines @@
 void SigninScreenHandler::OnFeedbackFinished() {
   CallJS("login.UnrecoverableCryptohomeErrorScreen.resumeAfterFeedbackUI");
 
   // Recreate user's cryptohome after the feedback is attempted.
   HandleResyncUserData();
 }
 
 void SigninScreenHandler::OnAllowedInputMethodsChanged() {
   if (focused_pod_account_id_) {
     std::string user_input_method =
-        GetUserLRUInputMethod(focused_pod_account_id_->GetUserEmail());
+        GetUserLastInputMethod(focused_pod_account_id_->GetUserEmail());
     EnforcePolicyInputMethods(user_input_method);
   } else {
     EnforcePolicyInputMethods(std::string());
   }
 }
 
 void SigninScreenHandler::SetKeyboardSettings(const AccountId& account_id) {
   bool auto_repeat_enabled = language_prefs::kXkbAutoRepeatEnabled;
   if (user_manager::known_user::GetBooleanPref(
           account_id, prefs::kLanguageXkbAutoRepeatEnabled,
@@ skipping 15 matching lines @@
   rate.initial_delay_in_ms = auto_repeat_delay;
   rate.repeat_interval_in_ms = auto_repeat_interval;
   input_method::InputMethodManager::Get()
       ->GetImeKeyboard()
       ->SetAutoRepeatEnabled(true);
   input_method::InputMethodManager::Get()->GetImeKeyboard()->SetAutoRepeatRate(
       rate);
 }
 
 }  // namespace chromeos