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));
+    User* user = FindUserInListAndModify(email);
     if (user && user->GetType() == User::USER_TYPE_PUBLIC_ACCOUNT) {
       PublicAccountUserLoggedIn(user);
     } else if ((user &&
                 user->GetType() == User::USER_TYPE_LOCALLY_MANAGED) ||
                (!user &&
                 gaia::ExtractDomainName(email) ==
                     UserManager::kLocallyManagedUserDomain)) {
       LocallyManagedUserLoggedIn(email);
     } else if (browser_restart && email == g_browser_process->local_state()->
                    GetString(kPublicAccountPendingDataRemoval)) {
       PublicAccountUserLoggedIn(User::CreatePublicAccountUser(email));
     } else if (email != owner_email_ && !user &&
                (AreEphemeralUsersEnabled() || browser_restart)) {
       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_);
 
   NotifyOnLogin();
 }
 
+void UserManagerImpl::SwitchActiveUser(const std::string& email) {
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(::switches::kMultiProfiles))
+    return;
+
+  User* user = FindUserAndModify(email);
+  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.
+  // http://crbug.com/230857
+  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);
+  // http://crosbug.com/230859
+  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;
+  }
 
   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));
+  User* user = FindUserAndModify(username);
   if (user)
     user->set_oauth_token_status(oauth_token_status);
 
   GetUserFlow(username)->HandleOAuthTokenStatusChange(oauth_token_status);
 
   // Do not update local store if data stored or cached outside the user's
   // cryptohome is to be treated as ephemeral.
   if (IsUserNonCryptohomeDataEphemeral(username))
     return;
 
@@ skipping 21 matching lines @@
       GetUserFlow(username)->HandleOAuthTokenStatusChange(result);
     return result;
   }
   return User::OAUTH_TOKEN_STATUS_UNKNOWN;
 }
 
 void UserManagerImpl::SaveUserDisplayName(const std::string& username,
                                           const string16& display_name) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  User* user = const_cast<User*>(FindUser(username));
+  User* user = FindUserAndModify(username);
   if (!user)
     return;  // Ignore if there is no such user.
 
   user->set_display_name(display_name);
 
   // Do not update local store if data stored or cached outside the user's
   // cryptohome is to be treated as ephemeral.
   if (IsUserNonCryptohomeDataEphemeral(username))
     return;
 
   PrefService* local_state = g_browser_process->local_state();
 
   DictionaryPrefUpdate display_name_update(local_state, kUserDisplayName);
   display_name_update->SetWithoutPathExpansion(
       username,
       new base::StringValue(display_name));
 }
 
 string16 UserManagerImpl::GetUserDisplayName(
     const std::string& username) const {
   const User* user = FindUser(username);
   return user ? user->display_name() : string16();
 }
 
 void UserManagerImpl::SaveUserDisplayEmail(const std::string& username,
                                            const std::string& display_email) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  User* user = const_cast<User*>(FindUser(username));
+  User* user = FindUserAndModify(username);
   if (!user)
     return;  // Ignore if there is no such user.
 
   user->set_display_email(display_email);
 
   // Do not update local store if data stored or cached outside the user's
   // cryptohome is to be treated as ephemeral.
   if (IsUserNonCryptohomeDataEphemeral(username))
     return;
 
@@ skipping 56 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.";
+    // http://crbug.com/230860
+    // 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 180 matching lines @@
   cros_settings_->AddSettingsObserver(kAccountsPrefDeviceLocalAccounts,
                                       this);
 }
 
 bool UserManagerImpl::AreEphemeralUsersEnabled() const {
   return ephemeral_users_enabled_ &&
       (g_browser_process->browser_policy_connector()->IsEnterpriseManaged() ||
       !owner_email_.empty());
 }
 
+UserList& UserManagerImpl::GetUsersAndModify() {
+  EnsureUsersLoaded();
+  return users_;
+}
+
+User* UserManagerImpl::FindUserAndModify(const std::string& email) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (active_user_ && active_user_->email() == email)
+    return active_user_;
+  return FindUserInListAndModify(email);
+}
+
 const User* UserManagerImpl::FindUserInList(const std::string& email) const {
   const UserList& users = GetUsers();
   for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
     if ((*it)->email() == email)
       return *it;
   }
   return NULL;
 }
 
+User* UserManagerImpl::FindUserInListAndModify(const std::string& email) {
+  UserList& users = GetUsersAndModify();
+  for (UserList::iterator it = users.begin(); it != users.end(); ++it) {
+    if ((*it)->email() == email)
+      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