Chrome OS multi-profiles backend and UI.

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 <vector>
 
@@ skipping 172 matching lines @@
   registry->RegisterDictionaryPref(kUserOAuthTokenStatus);
   registry->RegisterDictionaryPref(kUserDisplayName);
   registry->RegisterDictionaryPref(kUserDisplayEmail);
   SessionLengthLimiter::RegisterPrefs(registry);
 }
 
 UserManagerImpl::UserManagerImpl()
     : cros_settings_(CrosSettings::Get()),
       device_local_account_policy_service_(NULL),
       users_loaded_(false),
-      logged_in_user_(NULL),
+      active_user_(NULL),
       session_started_(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,
       content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_ADDED,
       content::NotificationService::AllSources());
   RetrieveTrustedDevicePolicies();
 }
 
 UserManagerImpl::~UserManagerImpl() {
   // Can't use STLDeleteElements because of the private destructor of User.
   for (UserList::iterator it = users_.begin(); it != users_.end();
        it = users_.erase(it)) {
-    if (logged_in_user_ == *it)
-      logged_in_user_ = NULL;
+    if (active_user_ == *it)
+      active_user_ = NULL;
     delete *it;
   }
-  delete logged_in_user_;
+  // These are pointers to the same User instances that were in users_ list.
+  logged_in_users_.clear();
+  delete active_user_;
 }
 
 void UserManagerImpl::Shutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   cros_settings_->RemoveSettingsObserver(kAccountsPrefDeviceLocalAccounts,
                                          this);
   // Stop the session length limiter.
   session_length_limiter_.reset();
 
   if (device_local_account_policy_service_)
     device_local_account_policy_service_->RemoveObserver(this);
 }
 
 UserImageManager* UserManagerImpl::GetUserImageManager() {
   return user_image_manager_.get();
 }
 
 const UserList& UserManagerImpl::GetUsers() const {
   const_cast<UserManagerImpl*>(this)->EnsureUsersLoaded();
   return users_;
 }
 
+const UserList& UserManagerImpl::GetLoggedInUsers() const {
+  return logged_in_users_;
+}
+
 void UserManagerImpl::UserLoggedIn(const std::string& email,
                                    const std::string& username_hash,
                                    bool browser_restart) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!CommandLine::ForCurrentProcess()->HasSwitch(::switches::kMultiProfiles))
     DCHECK(!IsUserLoggedIn());
 
+  if (active_user_)
+    active_user_->set_is_active(false);
+
   if (email == kGuestUserEMail) {
     GuestUserLoggedIn();
   } else if (email == kRetailModeUserEMail) {
     RetailModeUserLoggedIn();
   } else if (gaia::ExtractDomainName(email) == kKioskAppUserDomain) {
     KioskAppLoggedIn(email);
   } else {
     EnsureUsersLoaded();
 
     User* user = const_cast<User*>(FindUserInList(email));
@@ skipping 13 matching lines @@
       RegularUserLoggedInAsEphemeral(email);
     } else {
       RegularUserLoggedIn(email, browser_restart);
     }
 
     // Initialize the session length limiter and start it only if
     // session limit is defined by the policy.
     session_length_limiter_.reset(new SessionLengthLimiter(NULL,
                                                            browser_restart));
   }
-  DCHECK(logged_in_user_);
-  logged_in_user_->set_username_hash(username_hash);
+  DCHECK(active_user_);
+  active_user_->set_is_logged_in(true);
+  active_user_->set_is_active(true);
+  active_user_->set_username_hash(username_hash);
+
+  // Place user who just signed in to the top of the logged in users.
+  logged_in_users_.insert(logged_in_users_.begin(), active_user_);

[Dmitry Polukhin, 2013/04/11 13:34:15]

Does order of user matter?

[Nikita (slow), 2013/04/12 15:41:25]

Discussed, for now using same ordering logic as for logged in users. We'll
figure out this one later when switch UI will be implemented. Maybe it will make
sense to reorder list of logged in users on switch too.

 
   NotifyOnLogin();
 }
 
+void UserManagerImpl::SwitchActiveUser(const std::string& email) {
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(::switches::kMultiProfiles))
+    return;
+
+  User* user = const_cast<User*>(FindUser(email));

[Dmitry Polukhin, 2013/04/11 13:34:15]

I would add another function that returns non-const User* instead of adding
const_cast here. Also it will make clear that we would like to modify user.

[Nikita (slow), 2013/04/12 15:41:25]

Done.

+  if (!user) {
+    NOTREACHED() << "Switching to a non-existing user";
+    return;
+  }
+  if (user == active_user_) {
+    NOTREACHED() << "Switching to a user who is already active";
+    return;
+  }
+  if (!user->is_logged_in()) {
+    NOTREACHED() << "Switching to a user that is not logged in";
+    return;
+  }
+  if (user->GetType() != User::USER_TYPE_REGULAR) {
+    NOTREACHED() << "Switching to a non-regular user";
+    return;
+  }
+  if (user->username_hash().empty()) {
+    NOTREACHED() << "Switching to a user that doesn't have username_hash set";
+    return;
+  }
+
+  DCHECK(active_user_);
+  active_user_->set_is_active(false);
+  user->set_is_active(true);
+  active_user_ = user;
+
+  // TODO(nkostylev): Notify session_manager on active user change.
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_ACTIVE_USER_CHANGED,
+      content::Source<UserManager>(this),
+      content::Details<const User>(active_user_));
+}
+
 void UserManagerImpl::RetailModeUserLoggedIn() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   is_current_user_new_ = true;
-  logged_in_user_ = User::CreateRetailModeUser();
+  active_user_ = User::CreateRetailModeUser();
   user_image_manager_->UserLoggedIn(kRetailModeUserEMail,
                                     is_current_user_new_,
                                     true);
   WallpaperManager::Get()->SetInitialUserWallpaper(kRetailModeUserEMail, false);
 }
 
 void UserManagerImpl::GuestUserLoggedIn() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   WallpaperManager::Get()->SetInitialUserWallpaper(kGuestUserEMail, false);
-  logged_in_user_ = User::CreateGuestUser();
+  active_user_ = User::CreateGuestUser();
   // TODO(nkostylev): Add support for passing guest session cryptohome
   // mount point. Legacy (--login-profile) value will be used for now.
-  logged_in_user_->SetStubImage(User::kInvalidImageIndex, false);
+  active_user_->SetStubImage(User::kInvalidImageIndex, false);
 }
 
 void UserManagerImpl::KioskAppLoggedIn(const std::string& username) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(gaia::ExtractDomainName(username), kKioskAppUserDomain);
 
   WallpaperManager::Get()->SetInitialUserWallpaper(username, false);
-  logged_in_user_ = User::CreateKioskAppUser(username);
-  logged_in_user_->SetStubImage(User::kInvalidImageIndex, false);
+  active_user_ = User::CreateKioskAppUser(username);
+  active_user_->SetStubImage(User::kInvalidImageIndex, false);
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   command_line->AppendSwitch(::switches::kForceAppMode);
   command_line->AppendSwitchASCII(::switches::kAppId,
-                                  logged_in_user_->GetAccountName(false));
+                                  active_user_->GetAccountName(false));
 }
 
 void UserManagerImpl::LocallyManagedUserLoggedIn(
     const std::string& username) {
   // TODO(nkostylev): Refactor, share code with RegularUserLoggedIn().
 
   // Remove the user from the user list.
-  logged_in_user_ = RemoveRegularOrLocallyManagedUserFromList(username);
+  active_user_ = RemoveRegularOrLocallyManagedUserFromList(username);
   // If the user was not found on the user list, create a new user.
-  if (!logged_in_user_) {
+  if (!active_user_) {
     is_current_user_new_ = true;
-    logged_in_user_ = User::CreateLocallyManagedUser(username);
+    active_user_ = User::CreateLocallyManagedUser(username);
     // Leaving OAuth token status at the default state = unknown.
     WallpaperManager::Get()->SetInitialUserWallpaper(username, true);
   } else {
     ListPrefUpdate prefs_new_users_update(g_browser_process->local_state(),
                                           kLocallyManagedUsersFirstRun);
     if (prefs_new_users_update->Remove(base::StringValue(username), NULL)) {
       is_current_user_new_ = true;
       WallpaperManager::Get()->SetInitialUserWallpaper(username, true);
     }
   }
 
   // Add the user to the front of the user list.
   ListPrefUpdate prefs_users_update(g_browser_process->local_state(),
                                     kRegularUsers);
   prefs_users_update->Insert(0, new base::StringValue(username));
-  users_.insert(users_.begin(), logged_in_user_);
+  users_.insert(users_.begin(), active_user_);
 
   // Now that user is in the list, save display name.
   if (is_current_user_new_) {
-    SaveUserDisplayName(logged_in_user_->email(),
-                        logged_in_user_->GetDisplayName());
+    SaveUserDisplayName(active_user_->email(),
+                        active_user_->GetDisplayName());
   }
 
   user_image_manager_->UserLoggedIn(username, is_current_user_new_, true);
   WallpaperManager::Get()->EnsureLoggedInUserWallpaperLoaded();
 
   // Make sure that new data is persisted to Local State.
   g_browser_process->local_state()->CommitPendingWrite();
 }
 
 void UserManagerImpl::PublicAccountUserLoggedIn(User* user) {
   is_current_user_new_ = true;
-  logged_in_user_ = user;
+  active_user_ = user;
   // The UserImageManager chooses a random avatar picture when a user logs in
   // for the first time. Tell the UserImageManager that this user is not new to
   // prevent the avatar from getting changed.
   user_image_manager_->UserLoggedIn(user->email(), false, true);
   WallpaperManager::Get()->EnsureLoggedInUserWallpaperLoaded();
 }
 
 void UserManagerImpl::RegularUserLoggedIn(const std::string& email,
                                           bool browser_restart) {
   // Remove the user from the user list.
-  logged_in_user_ = RemoveRegularOrLocallyManagedUserFromList(email);
+  active_user_ = RemoveRegularOrLocallyManagedUserFromList(email);
 
   // If the user was not found on the user list, create a new user.
-  if (!logged_in_user_) {
+  if (!active_user_) {
     is_current_user_new_ = true;
-    logged_in_user_ = User::CreateRegularUser(email);
-    logged_in_user_->set_oauth_token_status(LoadUserOAuthStatus(email));
-    SaveUserDisplayName(logged_in_user_->email(),
-                        UTF8ToUTF16(logged_in_user_->GetAccountName(true)));
+    active_user_ = User::CreateRegularUser(email);
+    active_user_->set_oauth_token_status(LoadUserOAuthStatus(email));
+    SaveUserDisplayName(active_user_->email(),
+                        UTF8ToUTF16(active_user_->GetAccountName(true)));
     WallpaperManager::Get()->SetInitialUserWallpaper(email, true);
   }
 
   // Add the user to the front of the user list.
   ListPrefUpdate prefs_users_update(g_browser_process->local_state(),
                                     kRegularUsers);
   prefs_users_update->Insert(0, new base::StringValue(email));
-  users_.insert(users_.begin(), logged_in_user_);
+  users_.insert(users_.begin(), active_user_);
 
   user_image_manager_->UserLoggedIn(email, is_current_user_new_, false);
 
   if (!browser_restart) {
     // For GAIA login flow, logged in user wallpaper may not be loaded.
     WallpaperManager::Get()->EnsureLoggedInUserWallpaperLoaded();
   }
 
   // Make sure that new data is persisted to Local State.
   g_browser_process->local_state()->CommitPendingWrite();
 }
 
 void UserManagerImpl::RegularUserLoggedInAsEphemeral(const std::string& email) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   is_current_user_new_ = true;
   is_current_user_ephemeral_regular_user_ = true;
-  logged_in_user_ = User::CreateRegularUser(email);
+  active_user_ = User::CreateRegularUser(email);
   user_image_manager_->UserLoggedIn(email, is_current_user_new_, false);
   WallpaperManager::Get()->SetInitialUserWallpaper(email, false);
 }
 
 void UserManagerImpl::SessionStarted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   session_started_ = true;
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_SESSION_STARTED,
-      content::NotificationService::AllSources(),
-      content::NotificationService::NoDetails());
+      content::Source<UserManager>(this),
+      content::Details<const User>(active_user_));
   if (is_current_user_new_) {
     // Make sure that the new user's data is persisted to Local State.
     g_browser_process->local_state()->CommitPendingWrite();
   }
 }
 
 std::string UserManagerImpl::GenerateUniqueLocallyManagedUserId() {
   int counter = g_browser_process->local_state()->
       GetInteger(kLocallyManagedUsersNextId);
   std::string id;
@@ skipping 47 matching lines @@
     return;
 
   // Sanity check: we must not remove single user. This check may seem
   // redundant at a first sight because this single user must be an owner and
   // we perform special check later in order not to remove an owner.  However
   // due to non-instant nature of ownership assignment this later check may
   // sometimes fail. See http://crosbug.com/12723
   if (users_.size() < 2)
     return;
 
-  // Sanity check: do not allow the logged-in user to remove himself.
-  if (logged_in_user_ && logged_in_user_->email() == email)
-    return;
+  // Sanity check: do not allow any of the the logged in users to be removed.
+  for (UserList::const_iterator it = logged_in_users_.begin();
+       it != logged_in_users_.end(); ++it) {
+    if ((*it)->email() == email)
+      return;

[Dmitry Polukhin, 2013/04/11 13:34:15]

Do you know how it will look from UI point of view?

[Nikita (slow), 2013/04/12 15:41:25]

Yes, nothing will happen.
User will click on [Remove] item in menu and menu will just close.

But this should never happen in UI. [Remove] item is not shown on lock/add user
UI.

+  }
 
   RemoveUserInternal(email, delegate);
 }
 
 void UserManagerImpl::RemoveUserFromList(const std::string& email) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   EnsureUsersLoaded();
   RemoveNonCryptohomeData(email);
   delete RemoveRegularOrLocallyManagedUserFromList(email);
   // Make sure that new data is persisted to Local State.
   g_browser_process->local_state()->CommitPendingWrite();
 }
 
 bool UserManagerImpl::IsKnownUser(const std::string& email) const {
   return FindUser(email) != NULL;
 }
 
 const User* UserManagerImpl::FindUser(const std::string& email) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (logged_in_user_ && logged_in_user_->email() == email)
-    return logged_in_user_;
+  if (active_user_ && active_user_->email() == email)
+    return active_user_;
   return FindUserInList(email);
 }
 
 const User* UserManagerImpl::FindLocallyManagedUser(
     const string16& display_name) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   const UserList& users = GetUsers();
   for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
     if (((*it)->GetType() == User::USER_TYPE_LOCALLY_MANAGED) &&
         ((*it)->display_name() == display_name)) {
       return *it;
     }
   }
   return NULL;
 }
 
 const User* UserManagerImpl::GetLoggedInUser() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return logged_in_user_;
+  return active_user_;
 }
 
 User* UserManagerImpl::GetLoggedInUser() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return logged_in_user_;
+  return active_user_;
+}
+
+const User* UserManagerImpl::GetActiveUser() const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  return active_user_;
+}
+
+User* UserManagerImpl::GetActiveUser() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  return active_user_;
 }
 
 void UserManagerImpl::SaveUserOAuthStatus(
     const std::string& username,
     User::OAuthTokenStatus oauth_token_status) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DVLOG(1) << "Saving user OAuth token status in Local State";
   User* user = const_cast<User*>(FindUser(username));
   if (user)
@@ skipping 136 matching lines @@
       observed_sync_service_->GetAuthError().state();
   if (state != GoogleServiceAuthError::NONE &&
       state != GoogleServiceAuthError::CONNECTION_FAILED &&
       state != GoogleServiceAuthError::SERVICE_UNAVAILABLE &&
       state != GoogleServiceAuthError::REQUEST_CANCELED) {
     // Invalidate OAuth token to force Gaia sign-in flow. This is needed
     // because sign-out/sign-in solution is suggested to the user.
     // TODO(altimofeev): this code isn't needed after crosbug.com/25978 is
     // implemented.
     DVLOG(1) << "Invalidate OAuth token because of a sync error.";
+    // TODO(nkostylev): Figure out whether we want to have observers
+    // for each logged in user.
+    // TODO(nkostyelv): Change observer after active user has changed.
     SaveUserOAuthStatus(
-        logged_in_user_->email(),
+        active_user_->email(),
         User::OAUTH2_TOKEN_STATUS_INVALID);
   }
 }
 
 void UserManagerImpl::OnPolicyUpdated(const std::string& account_id) {
   UpdatePublicAccountDisplayName(account_id);
   NotifyUserListChanged();
 }
 
 void UserManagerImpl::OnDeviceLocalAccountsChanged() {
@@ skipping 19 matching lines @@
 }
 
 bool UserManagerImpl::IsCurrentUserNonCryptohomeDataEphemeral() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return IsUserLoggedIn() &&
          IsUserNonCryptohomeDataEphemeral(GetLoggedInUser()->email());
 }
 
 bool UserManagerImpl::CanCurrentUserLock() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return IsUserLoggedIn() && logged_in_user_->can_lock();
+  return IsUserLoggedIn() && active_user_->can_lock();
 }
 
 bool UserManagerImpl::IsUserLoggedIn() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return logged_in_user_;
+  return active_user_;
 }
 
 bool UserManagerImpl::IsLoggedInAsRegularUser() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return IsUserLoggedIn() &&
-         logged_in_user_->GetType() == User::USER_TYPE_REGULAR;
+         active_user_->GetType() == User::USER_TYPE_REGULAR;
 }
 
 bool UserManagerImpl::IsLoggedInAsDemoUser() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return IsUserLoggedIn() &&
-         logged_in_user_->GetType() == User::USER_TYPE_RETAIL_MODE;
+         active_user_->GetType() == User::USER_TYPE_RETAIL_MODE;
 }
 
 bool UserManagerImpl::IsLoggedInAsPublicAccount() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return IsUserLoggedIn() &&
-      logged_in_user_->GetType() == User::USER_TYPE_PUBLIC_ACCOUNT;
+      active_user_->GetType() == User::USER_TYPE_PUBLIC_ACCOUNT;
 }
 
 bool UserManagerImpl::IsLoggedInAsGuest() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return IsUserLoggedIn() &&
-         logged_in_user_->GetType() == User::USER_TYPE_GUEST;
+         active_user_->GetType() == User::USER_TYPE_GUEST;
 }
 
 bool UserManagerImpl::IsLoggedInAsLocallyManagedUser() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return IsUserLoggedIn() &&
-      logged_in_user_->GetType() == User::USER_TYPE_LOCALLY_MANAGED;
+      active_user_->GetType() == User::USER_TYPE_LOCALLY_MANAGED;
 }
 
 bool UserManagerImpl::IsLoggedInAsKioskApp() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return IsUserLoggedIn() &&
-      logged_in_user_->GetType() == User::USER_TYPE_KIOSK_APP;
+      active_user_->GetType() == User::USER_TYPE_KIOSK_APP;
 }
 
 bool UserManagerImpl::IsLoggedInAsStub() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return IsUserLoggedIn() && logged_in_user_->email() == kStubUser;
+  return IsUserLoggedIn() && active_user_->email() == kStubUser;
 }
 
 bool UserManagerImpl::IsSessionStarted() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return session_started_;
 }
 
 UserManager::MergeSessionState UserManagerImpl::GetMergeSessionState() const {
   return merge_session_state_;
 }
@@ skipping 194 matching lines @@
       return *it;
   }
   return NULL;
 }
 
 void UserManagerImpl::NotifyOnLogin() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_USER_CHANGED,
       content::Source<UserManager>(this),
-      content::Details<const User>(logged_in_user_));
+      content::Details<const User>(active_user_));
 
   CrosLibrary::Get()->GetCertLibrary()->LoadKeyStore();
 
   // Indicate to DeviceSettingsService that the owner key may have become
   // available.
-  DeviceSettingsService::Get()->SetUsername(logged_in_user_->email());
+  DeviceSettingsService::Get()->SetUsername(active_user_->email());
 }
 
 void UserManagerImpl::UpdateOwnership(
     DeviceSettingsService::OwnershipStatus status,
     bool is_owner) {
   VLOG(1) << "Current user " << (is_owner ? "is owner" : "is not owner");
 
   SetCurrentUserIsOwner(is_owner);
 }
 
@@ skipping 43 matching lines @@
     }
   }
   return user;
 }
 
 bool UserManagerImpl::UpdateAndCleanUpPublicAccounts(
     const base::ListValue& public_accounts) {
   PrefService* local_state = g_browser_process->local_state();
 
   // Determine the currently logged-in user's email.
-  std::string logged_in_user_email;
+  std::string active_user_email;
   if (IsUserLoggedIn())
-    logged_in_user_email = GetLoggedInUser()->email();
+    active_user_email = GetLoggedInUser()->email();
 
   // If there is a public account whose data is pending removal and the user is
   // not currently logged in with that account, take this opportunity to remove
   // the data.
   std::string public_account_pending_data_removal =
       local_state->GetString(kPublicAccountPendingDataRemoval);
   if (!public_account_pending_data_removal.empty() &&
-      public_account_pending_data_removal != logged_in_user_email) {
+      public_account_pending_data_removal != active_user_email) {
     RemoveNonCryptohomeData(public_account_pending_data_removal);
     local_state->ClearPref(kPublicAccountPendingDataRemoval);
   }
 
   // Split the current user list public accounts and regular users.
   std::vector<std::string> old_public_accounts;
   std::set<std::string> regular_users;
   for (UserList::const_iterator it = users_.begin(); it != users_.end(); ++it) {
     if ((*it)->GetType() == User::USER_TYPE_PUBLIC_ACCOUNT)
       old_public_accounts.push_back((*it)->email());
     else
       regular_users.insert((*it)->email());
   }
 
   // Get the new list of public accounts from policy.
   std::vector<std::string> new_public_accounts;
   std::set<std::string> new_public_accounts_set;
-  if (!ParseUserList(public_accounts, regular_users, logged_in_user_email,
+  if (!ParseUserList(public_accounts, regular_users, active_user_email,
                      &new_public_accounts, &new_public_accounts_set) &&
       IsLoggedInAsPublicAccount()) {
     // If the user is currently logged into a public account that has been
     // removed from the list, mark the account's data as pending removal after
     // logout.
     local_state->SetString(kPublicAccountPendingDataRemoval,
-                           logged_in_user_email);
+                           active_user_email);
   }
 
   // Persist the new list of public accounts in a pref.
   ListPrefUpdate prefs_public_accounts_update(local_state, kPublicAccounts);
   scoped_ptr<base::ListValue> prefs_public_accounts(public_accounts.DeepCopy());
   prefs_public_accounts_update->Swap(prefs_public_accounts.get());
 
   // If the list of public accounts has not changed, return.
   if (new_public_accounts.size() == old_public_accounts.size()) {
     bool changed = false;
@@ skipping 15 matching lines @@
       it = users_.erase(it);
     } else {
       ++it;
     }
   }
 
   // Add the new public accounts to the front of the user list.
   for (std::vector<std::string>::const_reverse_iterator
            it = new_public_accounts.rbegin();
        it != new_public_accounts.rend(); ++it) {
-    if (IsLoggedInAsPublicAccount() && *it == logged_in_user_email)
+    if (IsLoggedInAsPublicAccount() && *it == active_user_email)
       users_.insert(users_.begin(), GetLoggedInUser());
     else
       users_.insert(users_.begin(), User::CreatePublicAccountUser(*it));
     UpdatePublicAccountDisplayName(*it);
   }
 
   user_image_manager_->LoadUserImages(
       UserList(users_.begin(), users_.begin() + new_public_accounts.size()));
 
   return true;
@@ skipping 149 matching lines @@
       content::NotificationService::NoDetails());
 }
 
 void UserManagerImpl::NotifyMergeSessionStateChanged() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FOR_EACH_OBSERVER(UserManager::Observer, observer_list_,
                     MergeSessionStateChanged(merge_session_state_));
 }
 
 }  // namespace chromeos