IME refactoring: ChromeOS introduce input methods State.

chrome/browser/chromeos/login/session/user_session_manager.cc

 // Copyright 2014 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/session/user_session_manager.h"
 
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
@@ skipping 55 matching lines @@
 #include "components/user_manager/user.h"
 #include "components/user_manager/user_type.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 
 namespace chromeos {
 
 namespace {
 
 void InitLocaleAndInputMethodsForNewUser(
-    PrefService* prefs,
+    UserSessionManager* session_manager,
+    Profile* profile,
     const std::string& public_session_locale,
     const std::string& public_session_input_method) {
+  PrefService* prefs = profile->GetPrefs();
   std::string locale;
   if (!public_session_locale.empty()) {
     // If this is a public session and the user chose a |public_session_locale|,
     // write it to |prefs| so that the UI switches to it.
     locale = public_session_locale;
     prefs->SetString(prefs::kApplicationLocale, locale);
 
     // Suppress the locale change dialog.
     prefs->SetString(prefs::kApplicationLocaleAccepted, locale);
   } else {
     // Otherwise, assume that the session will use the current UI locale.
     locale = g_browser_process->GetApplicationLocale();
   }
 
   // First, we'll set kLanguagePreloadEngines.
   input_method::InputMethodManager* manager =
       input_method::InputMethodManager::Get();
   std::vector<std::string> input_method_ids;
 
   if (!public_session_input_method.empty()) {
     // If this is a public session and the user chose a
     // |public_session_input_method|, set kLanguagePreloadEngines to this input
     // method only.
     input_method_ids.push_back(public_session_input_method);
   } else {
     // Otherwise, set kLanguagePreloadEngines to a list of input methods derived
     // from the |locale| and the currently active input method.
     manager->GetInputMethodUtil()->GetFirstLoginInputMethodIds(
-        locale, manager->GetCurrentInputMethod(), &input_method_ids);
+        locale,
+        session_manager->GetDefaultIMEState(profile)->GetCurrentInputMethod(),
+        &input_method_ids);
   }
 
   // Save the input methods in the user's preferences.
   StringPrefMember language_preload_engines;
   language_preload_engines.Init(prefs::kLanguagePreloadEngines, prefs);
   language_preload_engines.SetValue(JoinString(input_method_ids, ','));
   BootTimesLoader::Get()->AddLoginTimeMarker("IMEStarted", false);
 
   // Second, we'll set kLanguagePreferredLanguages.
   std::vector<std::string> language_codes;
@@ skipping 93 matching lines @@
 }
 
 UserSessionManager::UserSessionManager()
     : delegate_(NULL),
       has_auth_cookies_(false),
       user_sessions_restored_(false),
       exit_after_session_restore_(false),
       session_restore_strategy_(
           OAuth2LoginManager::RESTORE_FROM_SAVED_OAUTH2_REFRESH_TOKEN) {
   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
+  UserManager::Get()->AddSessionStateObserver(this);
 }
 
 UserSessionManager::~UserSessionManager() {
+  // UserManager is destroyed before singletons, so we need to check if it
+  // still exists.
+  // TODO(nkostylev): fix order of destruction of UserManager
+  // / UserSessionManager objects.
+  if (UserManager::IsInitialized())
+    UserManager::Get()->RemoveSessionStateObserver(this);
   net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
 }
 
 void UserSessionManager::StartSession(
     const UserContext& user_context,
     scoped_refptr<Authenticator> authenticator,
     bool has_auth_cookies,
     bool has_active_session,
     UserSessionManagerDelegate* delegate) {
   authenticator_ = authenticator;
@@ skipping 82 matching lines @@
       base::Bind(&base::PathExists, GetRlzDisabledFlagPath()),
       base::Bind(&UserSessionManager::InitRlzImpl, AsWeakPtr(), profile));
 #endif
 }
 
 OAuth2LoginManager::SessionRestoreStrategy
 UserSessionManager::GetSigninSessionRestoreStrategy() {
   return session_restore_strategy_;
 }
 
-// static
 void UserSessionManager::SetFirstLoginPrefs(
-    PrefService* prefs,
+    Profile* profile,
     const std::string& public_session_locale,
     const std::string& public_session_input_method) {
   VLOG(1) << "Setting first login prefs";
-  InitLocaleAndInputMethodsForNewUser(prefs,
-                                      public_session_locale,
-                                      public_session_input_method);
+  InitLocaleAndInputMethodsForNewUser(
+      this, profile, public_session_locale, public_session_input_method);
 }
 
 bool UserSessionManager::GetAppModeChromeClientOAuthInfo(
     std::string* chrome_client_id, std::string* chrome_client_secret) {
   if (!chrome::IsRunningInForcedAppMode() ||
       chrome_client_id_.empty() ||
       chrome_client_secret_.empty()) {
     return false;
   }
 
@@ skipping 84 matching lines @@
   const bool enable_layouts = UserManager::Get()->IsLoggedInAsGuest();
   locale_util::SwitchLanguage(pref_locale,
                               enable_layouts,
                               false /* login_layouts_only */,
                               callback.Pass());
 
   return true;
 }
 
 void UserSessionManager::AddSessionStateObserver(
-    UserSessionStateObserver* observer) {
+    chromeos::UserSessionStateObserver* observer) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   session_state_observer_list_.AddObserver(observer);
 }
 
 void UserSessionManager::RemoveSessionStateObserver(
-    UserSessionStateObserver* observer) {
+    chromeos::UserSessionStateObserver* observer) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   session_state_observer_list_.RemoveObserver(observer);
 }
 
 void UserSessionManager::OnSessionRestoreStateChanged(
     Profile* user_profile,
     OAuth2LoginManager::SessionRestoreState state) {
   user_manager::User::OAuthTokenStatus user_status =
       user_manager::User::OAUTH_TOKEN_STATUS_UNKNOWN;
   OAuth2LoginManager* login_manager =
@@ skipping 178 matching lines @@
     case Profile::MAX_CREATE_STATUS:
       NOTREACHED();
       break;
   }
 }
 
 void UserSessionManager::InitProfilePreferences(
     Profile* profile,
     const UserContext& user_context) {
   if (UserManager::Get()->IsCurrentUserNew()) {
-    SetFirstLoginPrefs(profile->GetPrefs(),
+    SetFirstLoginPrefs(profile,
                        user_context.GetPublicSessionLocale(),
                        user_context.GetPublicSessionInputMethod());
   }
 
   if (UserManager::Get()->IsLoggedInAsSupervisedUser()) {
     user_manager::User* active_user = UserManager::Get()->GetActiveUser();
     std::string supervised_user_sync_id =
         UserManager::Get()->GetSupervisedUserManager()->
             GetUserSyncId(active_user->email());
     profile->GetPrefs()->SetString(prefs::kSupervisedUserId,
@@ skipping 310 matching lines @@
                  true,   // has_active_session
                  this);
   } else {
     RestorePendingUserSessions();
   }
 }
 
 void UserSessionManager::NotifyPendingUserSessionsRestoreFinished() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   user_sessions_restored_ = true;
-  FOR_EACH_OBSERVER(UserSessionStateObserver,
+  FOR_EACH_OBSERVER(chromeos::UserSessionStateObserver,
                     session_state_observer_list_,
                     PendingUserSessionsRestoreFinished());
 }
 
+void UserSessionManager::ActiveUserChanged(
+    const user_manager::User* active_user) {
+  input_method::InputMethodManager* manager =
+      input_method::InputMethodManager::Get();
+  manager->SetState(
+      GetDefaultIMEState(ProfileHelper::Get()->GetProfileByUser(active_user)));
+}
+
+scoped_refptr<input_method::InputMethodManager::State>
+UserSessionManager::GetDefaultIMEState(Profile* profile) {
+  scoped_refptr<input_method::InputMethodManager::State> state =
+      default_ime_states_[profile];
+  if (!state) {
+    // Profile can be NULL in tests.
+    state = input_method::InputMethodManager::Get()->CreateNewState(profile);
+    default_ime_states_[profile] = state;
+  }
+  return state;
+}
+
 }  // namespace chromeos