Restore last used user session after crash

components/user_manager/user_manager_base.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 "components/user_manager/user_manager_base.h"
 
 #include <cstddef>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 44 matching lines @@
 
 // A dictionary that maps user IDs to a flag indicating whether online
 // authentication against GAIA should be enforced during the next sign-in.
 const char kUserForceOnlineSignin[] = "UserForceOnlineSignin";
 
 // A string pref containing the ID of the last user who logged in if it was
 // a regular user or an empty string if it was another type of user (guest,
 // kiosk, public account, etc.).
 const char kLastLoggedInRegularUser[] = "LastLoggedInRegularUser";
 
+// A string pref containing the ID of the last active user.
+// In case of browser crash, this pref will be used to set active user after
+// session restore.
+const char kLastActiveUser[] = "LastActiveUser";
+
 // Upper bound for a histogram metric reporting the amount of time between
 // one regular user logging out and a different regular user logging in.
 const int kLogoutToLoginDelayMaxSec = 1800;
 
 // Callback that is called after user removal is complete.
 void OnRemoveUserComplete(const std::string& user_email,
                           bool success,
                           cryptohome::MountError return_code) {
   // Log the error, but there's not much we can do.
   if (!success) {
@@ skipping 12 matching lines @@
 
 // static
 void UserManagerBase::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterListPref(kRegularUsers);
   registry->RegisterStringPref(kLastLoggedInRegularUser, std::string());
   registry->RegisterDictionaryPref(kUserDisplayName);
   registry->RegisterDictionaryPref(kUserGivenName);
   registry->RegisterDictionaryPref(kUserDisplayEmail);
   registry->RegisterDictionaryPref(kUserOAuthTokenStatus);
   registry->RegisterDictionaryPref(kUserForceOnlineSignin);
+  registry->RegisterStringPref(kLastActiveUser, std::string());

[Dmitry Polukhin, 2014/09/24 11:16:17]

Could you please clear this field if the user is removed from system.

[Nikita (slow), 2014/09/25 19:51:49]

Done.

 }
 
 UserManagerBase::UserManagerBase(
     scoped_refptr<base::TaskRunner> task_runner,
     scoped_refptr<base::TaskRunner> blocking_task_runner)
     : active_user_(NULL),
       primary_user_(NULL),
       user_loading_stage_(STAGE_NOT_LOADED),
       session_started_(false),
       is_current_user_owner_(false),
       is_current_user_new_(false),
       is_current_user_ephemeral_regular_user_(false),
       ephemeral_users_enabled_(false),
       manager_creation_time_(base::TimeTicks::Now()),
+      last_session_active_user_initialized_(false),
       task_runner_(task_runner),
       blocking_task_runner_(blocking_task_runner),
       weak_factory_(this) {
   UpdateLoginState();
 }
 
 UserManagerBase::~UserManagerBase() {
   // Can't use STLDeleteElements because of the private destructor of User.
   for (UserList::iterator it = users_.begin(); it != users_.end();
        it = users_.erase(it)) {
@@ skipping 25 matching lines @@
 
 const std::string& UserManagerBase::GetOwnerEmail() const {
   return owner_email_;
 }
 
 void UserManagerBase::UserLoggedIn(const std::string& user_id,
                                    const std::string& username_hash,
                                    bool browser_restart) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
+  if (!last_session_active_user_initialized_) {
+    last_session_active_user_ = GetLocalState()->GetString(kLastActiveUser);
+    last_session_active_user_initialized_ = true;
+  }
+
   User* user = FindUserInListAndModify(user_id);
   if (active_user_ && user) {
     user->set_is_logged_in(true);
     user->set_username_hash(username_hash);
     logged_in_users_.push_back(user);
     lru_logged_in_users_.push_back(user);
 
     // Reset the new user flag if the user already exists.
     SetIsCurrentUserNew(false);
     NotifyUserAddedToSession(user, true /* user switch pending */);
@@ skipping 83 matching lines @@
   user->set_is_active(true);
   active_user_ = user;
 
   // Move the user to the front.
   SetLRUUser(active_user_);
 
   NotifyActiveUserHashChanged(active_user_->username_hash());
   NotifyActiveUserChanged(active_user_);
 }
 
+void UserManagerBase::SwitchToLastActiveUser() {
+  if (last_session_active_user_.empty())
+    return;
+
+  if (GetActiveUser()->email() != last_session_active_user_)
+    SwitchActiveUser(last_session_active_user_);
+
+  // Make sure that this function gets run only once.
+  last_session_active_user_.clear();
+}
+
 void UserManagerBase::SessionStarted() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   session_started_ = true;
 
   UpdateLoginState();
   session_manager::SessionManager::Get()->SetSessionState(
       session_manager::SESSION_STATE_ACTIVE);
 
   if (IsCurrentUserNew()) {
     // Make sure that the new user's data is persisted to Local State.
@@ skipping 687 matching lines @@
   if (primary_user_) {
     chromeos::LoginState::Get()->SetLoggedInStateAndPrimaryUser(
         logged_in_state, login_user_type, primary_user_->username_hash());
   } else {
     chromeos::LoginState::Get()->SetLoggedInState(logged_in_state,
                                                   login_user_type);
   }
 }
 
 void UserManagerBase::SetLRUUser(User* user) {
+  GetLocalState()->SetString(kLastActiveUser, user->email());
+  GetLocalState()->CommitPendingWrite();
+
   UserList::iterator it =
       std::find(lru_logged_in_users_.begin(), 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 UserManagerBase::SendRegularUserLoginMetrics(const std::string& user_id) {
   // If this isn't the first time Chrome was run after the system booted,
   // assume that Chrome was restarted because a previous session ended.
@@ skipping 44 matching lines @@
 }
 
 void UserManagerBase::DeleteUser(User* user) {
   const bool is_active_user = (user == active_user_);
   delete user;
   if (is_active_user)
     active_user_ = NULL;
 }
 
 }  // namespace user_manager