[CrOS multi-profiles] Restore user sessions after crash

chrome/browser/chromeos/login/user_manager_impl.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/chromeos/login/user_manager_impl.h"
 
 #include <cstddef>
 #include <set>
 
 #include "ash/shell.h"
@@ skipping 10 matching lines @@
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cert_library.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/login/default_pinned_apps_field_trial.h"
 #include "chrome/browser/chromeos/login/login_display.h"
+#include "chrome/browser/chromeos/login/login_utils.h"
 #include "chrome/browser/chromeos/login/remove_user_delegate.h"
 #include "chrome/browser/chromeos/login/user_image_manager_impl.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/session_length_limiter.h"
 #include "chrome/browser/chromeos/settings/cros_settings_names.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sync/profile_sync_service.h"
@@ skipping 140 matching lines @@
   registry->RegisterDictionaryPref(kUserDisplayEmail);
   SessionLengthLimiter::RegisterPrefs(registry);
 }
 
 UserManagerImpl::UserManagerImpl()
     : cros_settings_(CrosSettings::Get()),
       device_local_account_policy_service_(NULL),
       users_loaded_(false),
       active_user_(NULL),
       session_started_(false),
+      user_sessions_restored_(false),
       is_current_user_owner_(false),
       is_current_user_new_(false),
       is_current_user_ephemeral_regular_user_(false),
       ephemeral_users_enabled_(false),
       merge_session_state_(MERGE_STATUS_NOT_STARTED),
       observed_sync_service_(NULL),
       user_image_manager_(new UserImageManagerImpl) {
   // UserManager instance should be used only on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   registrar_.Add(this, chrome::NOTIFICATION_OWNERSHIP_STATUS_CHANGED,
@@ skipping 421 matching lines @@
       CheckOwnership();
       RetrieveTrustedDevicePolicies();
       break;
     case chrome::NOTIFICATION_PROFILE_ADDED:
       if (IsUserLoggedIn() &&
           !IsLoggedInAsGuest() &&
           !IsLoggedInAsLocallyManagedUser() &&
           !IsLoggedInAsKioskApp()) {
         Profile* profile = content::Source<Profile>(source).ptr();
         if (!profile->IsOffTheRecord() &&
-            // TODO(nkostylev): We should observe all logged in user's profiles.
             profile == ProfileManager::GetDefaultProfile()) {
-          DCHECK(NULL == observed_sync_service_);
+          // TODO(nkostylev): We should observe all logged in user's profiles.
+          // http://crbug.com/230860
+          if (!CommandLine::ForCurrentProcess()->
+                  HasSwitch(::switches::kMultiProfiles)) {
+            DCHECK(NULL == observed_sync_service_);
+          }
           observed_sync_service_ =
               ProfileSyncServiceFactory::GetForProfile(profile);
           if (observed_sync_service_)
             observed_sync_service_->AddObserver(this);
         }
       }
       break;
     case chrome::NOTIFICATION_SYSTEM_SETTING_CHANGED:
       DCHECK_EQ(*content::Details<const std::string>(details).ptr(),
                 kAccountsPrefDeviceLocalAccounts);
@@ skipping 110 matching lines @@
 bool UserManagerImpl::IsLoggedInAsStub() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return IsUserLoggedIn() && active_user_->email() == kStubUser;
 }
 
 bool UserManagerImpl::IsSessionStarted() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return session_started_;
 }
 
+bool UserManagerImpl::UserSessionsRestored() const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  return user_sessions_restored_;
+}
+
 UserManager::MergeSessionState UserManagerImpl::GetMergeSessionState() const {
   return merge_session_state_;
 }
 
 void UserManagerImpl::SetMergeSessionState(
     UserManager::MergeSessionState state) {
   if (merge_session_state_ == state)
     return;
 
   merge_session_state_ = state;
@@ skipping 64 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   session_state_observer_list_.RemoveObserver(obs);
 }
 
 void UserManagerImpl::NotifyLocalStateChanged() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FOR_EACH_OBSERVER(UserManager::Observer, observer_list_,
                     LocalStateChanged(this));
 }
 
+void UserManagerImpl::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.
+    LoginUtils::Get()->RestoreAuthenticationSession(profile);
+  }
+
+  // Restore other user sessions if any.
+  RestorePendingUserSessions();
+}
+
 void UserManagerImpl::EnsureUsersLoaded() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!g_browser_process || !g_browser_process->local_state())
     return;
 
   if (users_loaded_)
     return;
   users_loaded_ = true;
 
   // Clean up user list first.
@@ skipping 639 matching lines @@
                     MergeSessionStateChanged(merge_session_state_));
 }
 
 void UserManagerImpl::NotifyActiveUserHashChanged(const std::string& hash) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FOR_EACH_OBSERVER(UserManager::UserSessionStateObserver,
                     session_state_observer_list_,
                     ActiveUserHashChanged(hash));
 }
 
+void UserManagerImpl::NotifyPendingUserSessionsRestoreFinished() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  user_sessions_restored_ = true;
+  FOR_EACH_OBSERVER(UserManager::UserSessionStateObserver,
+                    session_state_observer_list_,
+                    PendingUserSessionsRestoreFinished());
+}
+
 void UserManagerImpl::UpdateLoginState() {
   if (!LoginState::IsInitialized())
     return;  // LoginState may not be intialized in tests.
   LoginState::LoggedInState logged_in_state;
   logged_in_state = active_user_ ? LoginState::LOGGED_IN_ACTIVE
       : LoginState::LOGGED_IN_NONE;
 
   LoginState::LoggedInUserType login_user_type;
   if (logged_in_state == LoginState::LOGGED_IN_NONE)
     login_user_type = LoginState::LOGGED_IN_USER_NONE;
@@ skipping 20 matching lines @@
                                     lru_logged_in_users_.end(),
                                     user);
   if (it != lru_logged_in_users_.end())
     lru_logged_in_users_.erase(it);
   lru_logged_in_users_.insert(lru_logged_in_users_.begin(), user);
 }
 
 void UserManagerImpl::OnRestoreActiveSessions(
     const SessionManagerClient::ActiveSessionsMap& sessions,
     bool success) {
-  // TODO(nkostylev): Restore all user sessions (in the background).
-  // This requires first refactoring this flow out of LoginUtils.
-  // 1. UserManager::UserLoggedIn()
-  // 2. InitSessionRestoreStrategy() (OAuth)
-  // 2. ProfileManager::CreateDefaultProfileAsync()
-  // 3. InitProfilePreferences
-  // 4. chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED
+  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.
+  DCHECK(GetLoggedInUsers().size() == 1);
+  DCHECK(GetActiveUser());
+  std::string active_user_id = 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 UserManagerImpl::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 = 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) {
+    // Will call OnProfilePrepared() once profile has been loaded.
+    LoginUtils::Get()->PrepareProfile(UserContext(user_id,
+                                                  std::string(),  // password
+                                                  std::string(),  // auth_code
+                                                  user_id_hash),
+                                      std::string(),  // display_email
+                                      false,          // using_oauth
+                                      false,          // has_cookies
+                                      true,           // has_active_session
+                                      this);
+  } else {
+    RestorePendingUserSessions();
+  }
 }
 
 }  // namespace chromeos