This CL replaces user_manager::UserID with AccountId.

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 98 matching lines @@
   }
 }
 
 // Runs on SequencedWorkerPool thread. Passes resolved locale to UI thread.
 void ResolveLocale(const std::string& raw_locale,
                    std::string* resolved_locale) {
   ignore_result(l10n_util::CheckAndResolveLocale(raw_locale, resolved_locale));
 }
 
 // Checks if values in |dict| correspond with |user_id| identity.
-bool UserMatches(const UserID& user_id, const base::DictionaryValue& dict) {
+bool UserMatches(const AccountId& user_id, const base::DictionaryValue& dict) {
   std::string value;
 
   bool has_email = dict.GetString(kCanonicalEmail, &value);
-  if (has_email && user_id == value)
+  if (has_email && user_id.GetUserEmail() == value)
     return true;
 
   // TODO(antrim): update code once user id is really a struct.
   bool has_gaia_id = dict.GetString(kGAIAIdKey, &value);
-  if (has_gaia_id && user_id == value)
+  if (has_gaia_id && user_id.GetUserEmail() == value)
     return true;
 
   return false;
 }
 
 // Fills relevant |dict| values based on |user_id|.
-void UpdateIdentity(const UserID& user_id, base::DictionaryValue& dict) {
-  dict.SetString(kCanonicalEmail, user_id);
+void UpdateIdentity(const AccountId& user_id, base::DictionaryValue& dict) {
+  dict.SetString(kCanonicalEmail, user_id.GetUserEmail());
 }
 
 }  // namespace
 
 // static
 void UserManagerBase::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterListPref(kRegularUsers);
   registry->RegisterListPref(kKnownUsers);
   registry->RegisterStringPref(kLastLoggedInGaiaUser, std::string());
   registry->RegisterDictionaryPref(kUserDisplayName);
   registry->RegisterDictionaryPref(kUserGivenName);
   registry->RegisterDictionaryPref(kUserDisplayEmail);
   registry->RegisterDictionaryPref(kUserOAuthTokenStatus);
   registry->RegisterDictionaryPref(kUserForceOnlineSignin);
   registry->RegisterDictionaryPref(kUserType);
   registry->RegisterStringPref(kLastActiveUser, std::string());
 }
 
 UserManagerBase::UserManagerBase(
     scoped_refptr<base::TaskRunner> task_runner,
     scoped_refptr<base::TaskRunner> blocking_task_runner)
     : active_user_(NULL),

[achuithb, 2015/10/23 00:08:52]

in class member initialization

[Alexander Alekseev, 2015/10/23 09:11:24]

Done.

       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),
+      owner_id_(EmptyAccountId()),
       manager_creation_time_(base::TimeTicks::Now()),
+      pending_user_switch_(EmptyAccountId()),
+      last_session_active_user_(EmptyAccountId()),
       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();
@@ skipping 17 matching lines @@
 }
 
 const UserList& UserManagerBase::GetLoggedInUsers() const {
   return logged_in_users_;
 }
 
 const UserList& UserManagerBase::GetLRULoggedInUsers() const {
   return lru_logged_in_users_;
 }
 
-const std::string& UserManagerBase::GetOwnerEmail() const {
-  return owner_email_;
+const AccountId& UserManagerBase::GetOwnerId() const {

[achuithb, 2015/10/23 00:08:52]

GetOwnerAccountID?

[Alexander Alekseev, 2015/10/23 09:11:25]

Done.

+  return owner_id_;
 }
 
-void UserManagerBase::UserLoggedIn(const std::string& user_id,
+void UserManagerBase::UserLoggedIn(const AccountId& 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_ =
+        AccountId::FromUserEmail(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 */);
 
     return;
   }
 
-  if (user_id == chromeos::login::kGuestUserName) {
+  if (user_id == chromeos::login::GuestAccountId()) {
     GuestUserLoggedIn();
   } else if (IsKioskApp(user_id)) {
     KioskAppLoggedIn(user_id);
   } else if (IsDemoApp(user_id)) {
     DemoAccountLoggedIn();
   } else {
     EnsureUsersLoaded();
 
     if (user && user->GetType() == USER_TYPE_PUBLIC_ACCOUNT) {
       PublicAccountUserLoggedIn(user);
     } else if ((user && user->GetType() == USER_TYPE_SUPERVISED) ||
                (!user &&
-                gaia::ExtractDomainName(user_id) ==
+                gaia::ExtractDomainName(user_id.GetUserEmail()) ==
                     chromeos::login::kSupervisedUserDomain)) {
       SupervisedUserLoggedIn(user_id);
     } else if (browser_restart && IsPublicAccountMarkedForRemoval(user_id)) {
       PublicAccountUserLoggedIn(User::CreatePublicAccountUser(user_id));
-    } else if (user_id != GetOwnerEmail() && !user &&
+    } else if (user_id != GetOwnerId() && !user &&
                (AreEphemeralUsersEnabled() || browser_restart)) {
       RegularUserLoggedInAsEphemeral(user_id);
     } else {
       RegularUserLoggedIn(user_id);
     }
   }
 
   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_);
   SetLRUUser(active_user_);
 
   if (!primary_user_) {
     primary_user_ = active_user_;
     if (primary_user_->HasGaiaAccount())
       SendGaiaUserLoginMetrics(user_id);
   }
 
   UMA_HISTOGRAM_ENUMERATION(
       "UserManager.LoginUserType", active_user_->GetType(), NUM_USER_TYPES);
 
   GetLocalState()->SetString(
-      kLastLoggedInGaiaUser, active_user_->HasGaiaAccount() ? user_id : "");
+      kLastLoggedInGaiaUser,
+      active_user_->HasGaiaAccount() ? user_id.GetUserEmail() : "");
 
   NotifyOnLogin();
   PerformPostUserLoggedInActions(browser_restart);
 }
 
-void UserManagerBase::SwitchActiveUser(const std::string& user_id) {
+void UserManagerBase::SwitchActiveUser(const AccountId& user_id) {
   User* user = FindUserAndModify(user_id);
   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()) {
@@ skipping 19 matching lines @@
   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_)
+  if (AccountId::FromUserEmail(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.
     GetLocalState()->CommitPendingWrite();
   }
 }
 
-void UserManagerBase::RemoveUser(const std::string& user_id,
+void UserManagerBase::RemoveUser(const AccountId& user_id,
                                  RemoveUserDelegate* delegate) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   if (!CanUserBeRemoved(FindUser(user_id)))
     return;
 
   RemoveUserInternal(user_id, delegate);
 }
 
-void UserManagerBase::RemoveUserInternal(const std::string& user_email,
+void UserManagerBase::RemoveUserInternal(const AccountId& user_id,
                                          RemoveUserDelegate* delegate) {
-  RemoveNonOwnerUserInternal(user_email, delegate);
+  RemoveNonOwnerUserInternal(user_id, delegate);
 }
 
-void UserManagerBase::RemoveNonOwnerUserInternal(const std::string& user_email,
+void UserManagerBase::RemoveNonOwnerUserInternal(const AccountId& user_id,
                                                  RemoveUserDelegate* delegate) {
   if (delegate)
-    delegate->OnBeforeUserRemoved(user_email);
-  RemoveUserFromList(user_email);
+    delegate->OnBeforeUserRemoved(user_id.GetUserEmail());
+  RemoveUserFromList(user_id);
   cryptohome::AsyncMethodCaller::GetInstance()->AsyncRemove(
-      user_email, base::Bind(&OnRemoveUserComplete, user_email));
+      user_id.GetUserEmail(),
+      base::Bind(&OnRemoveUserComplete, user_id.GetUserEmail()));
 
   if (delegate)
-    delegate->OnUserRemoved(user_email);
+    delegate->OnUserRemoved(user_id.GetUserEmail());
 }
 
-void UserManagerBase::RemoveUserFromList(const std::string& user_id) {
+void UserManagerBase::RemoveUserFromList(const AccountId& user_id) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   RemoveNonCryptohomeData(user_id);
   if (user_loading_stage_ == STAGE_LOADED) {
     DeleteUser(RemoveRegularOrSupervisedUserFromList(user_id));
   } else if (user_loading_stage_ == STAGE_LOADING) {
-    DCHECK(gaia::ExtractDomainName(user_id) ==
+    DCHECK(gaia::ExtractDomainName(user_id.GetUserEmail()) ==
                chromeos::login::kSupervisedUserDomain ||
            HasPendingBootstrap(user_id));
     // Special case, removing partially-constructed supervised user or
     // boostrapping user during user list loading.
     ListPrefUpdate users_update(GetLocalState(), kRegularUsers);
-    users_update->Remove(base::StringValue(user_id), NULL);
+    users_update->Remove(base::StringValue(user_id.GetUserEmail()), NULL);
     OnUserRemoved(user_id);
   } else {
     NOTREACHED() << "Users are not loaded yet.";
     return;
   }
 
   // Make sure that new data is persisted to Local State.
   GetLocalState()->CommitPendingWrite();
 }
 
-bool UserManagerBase::IsKnownUser(const std::string& user_id) const {
+bool UserManagerBase::IsKnownUser(const AccountId& user_id) const {
   return FindUser(user_id) != NULL;
 }
 
-const User* UserManagerBase::FindUser(const std::string& user_id) const {
+const User* UserManagerBase::FindUser(const AccountId& user_id) const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
-  if (active_user_ && active_user_->email() == user_id)
+  if (active_user_ && active_user_->GetUserID() == user_id)
     return active_user_;
   return FindUserInList(user_id);
 }
 
-User* UserManagerBase::FindUserAndModify(const std::string& user_id) {
+User* UserManagerBase::FindUserAndModify(const AccountId& user_id) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
-  if (active_user_ && active_user_->email() == user_id)
+  if (active_user_ && active_user_->GetUserID() == user_id)
     return active_user_;
   return FindUserInListAndModify(user_id);
 }
 
 const User* UserManagerBase::GetLoggedInUser() const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return active_user_;
 }
 
 User* UserManagerBase::GetLoggedInUser() {
@@ skipping 10 matching lines @@
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return active_user_;
 }
 
 const User* UserManagerBase::GetPrimaryUser() const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return primary_user_;
 }
 
 void UserManagerBase::SaveUserOAuthStatus(
-    const std::string& user_id,
+    const AccountId& user_id,
     User::OAuthTokenStatus oauth_token_status) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   DVLOG(1) << "Saving user OAuth token status in Local State";
   User* user = FindUserAndModify(user_id);
   if (user)
     user->set_oauth_token_status(oauth_token_status);
 
   // Do not update local state if data stored or cached outside the user's
   // cryptohome is to be treated as ephemeral.
   if (IsUserNonCryptohomeDataEphemeral(user_id))
     return;
 
   DictionaryPrefUpdate oauth_status_update(GetLocalState(),
                                            kUserOAuthTokenStatus);
   oauth_status_update->SetWithoutPathExpansion(
-      user_id,
+      user_id.GetUserEmail(),
       new base::FundamentalValue(static_cast<int>(oauth_token_status)));
 }
 
-void UserManagerBase::SaveForceOnlineSignin(const std::string& user_id,
+void UserManagerBase::SaveForceOnlineSignin(const AccountId& user_id,
                                             bool force_online_signin) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   // Do not update local state if data stored or cached outside the user's
   // cryptohome is to be treated as ephemeral.
   if (IsUserNonCryptohomeDataEphemeral(user_id))
     return;
 
   DictionaryPrefUpdate force_online_update(GetLocalState(),
                                            kUserForceOnlineSignin);
-  force_online_update->SetBooleanWithoutPathExpansion(user_id,
+  force_online_update->SetBooleanWithoutPathExpansion(user_id.GetUserEmail(),
                                                       force_online_signin);
 }
 
-void UserManagerBase::SaveUserDisplayName(const std::string& user_id,
+void UserManagerBase::SaveUserDisplayName(const AccountId& user_id,
                                           const base::string16& display_name) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   if (User* user = FindUserAndModify(user_id)) {
     user->set_display_name(display_name);
 
     // Do not update local state if data stored or cached outside the user's
     // cryptohome is to be treated as ephemeral.
     if (!IsUserNonCryptohomeDataEphemeral(user_id)) {
       DictionaryPrefUpdate display_name_update(GetLocalState(),
                                                kUserDisplayName);
       display_name_update->SetWithoutPathExpansion(
-          user_id, new base::StringValue(display_name));
+          user_id.GetUserEmail(), new base::StringValue(display_name));
     }
   }
 }
 
 base::string16 UserManagerBase::GetUserDisplayName(
-    const std::string& user_id) const {
+    const AccountId& user_id) const {
   const User* user = FindUser(user_id);
   return user ? user->display_name() : base::string16();
 }
 
-void UserManagerBase::SaveUserDisplayEmail(const std::string& user_id,
+void UserManagerBase::SaveUserDisplayEmail(const AccountId& user_id,
                                            const std::string& display_email) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   User* user = FindUserAndModify(user_id);
   if (!user) {
-    LOG(ERROR) << "User not found: " << user_id;
+    LOG(ERROR) << "User not found: " << user_id.GetUserEmail();
     return;  // Ignore if there is no such user.
   }
 
   user->set_display_email(display_email);
 
   // Do not update local state if data stored or cached outside the user's
   // cryptohome is to be treated as ephemeral.
   if (IsUserNonCryptohomeDataEphemeral(user_id))
     return;
 
   DictionaryPrefUpdate display_email_update(GetLocalState(), kUserDisplayEmail);
   display_email_update->SetWithoutPathExpansion(
-      user_id, new base::StringValue(display_email));
+      user_id.GetUserEmail(), new base::StringValue(display_email));
 }
 
 std::string UserManagerBase::GetUserDisplayEmail(
-    const std::string& user_id) const {
+    const AccountId& user_id) const {
   const User* user = FindUser(user_id);
-  return user ? user->display_email() : user_id;
+  return user ? user->display_email() : user_id.GetUserEmail();
 }
 
-void UserManagerBase::SaveUserType(const std::string& user_id,
+void UserManagerBase::SaveUserType(const AccountId& user_id,
                                    const UserType& user_type) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   User* user = FindUserAndModify(user_id);
   if (!user) {
-    LOG(ERROR) << "User not found: " << user_id;
+    LOG(ERROR) << "User not found: " << user_id.GetUserEmail();
     return;  // Ignore if there is no such user.
   }
 
   // Do not update local state if data stored or cached outside the user's
   // cryptohome is to be treated as ephemeral.
   if (IsUserNonCryptohomeDataEphemeral(user_id))
     return;
 
   DictionaryPrefUpdate user_type_update(GetLocalState(), kUserType);
   user_type_update->SetWithoutPathExpansion(
-      user_id, new base::FundamentalValue(static_cast<int>(user_type)));
+      user_id.GetUserEmail(),
+      new base::FundamentalValue(static_cast<int>(user_type)));
   GetLocalState()->CommitPendingWrite();
 }
 
-void UserManagerBase::UpdateUsingSAML(const std::string& user_id,
+void UserManagerBase::UpdateUsingSAML(const AccountId& user_id,
                                       const bool using_saml) {
   SetKnownUserBooleanPref(user_id, kUsingSAMLKey, using_saml);
 }
 
-bool UserManagerBase::FindUsingSAML(const std::string& user_id) {
+bool UserManagerBase::FindUsingSAML(const AccountId& user_id) {
   bool using_saml;
   if (GetKnownUserBooleanPref(user_id, kUsingSAMLKey, &using_saml))
     return using_saml;
   return false;
 }
 
-void UserManagerBase::UpdateReauthReason(const std::string& user_id,
+void UserManagerBase::UpdateReauthReason(const AccountId& user_id,
                                          const int reauth_reason) {
   SetKnownUserIntegerPref(user_id, kReauthReasonKey, reauth_reason);
 }
 
-bool UserManagerBase::FindReauthReason(const std::string& user_id,
+bool UserManagerBase::FindReauthReason(const AccountId& user_id,
                                        int* out_value) {
   return GetKnownUserIntegerPref(user_id, kReauthReasonKey, out_value);
 }
 
 void UserManagerBase::UpdateUserAccountData(
-    const std::string& user_id,
+    const AccountId& user_id,
     const UserAccountData& account_data) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   SaveUserDisplayName(user_id, account_data.display_name());
 
   if (User* user = FindUserAndModify(user_id)) {
     base::string16 given_name = account_data.given_name();
     user->set_given_name(given_name);
     if (!IsUserNonCryptohomeDataEphemeral(user_id)) {
       DictionaryPrefUpdate given_name_update(GetLocalState(), kUserGivenName);
       given_name_update->SetWithoutPathExpansion(
-          user_id, new base::StringValue(given_name));
+          user_id.GetUserEmail(), new base::StringValue(given_name));
     }
   }
 
   UpdateUserAccountLocale(user_id, account_data.locale());
 }
 
 // static
 void UserManagerBase::ParseUserList(const base::ListValue& users_list,
-                                    const std::set<std::string>& existing_users,
-                                    std::vector<std::string>* users_vector,
-                                    std::set<std::string>* users_set) {
+                                    const std::set<AccountId>& existing_users,
+                                    std::vector<AccountId>* users_vector,
+                                    std::set<AccountId>* users_set) {
   users_vector->clear();
   users_set->clear();
   for (size_t i = 0; i < users_list.GetSize(); ++i) {
     std::string email;
     if (!users_list.GetString(i, &email) || email.empty()) {
       LOG(ERROR) << "Corrupt entry in user list at index " << i << ".";
       continue;
     }
-    if (existing_users.find(email) != existing_users.end() ||
-        !users_set->insert(email).second) {
+    const AccountId account_id(AccountId::FromUserEmail(email));
+    if (existing_users.find(account_id) != existing_users.end() ||
+        !users_set->insert(account_id).second) {
       LOG(ERROR) << "Duplicate user: " << email;
       continue;
     }
-    users_vector->push_back(email);
+    users_vector->push_back(account_id);
   }
 }
 
 bool UserManagerBase::IsCurrentUserOwner() const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   base::AutoLock lk(is_current_user_owner_lock_);
   return is_current_user_owner_;
 }
 
 void UserManagerBase::SetCurrentUserIsOwner(bool is_current_user_owner) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   {
     base::AutoLock lk(is_current_user_owner_lock_);
     is_current_user_owner_ = is_current_user_owner;
   }
   UpdateLoginState();
 }
 
 bool UserManagerBase::IsCurrentUserNew() const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return is_current_user_new_;
 }
 
 bool UserManagerBase::IsCurrentUserNonCryptohomeDataEphemeral() const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return IsUserLoggedIn() &&
-         IsUserNonCryptohomeDataEphemeral(GetLoggedInUser()->email());
+         IsUserNonCryptohomeDataEphemeral(GetLoggedInUser()->GetUserID());
 }
 
 bool UserManagerBase::CanCurrentUserLock() const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return IsUserLoggedIn() && active_user_->can_lock();
 }
 
 bool UserManagerBase::IsUserLoggedIn() const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return active_user_;
@@ skipping 35 matching lines @@
   return IsUserLoggedIn() &&
          active_user_->email() == chromeos::login::kStubUser;
 }
 
 bool UserManagerBase::IsSessionStarted() const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return session_started_;
 }
 
 bool UserManagerBase::IsUserNonCryptohomeDataEphemeral(
-    const std::string& user_id) const {
+    const AccountId& user_id) const {
   // Data belonging to the guest and stub users is always ephemeral.
-  if (user_id == chromeos::login::kGuestUserName ||
-      user_id == chromeos::login::kStubUser) {
+  if (user_id == chromeos::login::GuestAccountId() ||
+      user_id == chromeos::login::StubAccountId()) {
     return true;
   }
 
   // Data belonging to the owner, anyone found on the user list and obsolete
   // public accounts whose data has not been removed yet is not ephemeral.
-  if (user_id == GetOwnerEmail() || UserExistsInList(user_id) ||
+  if (user_id == GetOwnerId() || UserExistsInList(user_id) ||
       IsPublicAccountMarkedForRemoval(user_id)) {
     return false;
   }
 
   // Data belonging to the currently logged-in user is ephemeral when:
   // a) The user logged into a regular gaia account while the ephemeral users
   //    policy was enabled.
   //    - or -
   // b) The user logged into any other account type.
-  if (IsUserLoggedIn() && (user_id == GetLoggedInUser()->email()) &&
+  if (IsUserLoggedIn() && (user_id == GetLoggedInUser()->GetUserID()) &&
       (is_current_user_ephemeral_regular_user_ ||
        !IsLoggedInAsUserWithGaiaAccount())) {
     return true;
   }
 
   // Data belonging to any other user is ephemeral when:
   // a) Going through the regular login flow and the ephemeral users policy is
   //    enabled.
   //    - or -
   // b) The browser is restarting after a crash.
@@ skipping 59 matching lines @@
 }
 
 void UserManagerBase::SetEphemeralUsersEnabled(bool enabled) {
   ephemeral_users_enabled_ = enabled;
 }
 
 void UserManagerBase::SetIsCurrentUserNew(bool is_new) {
   is_current_user_new_ = is_new;
 }
 
-bool UserManagerBase::HasPendingBootstrap(const std::string& user_id) const {
+bool UserManagerBase::HasPendingBootstrap(const AccountId& user_id) const {
   return false;
 }
 
-void UserManagerBase::SetOwnerEmail(const std::string& owner_user_id) {
-  owner_email_ = owner_user_id;
+void UserManagerBase::SetOwnerId(const AccountId& owner_user_id) {
+  owner_id_ = owner_user_id;
 }
 
-const std::string& UserManagerBase::GetPendingUserSwitchID() const {
+const AccountId& UserManagerBase::GetPendingUserSwitchID() const {
   return pending_user_switch_;
 }
 
-void UserManagerBase::SetPendingUserSwitchID(const std::string& user_id) {
+void UserManagerBase::SetPendingUserSwitchId(const AccountId& user_id) {
   pending_user_switch_ = user_id;
 }
 
 void UserManagerBase::EnsureUsersLoaded() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   if (!GetLocalState())
     return;
 
   if (user_loading_stage_ != STAGE_NOT_LOADED)
     return;
   user_loading_stage_ = STAGE_LOADING;
 
   PerformPreUserListLoadingActions();
 
   PrefService* local_state = GetLocalState();
   const base::ListValue* prefs_regular_users =
       local_state->GetList(kRegularUsers);
 
   const base::DictionaryValue* prefs_display_names =
       local_state->GetDictionary(kUserDisplayName);
   const base::DictionaryValue* prefs_given_names =
       local_state->GetDictionary(kUserGivenName);
   const base::DictionaryValue* prefs_display_emails =
       local_state->GetDictionary(kUserDisplayEmail);
   const base::DictionaryValue* prefs_user_types =
       local_state->GetDictionary(kUserType);
 
   // Load public sessions first.
-  std::set<std::string> public_sessions_set;
+  std::set<AccountId> public_sessions_set;
   LoadPublicAccounts(&public_sessions_set);
 
   // Load regular users and supervised users.
-  std::vector<std::string> regular_users;
-  std::set<std::string> regular_users_set;
+  std::vector<AccountId> regular_users;
+  std::set<AccountId> regular_users_set;
   ParseUserList(*prefs_regular_users,
                 public_sessions_set,
                 &regular_users,
                 &regular_users_set);
-  for (std::vector<std::string>::const_iterator it = regular_users.begin();
-       it != regular_users.end();
-       ++it) {
+  for (std::vector<AccountId>::const_iterator it = regular_users.begin();
+       it != regular_users.end(); ++it) {
     User* user = NULL;
-    const std::string domain = gaia::ExtractDomainName(*it);
+    const std::string domain = gaia::ExtractDomainName(it->GetUserEmail());
     if (domain == chromeos::login::kSupervisedUserDomain) {
       user = User::CreateSupervisedUser(*it);
     } else {
       user = User::CreateRegularUser(*it);
       int user_type;
-      if (prefs_user_types->GetIntegerWithoutPathExpansion(*it, &user_type) &&
+      if (prefs_user_types->GetIntegerWithoutPathExpansion(it->GetUserEmail(),
+                                                           &user_type) &&
           user_type == USER_TYPE_CHILD) {
         ChangeUserChildStatus(user, true /* is child */);
       }
     }
     user->set_oauth_token_status(LoadUserOAuthStatus(*it));
     user->set_force_online_signin(LoadForceOnlineSignin(*it));
     user->set_using_saml(FindUsingSAML(*it));
     users_.push_back(user);
 
     base::string16 display_name;
-    if (prefs_display_names->GetStringWithoutPathExpansion(*it,
+    if (prefs_display_names->GetStringWithoutPathExpansion(it->GetUserEmail(),
                                                            &display_name)) {
       user->set_display_name(display_name);
     }
 
     base::string16 given_name;
-    if (prefs_given_names->GetStringWithoutPathExpansion(*it, &given_name)) {
+    if (prefs_given_names->GetStringWithoutPathExpansion(it->GetUserEmail(),
+                                                         &given_name)) {
       user->set_given_name(given_name);
     }
 
     std::string display_email;
-    if (prefs_display_emails->GetStringWithoutPathExpansion(*it,
+    if (prefs_display_emails->GetStringWithoutPathExpansion(it->GetUserEmail(),
                                                             &display_email)) {
       user->set_display_email(display_email);
     }
   }
 
   user_loading_stage_ = STAGE_LOADED;
 
   PerformPostUserListLoadingActions();
 }
 
 UserList& UserManagerBase::GetUsersAndModify() {
   EnsureUsersLoaded();
   return users_;
 }
 
-const User* UserManagerBase::FindUserInList(const std::string& user_id) const {
+const User* UserManagerBase::FindUserInList(const AccountId& user_id) const {
   const UserList& users = GetUsers();
   for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
-    if ((*it)->email() == user_id)
+    if ((*it)->GetUserID() == user_id)
       return *it;
   }
   return NULL;
 }
 
-bool UserManagerBase::UserExistsInList(const std::string& user_id) const {
+bool UserManagerBase::UserExistsInList(const AccountId& user_id) const {
   const base::ListValue* user_list = GetLocalState()->GetList(kRegularUsers);
   for (size_t i = 0; i < user_list->GetSize(); ++i) {
     std::string email;
-    if (user_list->GetString(i, &email) && (user_id == email))
+    if (user_list->GetString(i, &email) && (user_id.GetUserEmail() == email))
       return true;
   }
   return false;
 }
 
-User* UserManagerBase::FindUserInListAndModify(const std::string& user_id) {
+User* UserManagerBase::FindUserInListAndModify(const AccountId& user_id) {
   UserList& users = GetUsersAndModify();
   for (UserList::iterator it = users.begin(); it != users.end(); ++it) {
-    if ((*it)->email() == user_id)
+    if ((*it)->GetUserID() == user_id)
       return *it;
   }
   return NULL;
 }
 
 void UserManagerBase::GuestUserLoggedIn() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   active_user_ = User::CreateGuestUser();
 }
 
 void UserManagerBase::AddUserRecord(User* user) {
   // Add the user to the front of the user list.
   ListPrefUpdate prefs_users_update(GetLocalState(), kRegularUsers);
   prefs_users_update->Insert(0, new base::StringValue(user->email()));
   users_.insert(users_.begin(), user);
 }
 
-void UserManagerBase::RegularUserLoggedIn(const std::string& user_id) {
+void UserManagerBase::RegularUserLoggedIn(const AccountId& user_id) {
   // Remove the user from the user list.
   active_user_ = RemoveRegularOrSupervisedUserFromList(user_id);
 
   // If the user was not found on the user list, create a new user.
   SetIsCurrentUserNew(!active_user_);
   if (IsCurrentUserNew()) {
     active_user_ = User::CreateRegularUser(user_id);
     active_user_->set_oauth_token_status(LoadUserOAuthStatus(user_id));
-    SaveUserDisplayName(active_user_->email(),
+    SaveUserDisplayName(active_user_->GetUserID(),
                         base::UTF8ToUTF16(active_user_->GetAccountName(true)));
   }
 
   AddUserRecord(active_user_);
 
   // Make sure that new data is persisted to Local State.
   GetLocalState()->CommitPendingWrite();
 }
 
-void UserManagerBase::RegularUserLoggedInAsEphemeral(
-    const std::string& user_id) {
+void UserManagerBase::RegularUserLoggedInAsEphemeral(const AccountId& user_id) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   SetIsCurrentUserNew(true);
   is_current_user_ephemeral_regular_user_ = true;
   active_user_ = User::CreateRegularUser(user_id);
 }
 
 void UserManagerBase::NotifyOnLogin() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   NotifyActiveUserHashChanged(active_user_->username_hash());
   NotifyActiveUserChanged(active_user_);
   UpdateLoginState();
 }
 
 User::OAuthTokenStatus UserManagerBase::LoadUserOAuthStatus(
-    const std::string& user_id) const {
+    const AccountId& user_id) const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   const base::DictionaryValue* prefs_oauth_status =
       GetLocalState()->GetDictionary(kUserOAuthTokenStatus);
   int oauth_token_status = User::OAUTH_TOKEN_STATUS_UNKNOWN;
   if (prefs_oauth_status &&
-      prefs_oauth_status->GetIntegerWithoutPathExpansion(user_id,
+      prefs_oauth_status->GetIntegerWithoutPathExpansion(user_id.GetUserEmail(),
                                                          &oauth_token_status)) {
     User::OAuthTokenStatus status =
         static_cast<User::OAuthTokenStatus>(oauth_token_status);
     HandleUserOAuthTokenStatusChange(user_id, status);
 
     return status;
   }
   return User::OAUTH_TOKEN_STATUS_UNKNOWN;
 }
 
-bool UserManagerBase::LoadForceOnlineSignin(const std::string& user_id) const {
+bool UserManagerBase::LoadForceOnlineSignin(const AccountId& user_id) const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   const base::DictionaryValue* prefs_force_online =
       GetLocalState()->GetDictionary(kUserForceOnlineSignin);
   bool force_online_signin = false;
   if (prefs_force_online) {
-    prefs_force_online->GetBooleanWithoutPathExpansion(user_id,
+    prefs_force_online->GetBooleanWithoutPathExpansion(user_id.GetUserEmail(),
                                                        &force_online_signin);
   }
   return force_online_signin;
 }
 
-void UserManagerBase::RemoveNonCryptohomeData(const std::string& user_id) {
+void UserManagerBase::RemoveNonCryptohomeData(const AccountId& user_id) {
   PrefService* prefs = GetLocalState();
   DictionaryPrefUpdate prefs_display_name_update(prefs, kUserDisplayName);
-  prefs_display_name_update->RemoveWithoutPathExpansion(user_id, NULL);
+  prefs_display_name_update->RemoveWithoutPathExpansion(user_id.GetUserEmail(),
+                                                        NULL);
 
   DictionaryPrefUpdate prefs_given_name_update(prefs, kUserGivenName);
-  prefs_given_name_update->RemoveWithoutPathExpansion(user_id, NULL);
+  prefs_given_name_update->RemoveWithoutPathExpansion(user_id.GetUserEmail(),
+                                                      NULL);
 
   DictionaryPrefUpdate prefs_display_email_update(prefs, kUserDisplayEmail);
-  prefs_display_email_update->RemoveWithoutPathExpansion(user_id, NULL);
+  prefs_display_email_update->RemoveWithoutPathExpansion(user_id.GetUserEmail(),
+                                                         NULL);
 
   DictionaryPrefUpdate prefs_oauth_update(prefs, kUserOAuthTokenStatus);
-  prefs_oauth_update->RemoveWithoutPathExpansion(user_id, NULL);
+  prefs_oauth_update->RemoveWithoutPathExpansion(user_id.GetUserEmail(), NULL);
 
   DictionaryPrefUpdate prefs_force_online_update(prefs, kUserForceOnlineSignin);
-  prefs_force_online_update->RemoveWithoutPathExpansion(user_id, NULL);
+  prefs_force_online_update->RemoveWithoutPathExpansion(user_id.GetUserEmail(),
+                                                        NULL);
 
   RemoveKnownUserPrefs(user_id);
 
-  std::string last_active_user = GetLocalState()->GetString(kLastActiveUser);
+  AccountId last_active_user =

[achuithb, 2015/10/23 00:08:52]

const AccountId last_active_account_id =

[Alexander Alekseev, 2015/10/23 09:11:25]

Done.

+      AccountId::FromUserEmail(GetLocalState()->GetString(kLastActiveUser));
   if (user_id == last_active_user)
     GetLocalState()->SetString(kLastActiveUser, std::string());
 }
 
 bool UserManagerBase::FindKnownUserPrefs(
-    const UserID& user_id,
+    const AccountId& user_id,
     const base::DictionaryValue** out_value) {
   PrefService* local_state = GetLocalState();
 
   // Local State may not be initialized in tests.
   if (!local_state)
     return false;
   if (IsUserNonCryptohomeDataEphemeral(user_id))
     return false;
 
   const base::ListValue* known_users = local_state->GetList(kKnownUsers);
   for (size_t i = 0; i < known_users->GetSize(); ++i) {
     const base::DictionaryValue* element = nullptr;
     if (known_users->GetDictionary(i, &element)) {
       if (UserMatches(user_id, *element)) {
         known_users->GetDictionary(i, out_value);
         return true;
       }
     }
   }
   return false;
 }
 
-void UserManagerBase::UpdateKnownUserPrefs(const UserID& user_id,
+void UserManagerBase::UpdateKnownUserPrefs(const AccountId& user_id,
                                            const base::DictionaryValue& values,
                                            bool clear) {
   PrefService* local_state = GetLocalState();
 
   // Local State may not be initialized in tests.
   if (!local_state)
     return;
 
   if (IsUserNonCryptohomeDataEphemeral(user_id))
     return;
@@ skipping 10 matching lines @@
         return;
       }
     }
   }
   scoped_ptr<base::DictionaryValue> new_value(new base::DictionaryValue());
   new_value->MergeDictionary(&values);
   UpdateIdentity(user_id, *new_value);
   update->Append(new_value.release());
 }
 
-bool UserManagerBase::GetKnownUserStringPref(const UserID& user_id,
+bool UserManagerBase::GetKnownUserStringPref(const AccountId& user_id,
                                              const std::string& path,
                                              std::string* out_value) {
   const base::DictionaryValue* user_pref_dict = nullptr;
   if (!FindKnownUserPrefs(user_id, &user_pref_dict))
     return false;
 
   return user_pref_dict->GetString(path, out_value);
 }
 
-void UserManagerBase::SetKnownUserStringPref(const UserID& user_id,
+void UserManagerBase::SetKnownUserStringPref(const AccountId& user_id,
                                              const std::string& path,
                                              const std::string& in_value) {
   PrefService* local_state = GetLocalState();
 
   // Local State may not be initialized in tests.
   if (!local_state)
     return;
 
   ListPrefUpdate update(local_state, kKnownUsers);
   base::DictionaryValue dict;
   dict.SetString(path, in_value);
   UpdateKnownUserPrefs(user_id, dict, false);
 }
 
-bool UserManagerBase::GetKnownUserBooleanPref(const UserID& user_id,
+bool UserManagerBase::GetKnownUserBooleanPref(const AccountId& user_id,
                                               const std::string& path,
                                               bool* out_value) {
   const base::DictionaryValue* user_pref_dict = nullptr;
   if (!FindKnownUserPrefs(user_id, &user_pref_dict))
     return false;
 
   return user_pref_dict->GetBoolean(path, out_value);
 }
 
-void UserManagerBase::SetKnownUserBooleanPref(const UserID& user_id,
+void UserManagerBase::SetKnownUserBooleanPref(const AccountId& user_id,
                                               const std::string& path,
                                               const bool in_value) {
   PrefService* local_state = GetLocalState();
 
   // Local State may not be initialized in tests.
   if (!local_state)
     return;
 
   ListPrefUpdate update(local_state, kKnownUsers);
   base::DictionaryValue dict;
   dict.SetBoolean(path, in_value);
   UpdateKnownUserPrefs(user_id, dict, false);
 }
 
-bool UserManagerBase::GetKnownUserIntegerPref(const UserID& user_id,
+bool UserManagerBase::GetKnownUserIntegerPref(const AccountId& user_id,
                                               const std::string& path,
                                               int* out_value) {
   const base::DictionaryValue* user_pref_dict = nullptr;
   if (!FindKnownUserPrefs(user_id, &user_pref_dict))
     return false;
   return user_pref_dict->GetInteger(path, out_value);
 }
 
-void UserManagerBase::SetKnownUserIntegerPref(const UserID& user_id,
+void UserManagerBase::SetKnownUserIntegerPref(const AccountId& user_id,
                                               const std::string& path,
                                               const int in_value) {
   PrefService* local_state = GetLocalState();
 
   // Local State may not be initialized in tests.
   if (!local_state)
     return;
 
   ListPrefUpdate update(local_state, kKnownUsers);
   base::DictionaryValue dict;
   dict.SetInteger(path, in_value);
   UpdateKnownUserPrefs(user_id, dict, false);
 }
 
-bool UserManagerBase::GetKnownUserCanonicalEmail(const UserID& user_id,
-                                                 std::string* out_email) {
-  return GetKnownUserStringPref(user_id, kCanonicalEmail, out_email);
+bool UserManagerBase::GetKnownUserAccountId(const AccountId& authenticated_id,
+                                            AccountId* out_id) {
+  DCHECK(!authenticated_id.GetGaiaId().empty());
+  std::string canonical_email;
+  if (!GetKnownUserStringPref(
+          AccountId::FromGaiaId(authenticated_id.GetGaiaId()), kCanonicalEmail,
+          &canonical_email))
+    return false;
+
+  *out_id = authenticated_id;
+  out_id->SetUserEmail(canonical_email);
+  return true;
 }
 
-void UserManagerBase::UpdateGaiaID(const UserID& user_id,
+void UserManagerBase::UpdateGaiaID(const AccountId& user_id,
                                    const std::string& gaia_id) {
   SetKnownUserStringPref(user_id, kGAIAIdKey, gaia_id);
 }
 
-bool UserManagerBase::FindGaiaID(const UserID& user_id,
+bool UserManagerBase::FindGaiaID(const AccountId& user_id,
                                  std::string* out_value) {
   return GetKnownUserStringPref(user_id, kGAIAIdKey, out_value);
 }
 
-void UserManagerBase::SetKnownUserDeviceId(const UserID& user_id,
+void UserManagerBase::SetKnownUserDeviceId(const AccountId& user_id,
                                            const std::string& device_id) {
   const std::string known_device_id = GetKnownUserDeviceId(user_id);
   if (!known_device_id.empty() && device_id != known_device_id) {
     NOTREACHED() << "Trying to change device ID for known user.";
   }
   SetKnownUserStringPref(user_id, kDeviceId, device_id);
 }
 
-std::string UserManagerBase::GetKnownUserDeviceId(const UserID& user_id) {
+std::string UserManagerBase::GetKnownUserDeviceId(const AccountId& user_id) {
   std::string device_id;
   if (GetKnownUserStringPref(user_id, kDeviceId, &device_id)) {
     return device_id;
   }
   return std::string();
 }
 
-void UserManagerBase::SetKnownUserGAPSCookie(const UserID& user_id,
+void UserManagerBase::SetKnownUserGAPSCookie(const AccountId& user_id,
                                              const std::string& gaps_cookie) {
   SetKnownUserStringPref(user_id, kGAPSCookie, gaps_cookie);
 }
 
-std::string UserManagerBase::GetKnownUserGAPSCookie(const UserID& user_id) {
+std::string UserManagerBase::GetKnownUserGAPSCookie(const AccountId& user_id) {
   std::string gaps_cookie;
   if (GetKnownUserStringPref(user_id, kGAPSCookie, &gaps_cookie)) {
     return gaps_cookie;
   }
   return std::string();
 }
 
 User* UserManagerBase::RemoveRegularOrSupervisedUserFromList(
-    const std::string& user_id) {
+    const AccountId& user_id) {
   ListPrefUpdate prefs_users_update(GetLocalState(), kRegularUsers);
   prefs_users_update->Clear();
   User* user = NULL;
   for (UserList::iterator it = users_.begin(); it != users_.end();) {
-    const std::string user_email = (*it)->email();
-    if (user_email == user_id) {
+    if ((*it)->GetUserID() == user_id) {
       user = *it;
       it = users_.erase(it);
     } else {
-      if ((*it)->HasGaiaAccount() || (*it)->IsSupervised())
+      if ((*it)->HasGaiaAccount() || (*it)->IsSupervised()) {
+        const std::string user_email = (*it)->email();
         prefs_users_update->Append(new base::StringValue(user_email));
+      }
       ++it;
     }
   }
   OnUserRemoved(user_id);
   return user;
 }
 
-void UserManagerBase::RemoveKnownUserPrefs(const UserID& user_id) {
+void UserManagerBase::RemoveKnownUserPrefs(const AccountId& user_id) {
   ListPrefUpdate update(GetLocalState(), kKnownUsers);
   for (size_t i = 0; i < update->GetSize(); ++i) {
     base::DictionaryValue* element = nullptr;
     if (update->GetDictionary(i, &element)) {
       if (UserMatches(user_id, *element)) {
         update->Remove(i, nullptr);
         break;
       }
     }
   }
@@ skipping 19 matching lines @@
   FOR_EACH_OBSERVER(UserManager::UserSessionStateObserver,
                     session_state_observer_list_,
                     ActiveUserHashChanged(hash));
 }
 
 void UserManagerBase::ChangeUserChildStatus(User* user, bool is_child) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   if (user->IsSupervised() == is_child)
     return;
   user->SetIsChild(is_child);
-  SaveUserType(user->email(), is_child ? user_manager::USER_TYPE_CHILD
-                                       : user_manager::USER_TYPE_REGULAR);
+  SaveUserType(user->GetUserID(), is_child ? user_manager::USER_TYPE_CHILD
+                                           : user_manager::USER_TYPE_REGULAR);
   FOR_EACH_OBSERVER(UserManager::UserSessionStateObserver,
                     session_state_observer_list_,
                     UserChangedChildStatus(user));
 }
 
 void UserManagerBase::UpdateLoginState() {
   if (!chromeos::LoginState::IsInitialized())
     return;  // LoginState may not be initialized in tests.
 
   chromeos::LoginState::LoggedInState logged_in_state;
@@ skipping 29 matching lines @@
   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::SendGaiaUserLoginMetrics(const std::string& user_id) {
+void UserManagerBase::SendGaiaUserLoginMetrics(const AccountId& 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.
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kFirstExecAfterBoot)) {
     const std::string last_email =
         GetLocalState()->GetString(kLastLoggedInGaiaUser);
     const base::TimeDelta time_to_login =
         base::TimeTicks::Now() - manager_creation_time_;
-    if (!last_email.empty() && user_id != last_email &&
+    if (!last_email.empty() &&
+        user_id != AccountId::FromUserEmail(last_email) &&
         time_to_login.InSeconds() <= kLogoutToLoginDelayMaxSec) {
       UMA_HISTOGRAM_CUSTOM_COUNTS("UserManager.LogoutToLoginDelay",
                                   time_to_login.InSeconds(),
                                   0,
                                   kLogoutToLoginDelayMaxSec,
                                   50);
     }
   }
 }
 
-void UserManagerBase::UpdateUserAccountLocale(const std::string& user_id,
+void UserManagerBase::UpdateUserAccountLocale(const AccountId& user_id,
                                               const std::string& locale) {
   scoped_ptr<std::string> resolved_locale(new std::string());
   if (!locale.empty() && locale != GetApplicationLocale()) {
     // base::Pased will NULL out |resolved_locale|, so cache the underlying ptr.
     std::string* raw_resolved_locale = resolved_locale.get();
     blocking_task_runner_->PostTaskAndReply(
         FROM_HERE,
         base::Bind(ResolveLocale,
                    locale,
                    base::Unretained(raw_resolved_locale)),
         base::Bind(&UserManagerBase::DoUpdateAccountLocale,
                    weak_factory_.GetWeakPtr(),
                    user_id,
                    base::Passed(&resolved_locale)));
   } else {
     resolved_locale.reset(new std::string(locale));
     DoUpdateAccountLocale(user_id, resolved_locale.Pass());
   }
 }
 
 void UserManagerBase::DoUpdateAccountLocale(
-    const std::string& user_id,
+    const AccountId& user_id,
     scoped_ptr<std::string> resolved_locale) {
   User* user = FindUserAndModify(user_id);
   if (user && resolved_locale)
     user->SetAccountLocale(*resolved_locale);
 }
 
 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