Rename LRU Input Method to Last Input Method

chrome/browser/chromeos/input_method/input_method_persistence.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/chromeos/input_method/input_method_persistence.h"
 
 #include "base/logging.h"
 #include "base/sys_info.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/input_method/input_method_util.h"
 #include "chrome/browser/chromeos/language_preferences.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/pref_names.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 
 namespace chromeos {
 namespace input_method {
 namespace {
 
 void PersistSystemInputMethod(const std::string& input_method) {
   if (!g_browser_process || !g_browser_process->local_state())
     return;
 
   g_browser_process->local_state()->SetString(
         language_prefs::kPreferredKeyboardLayout, input_method);
 }
 
-static void SetUserLRUInputMethodPreference(const std::string& username,
-                                            const std::string& input_method,
-                                            PrefService* local_state) {
+static void SetUserLastInputMethodPreference(const std::string& username,
+                                             const std::string& input_method,
+                                             PrefService* local_state) {
   if (!username.empty() && !local_state->ReadOnly()) {
     bool update_succeed = false;
     {
       // Updater may have side-effects, therefore we do not replace
       // entry while updater exists.
-      DictionaryPrefUpdate updater(local_state, prefs::kUsersLRUInputMethod);
-      base::DictionaryValue* const users_lru_input_methods = updater.Get();
-      if (users_lru_input_methods) {
-        users_lru_input_methods->SetStringWithoutPathExpansion(username,
-                                                               input_method);
+      DictionaryPrefUpdate updater(local_state, prefs::kUsersLastInputMethod);
+      base::DictionaryValue* const users_last_input_methods = updater.Get();
+      if (users_last_input_methods) {
+        users_last_input_methods->SetStringWithoutPathExpansion(username,
+                                                                input_method);
         update_succeed = true;
       }
     }
     if (!update_succeed) {
-      // Somehow key kUsersLRUInputMethod has value of invalid type.
+      // Somehow key kUsersLastInputMethod has value of invalid type.
       // Replace and retry.
-      local_state->Set(prefs::kUsersLRUInputMethod, base::DictionaryValue());
+      local_state->Set(prefs::kUsersLastInputMethod, base::DictionaryValue());
 
-      DictionaryPrefUpdate updater(local_state, prefs::kUsersLRUInputMethod);
-      base::DictionaryValue* const users_lru_input_methods = updater.Get();
-      if (users_lru_input_methods) {
-        users_lru_input_methods->SetStringWithoutPathExpansion(username,
-                                                               input_method);
+      DictionaryPrefUpdate updater(local_state, prefs::kUsersLastInputMethod);
+      base::DictionaryValue* const users_last_input_methods = updater.Get();
+      if (users_last_input_methods) {
+        users_last_input_methods->SetStringWithoutPathExpansion(username,
+                                                                input_method);
         update_succeed = true;
       }
     }
     if (!update_succeed) {
-      DVLOG(1) << "Failed to replace local_state.kUsersLRUInputMethod: '"
-               << prefs::kUsersLRUInputMethod << "' for '" << username << "'";
+      DVLOG(1) << "Failed to replace local_state.kUsersLastInputMethod: '"
+               << prefs::kUsersLastInputMethod << "' for '" << username << "'";
     }
   }
 }
 
-// Update user LRU keyboard layout for login screen
-static void SetUserLRUInputMethod(
+// Update user Last keyboard layout for login screen
+static void SetUserLastInputMethod(
     const std::string& input_method,
     const chromeos::input_method::InputMethodManager* const manager,
     Profile* profile) {
   // Skip if it's not a keyboard layout. Drop input methods including
   // extension ones.
   if (!manager->IsLoginKeyboard(input_method))
     return;
 
   if (profile == NULL)
     return;
 
   PrefService* const local_state = g_browser_process->local_state();
 
-  SetUserLRUInputMethodPreference(
-      profile->GetProfileUserName(), input_method, local_state);
+  SetUserLastInputMethodPreference(profile->GetProfileUserName(), input_method,
+                                   local_state);
 }
 
 void PersistUserInputMethod(const std::string& input_method,
                             InputMethodManager* const manager,
                             Profile* profile) {
   PrefService* user_prefs = NULL;
   // Persist the method on a per user basis. Note that the keyboard settings are
   // stored per user desktop and a visiting window will use the same input
   // method as the desktop it is on (and not of the owner of the window).
   if (profile)
     user_prefs = profile->GetPrefs();
   if (!user_prefs)
     return;
-  SetUserLRUInputMethod(input_method, manager, profile);
+  SetUserLastInputMethod(input_method, manager, profile);
 
   const std::string current_input_method_on_pref =
       user_prefs->GetString(prefs::kLanguageCurrentInputMethod);
   if (current_input_method_on_pref == input_method)
     return;
 
   user_prefs->SetString(prefs::kLanguagePreviousInputMethod,
                         current_input_method_on_pref);
   user_prefs->SetString(prefs::kLanguageCurrentInputMethod,
                         input_method);
@@ skipping 39 matching lines @@
       return;
   }
   NOTREACHED();
 }
 
 void InputMethodPersistence::OnSessionStateChange(
     InputMethodManager::UISessionState new_ui_session) {
   ui_session_ = new_ui_session;
 }
 
-void SetUserLRUInputMethodPreferenceForTesting(const std::string& username,
-                                               const std::string& input_method,
-                                               PrefService* const local_state) {
-  SetUserLRUInputMethodPreference(username, input_method, local_state);
+void SetUserLastInputMethodPreferenceForTesting(
+    const std::string& username,
+    const std::string& input_method,
+    PrefService* const local_state) {
+  SetUserLastInputMethodPreference(username, input_method, local_state);
 }
 
 }  // namespace input_method
 }  // namespace chromeos