UserManager refactoring: move active user session restoration to UserSessionManager.

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 38 matching lines @@
 #include "chromeos/cert_loader.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/cryptohome_util.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "chromeos/ime/input_method_manager.h"
 #include "chromeos/network/portal_detector/network_portal_detector.h"
 #include "chromeos/network/portal_detector/network_portal_detector_strategy.h"
 #include "components/signin/core/browser/signin_manager_base.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 
 namespace chromeos {
 
 namespace {
 
 void InitLocaleAndInputMethodsForNewUser(PrefService* prefs) {
   // First, we'll set kLanguagePreloadEngines.
   std::string locale = g_browser_process->GetApplicationLocale();
   input_method::InputMethodManager* manager =
@@ skipping 53 matching lines @@
 // provided NSS database. It must be called for primary user only.
 void OnGetNSSCertDatabaseForUser(net::NSSCertDatabase* database) {
   if (!CertLoader::IsInitialized())
     return;
 
   CertLoader::Get()->StartWithNSSDB(database);
 }
 
 }  // namespace
 
+#if defined(ENABLE_RLZ)
+void UserSessionManagerDelegate::OnRlzInitialized() {
+}
+#endif
+
+UserSessionManagerDelegate::~UserSessionManagerDelegate() {
+}
+
+void UserSessionStateObserver::PendingUserSessionsRestoreFinished() {
+}
+
+UserSessionStateObserver::~UserSessionStateObserver() {
+}
+
 // static
 UserSessionManager* UserSessionManager::GetInstance() {
   return Singleton<UserSessionManager,
       DefaultSingletonTraits<UserSessionManager> >::get();
 }
 
 // static
 void UserSessionManager::OverrideHomedir() {
   // Override user homedir, check for ProfileManager being initialized as
   // it may not exist in unit tests.
@@ skipping 14 matching lines @@
 
 // static
 void UserSessionManager::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterStringPref(prefs::kRLZBrand, std::string());
   registry->RegisterBooleanPref(prefs::kRLZDisabled, false);
 }
 
 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);
 }
 
 UserSessionManager::~UserSessionManager() {
   net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
 }
 
-void UserSessionManager::StartSession(const UserContext& user_context,
-                                  scoped_refptr<Authenticator> authenticator,
-                                  bool has_auth_cookies,
-                                  bool has_active_session,
-                                  Delegate* delegate) {
+void UserSessionManager::StartSession(
+    const UserContext& user_context,
+    scoped_refptr<Authenticator> authenticator,
+    bool has_auth_cookies,
+    bool has_active_session,
+    UserSessionManagerDelegate* delegate) {
   authenticator_ = authenticator;
   delegate_ = delegate;
 
   VLOG(1) << "Starting session for " << user_context.GetUserID();
 
   PreStartSession();
   CreateUserSession(user_context, has_auth_cookies);
 
   if (!has_active_session)
     StartCrosSession();
@@ skipping 29 matching lines @@
   // explicitly disabled for it.
   if (!user_manager->IsUserLoggedIn() ||
       !user_manager->IsLoggedInAsRegularUser() ||
       user_manager->IsLoggedInAsStub()) {
     return;
   }
 
   User* user = ProfileHelper::Get()->GetUserByProfile(user_profile);
   DCHECK(user);
   if (!net::NetworkChangeNotifier::IsOffline()) {
-    pending_restore_sessions_.erase(user->email());
+    pending_signin_restore_sessions_.erase(user->email());
     RestoreAuthSessionImpl(user_profile, false /* has_auth_cookies */);
   } else {
     // Even if we're online we should wait till initial
     // OnConnectionTypeChanged() call. Otherwise starting fetchers too early may
     // end up canceling all request when initial network connection type is
     // processed. See http://crbug.com/121643.
-    pending_restore_sessions_.insert(user->email());
+    pending_signin_restore_sessions_.insert(user->email());
   }
 }
 
+void UserSessionManager::RestoreActiveSessions() {
+  DBusThreadManager::Get()->GetSessionManagerClient()->RetrieveActiveSessions(
+      base::Bind(&UserSessionManager::OnRestoreActiveSessions,
+                 base::Unretained(this)));
+}
+
+bool UserSessionManager::UserSessionsRestored() const {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  return user_sessions_restored_;
+}
+
 void UserSessionManager::InitRlz(Profile* profile) {
 #if defined(ENABLE_RLZ)
   if (!g_browser_process->local_state()->HasPrefPath(prefs::kRLZBrand)) {
     // Read brand code asynchronously from an OEM data and repost ourselves.
     google_brand::chromeos::InitBrand(
         base::Bind(&UserSessionManager::InitRlz, AsWeakPtr(), profile));
     return;
   }
   base::PostTaskAndReplyWithResult(
       base::WorkerPool::GetTaskRunner(false),
@@ skipping 109 matching lines @@
   // So input methods should be enabled somewhere.
   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) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  session_state_observer_list_.AddObserver(observer);
+}
+
+void UserSessionManager::RemoveSessionStateObserver(
+    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::OAuthTokenStatus user_status = User::OAUTH_TOKEN_STATUS_UNKNOWN;
   OAuth2LoginManager* login_manager =
       OAuth2LoginManagerFactory::GetInstance()->GetForProfile(user_profile);
 
   bool connection_error = false;
   switch (state) {
     case OAuth2LoginManager::SESSION_RESTORE_DONE:
@@ skipping 55 matching lines @@
   }
 
   // Need to iterate over all users and their OAuth2 session state.
   const UserList& users = user_manager->GetLoggedInUsers();
   for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
     if (!(*it)->is_profile_created())
       continue;
 
     Profile* user_profile = ProfileHelper::Get()->GetProfileByUser(*it);
     bool should_restore_session =
-        pending_restore_sessions_.find((*it)->email()) !=
-            pending_restore_sessions_.end();
+        pending_signin_restore_sessions_.find((*it)->email()) !=
+        pending_signin_restore_sessions_.end();
     OAuth2LoginManager* login_manager =
         OAuth2LoginManagerFactory::GetInstance()->GetForProfile(user_profile);
     if (login_manager->state() ==
             OAuth2LoginManager::SESSION_RESTORE_IN_PROGRESS) {
       // If we come online for the first time after successful offline login,
       // we need to kick off OAuth token verification process again.
       login_manager->ContinueSessionRestore();
     } else if (should_restore_session) {
-      pending_restore_sessions_.erase((*it)->email());
+      pending_signin_restore_sessions_.erase((*it)->email());
       RestoreAuthSessionImpl(user_profile, false /* has_auth_cookies */);
     }
   }
 }
 
+void UserSessionManager::OnProfilePrepared(Profile* profile) {
+  LoginUtils::Get()->DoBrowserLaunch(profile, NULL);  // host_, not needed here
+
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(::switches::kTestName)) {
+    // Did not log in (we crashed or are debugging), need to restore Sync.
+    // TODO(nkostylev): Make sure that OAuth state is restored correctly for all
+    // users once it is fully multi-profile aware. http://crbug.com/238987
+    // For now if we have other user pending sessions they'll override OAuth
+    // session restore for previous users.
+    UserSessionManager::GetInstance()->RestoreAuthenticationSession(profile);
+  }
+
+  // Restore other user sessions if any.
+  RestorePendingUserSessions();
+}
+
 void UserSessionManager::CreateUserSession(const UserContext& user_context,
                                        bool has_auth_cookies) {
   user_context_ = user_context;
   has_auth_cookies_ = has_auth_cookies;
   InitSessionRestoreStrategy();
 }
 
 void UserSessionManager::PreStartSession() {
   // Switch log file as soon as possible.
   if (base::SysInfo::IsRunningOnChromeOS())
@@ skipping 279 matching lines @@
   if (user_manager->IsUserLoggedIn() &&
       primary_user &&
       profile == ProfileHelper::Get()->GetProfileByUser(primary_user) &&
       CertLoader::IsInitialized() &&
       base::SysInfo::IsRunningOnChromeOS()) {
     GetNSSCertDatabaseForProfile(profile,
                                  base::Bind(&OnGetNSSCertDatabaseForUser));
   }
 }
 
+void UserSessionManager::OnRestoreActiveSessions(
+    const SessionManagerClient::ActiveSessionsMap& sessions,
+    bool success) {
+  if (!success) {
+    LOG(ERROR) << "Could not get list of active user sessions after crash.";
+    // If we could not get list of active user sessions it is safer to just
+    // sign out so that we don't get in the inconsistent state.
+    DBusThreadManager::Get()->GetSessionManagerClient()->StopSession();
+    return;
+  }
+
+  // One profile has been already loaded on browser start.
+  UserManager* user_manager = UserManager::Get();
+  DCHECK(user_manager->GetLoggedInUsers().size() == 1);
+  DCHECK(user_manager->GetActiveUser());
+  std::string active_user_id = user_manager->GetActiveUser()->email();
+
+  SessionManagerClient::ActiveSessionsMap::const_iterator it;
+  for (it = sessions.begin(); it != sessions.end(); ++it) {
+    if (active_user_id == it->first)
+      continue;
+    pending_user_sessions_[it->first] = it->second;
+  }
+  RestorePendingUserSessions();
+}
+
+void UserSessionManager::RestorePendingUserSessions() {
+  if (pending_user_sessions_.empty()) {
+    NotifyPendingUserSessionsRestoreFinished();
+    return;
+  }
+
+  // Get next user to restore sessions and delete it from list.
+  SessionManagerClient::ActiveSessionsMap::const_iterator it =
+      pending_user_sessions_.begin();
+  std::string user_id = it->first;
+  std::string user_id_hash = it->second;
+  DCHECK(!user_id.empty());
+  DCHECK(!user_id_hash.empty());
+  pending_user_sessions_.erase(user_id);
+
+  // Check that this user is not logged in yet.
+  UserList logged_in_users = UserManager::Get()->GetLoggedInUsers();
+  bool user_already_logged_in = false;
+  for (UserList::const_iterator it = logged_in_users.begin();
+       it != logged_in_users.end();
+       ++it) {
+    const User* user = (*it);
+    if (user->email() == user_id) {
+      user_already_logged_in = true;
+      break;
+    }
+  }
+  DCHECK(!user_already_logged_in);
+
+  if (!user_already_logged_in) {
+    UserContext user_context(user_id);
+    user_context.SetUserIDHash(user_id_hash);
+    user_context.SetIsUsingOAuth(false);
+
+    // Will call OnProfilePrepared() once profile has been loaded.
+    StartSession(user_context,
+                 NULL,   // authenticator
+                 false,  // has_auth_cookies
+                 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,
+                    session_state_observer_list_,
+                    PendingUserSessionsRestoreFinished());
+}
+
 }  // namespace chromeos