We should use UserID object to identify users instead of username.

chrome/browser/chromeos/login/session/user_session_manager.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 "chrome/browser/chromeos/login/session/user_session_manager.h"
 
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
@@ skipping 356 matching lines @@
   // This makes sure that Chrome restarts with no per-session flags. The guest
   // profile will always have empty set of per-session flags. If this is not
   // done and device owner has some per-session flags, when Chrome is relaunched
   // the guest profile session flags will not match the current command line and
   // another restart will be attempted in order to reset the user flags for the
   // guest user.
   const base::CommandLine user_flags(base::CommandLine::NO_PROGRAM);
   if (!about_flags::AreSwitchesIdenticalToCurrentCommandLine(
           user_flags, *base::CommandLine::ForCurrentProcess(), NULL)) {
     DBusThreadManager::Get()->GetSessionManagerClient()->SetFlagsForUser(
-        chromeos::login::kGuestUserName, base::CommandLine::StringVector());
+        chromeos::login::GetGuestUserID(), base::CommandLine::StringVector());
   }
 
   RestartChrome(cmd_line_str);
 }
 
 scoped_refptr<Authenticator> UserSessionManager::CreateAuthenticator(
     AuthStatusConsumer* consumer) {
   // Screen locker needs new Authenticator instance each time.
   if (ScreenLocker::default_screen_locker()) {
     if (authenticator_.get())
@@ skipping 17 matching lines @@
 
 void UserSessionManager::StartSession(
     const UserContext& user_context,
     StartSessionType start_session_type,
     bool has_auth_cookies,
     bool has_active_session,
     UserSessionManagerDelegate* delegate) {
   delegate_ = delegate;
   start_session_type_ = start_session_type;
 
-  VLOG(1) << "Starting session for " << user_context.GetUserID();
+  VLOG(1) << "Starting session for " << user_context.GetUserID().GetUserEmail();
 
   PreStartSession();
   CreateUserSession(user_context, has_auth_cookies);
 
   if (!has_active_session)
     StartCrosSession();
 
   // TODO(nkostylev): Notify UserLoggedIn() after profile is actually
   // ready to be used (http://crbug.com/361528).
   NotifyUserLoggedIn();
@@ skipping 32 matching lines @@
   if (!user_manager->IsUserLoggedIn() ||
       !user_manager->IsLoggedInAsUserWithGaiaAccount() ||
       user_manager->IsLoggedInAsStub()) {
     return;
   }
 
   const user_manager::User* user =
       ProfileHelper::Get()->GetUserByProfile(user_profile);
   DCHECK(user);
   if (!net::NetworkChangeNotifier::IsOffline()) {
-    pending_signin_restore_sessions_.erase(user->email());
+    pending_signin_restore_sessions_.erase(user->GetUserID());
     RestoreAuthSessionImpl(user_profile, false /* has_auth_cookies */);
   } else {
     // Even if we're online we should wait till initial
     // OnConnectionTypeChanged() call. Otherwise starting fetchers too early may
     // end up canceling all request when initial network connection type is
     // processed. See http://crbug.com/121643.
-    pending_signin_restore_sessions_.insert(user->email());
+    pending_signin_restore_sessions_.insert(user->GetUserID());
   }
 }
 
 void UserSessionManager::RestoreActiveSessions() {
   user_sessions_restore_in_progress_ = true;
   DBusThreadManager::Get()->GetSessionManagerClient()->RetrieveActiveSessions(
       base::Bind(&UserSessionManager::OnRestoreActiveSessions, AsWeakPtr()));
 }
 
 bool UserSessionManager::UserSessionsRestored() const {
@@ skipping 163 matching lines @@
 
   LogCustomSwitches(command_line_difference);
 
   about_flags::ReportCustomFlags("Login.CustomFlags", command_line_difference);
 
   base::CommandLine::StringVector flags;
   // argv[0] is the program name |base::CommandLine::NO_PROGRAM|.
   flags.assign(user_flags.argv().begin() + 1, user_flags.argv().end());
   LOG(WARNING) << "Restarting to apply per-session flags...";
   DBusThreadManager::Get()->GetSessionManagerClient()->SetFlagsForUser(
-      user_manager::UserManager::Get()->GetActiveUser()->email(), flags);
+      user_manager::UserManager::Get()->GetActiveUser()->GetUserID(), flags);
   AttemptRestart(profile);
   return true;
 }
 
 bool UserSessionManager::NeedsToUpdateEasyUnlockKeys() const {
   return EasyUnlockService::IsSignInEnabled() &&
          !user_context_.GetUserID().empty() &&
          user_manager::User::TypeHasGaiaAccount(user_context_.GetUserType()) &&
          user_context_.GetKey() && !user_context_.GetKey()->GetSecret().empty();
 }
@@ skipping 44 matching lines @@
     case OAuth2LoginManager::SESSION_RESTORE_PREPARING:
     case OAuth2LoginManager::SESSION_RESTORE_IN_PROGRESS:
       return;
   }
 
   // We should not be clearing existing token state if that was a connection
   // error. http://crbug.com/295245
   if (!connection_error) {
     // We are in one of "done" states here.
     user_manager::UserManager::Get()->SaveUserOAuthStatus(
-        user_manager::UserManager::Get()->GetLoggedInUser()->email(),
+        user_manager::UserManager::Get()->GetLoggedInUser()->GetUserID(),
         user_status);
   }
 
   login_manager->RemoveObserver(this);
 
   if (exit_after_session_restore_ &&
       (state  == OAuth2LoginManager::SESSION_RESTORE_DONE ||
        state  == OAuth2LoginManager::SESSION_RESTORE_FAILED ||
        state  == OAuth2LoginManager::SESSION_RESTORE_CONNECTION_FAILED)) {
     LOG(WARNING) << "Restarting Chrome after session restore finishes, "
@@ skipping 22 matching lines @@
   // Need to iterate over all users and their OAuth2 session state.
   const user_manager::UserList& users = user_manager->GetLoggedInUsers();
   for (user_manager::UserList::const_iterator it = users.begin();
        it != users.end();
        ++it) {
     if (!(*it)->is_profile_created())
       continue;
 
     Profile* user_profile = ProfileHelper::Get()->GetProfileByUserUnsafe(*it);
     bool should_restore_session =
-        pending_signin_restore_sessions_.find((*it)->email()) !=
+        pending_signin_restore_sessions_.find((*it)->GetUserID()) !=
         pending_signin_restore_sessions_.end();
     OAuth2LoginManager* login_manager =
         OAuth2LoginManagerFactory::GetInstance()->GetForProfile(user_profile);
     if (login_manager->SessionRestoreIsRunning()) {
       // If we come online for the first time after successful offline login,
       // we need to kick off OAuth token verification process again.
       login_manager->ContinueSessionRestore();
     } else if (should_restore_session) {
-      pending_signin_restore_sessions_.erase((*it)->email());
+      pending_signin_restore_sessions_.erase((*it)->GetUserID());
       RestoreAuthSessionImpl(user_profile, false /* has_auth_cookies */);
     }
   }
 }
 
 void UserSessionManager::OnProfilePrepared(Profile* profile,
                                            bool browser_launched) {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           ::switches::kTestName)) {
     // Did not log in (we crashed or are debugging), need to restore Sync.
@@ skipping 29 matching lines @@
 }
 
 void UserSessionManager::PreStartSession() {
   // Switch log file as soon as possible.
   if (base::SysInfo::IsRunningOnChromeOS())
     logging::RedirectChromeLogging(*(base::CommandLine::ForCurrentProcess()));
 }
 
 void UserSessionManager::StoreUserContextDataBeforeProfileIsCreated() {
   // Store obfuscated GAIA ID.
-  if (!user_context_.GetGaiaID().empty()) {
+  if (!user_context_.GetUserID().GetGaiaId().empty()) {
     user_manager::UserManager::Get()->UpdateGaiaID(user_context_.GetUserID(),
-                                                   user_context_.GetGaiaID());
+                                                   user_context_.GetUserID().GetGaiaId());
   }
 }
 
 void UserSessionManager::StartCrosSession() {
   BootTimesRecorder* btl = BootTimesRecorder::Get();
   btl->AddLoginTimeMarker("StartSession-Start", false);
   DBusThreadManager::Get()->GetSessionManagerClient()->
       StartSession(user_context_.GetUserID());
   btl->AddLoginTimeMarker("StartSession-End", false);
 }
@@ skipping 15 matching lines @@
   // TODO(nkostylev): Figure out whether demo session is using the right profile
   // path or not. See https://codereview.chromium.org/171423009
   g_browser_process->profile_manager()->CreateProfileAsync(
       ProfileHelper::GetProfilePathByUserIdHash(user_context_.GetUserIDHash()),
       base::Bind(&UserSessionManager::OnProfileCreated,
                  AsWeakPtr(),
                  user_context_,
                  is_demo_session),
       base::string16(),
       base::string16(),
-      std::string());
+      user_manager::UserID(std::string(), std::string()));

[Denis Kuznetsov (DE-MUC), 2015/06/10 16:50:46]

EmptyGaiaID() ?

 }
 
 void UserSessionManager::OnProfileCreated(const UserContext& user_context,
                                           bool is_incognito_profile,
                                           Profile* profile,
                                           Profile::CreateStatus status) {
   CHECK(profile);
 
   switch (status) {
     case Profile::CREATE_STATUS_CREATED:
@@ skipping 36 matching lines @@
     SetFirstLoginPrefs(profile,
                        user_context.GetPublicSessionLocale(),
                        user_context.GetPublicSessionInputMethod());
   }
 
   if (user_manager::UserManager::Get()->IsLoggedInAsSupervisedUser()) {
     user_manager::User* active_user =
         user_manager::UserManager::Get()->GetActiveUser();
     std::string supervised_user_sync_id =
         ChromeUserManager::Get()->GetSupervisedUserManager()->GetUserSyncId(
-            active_user->email());
+            active_user->GetUserID());
     profile->GetPrefs()->SetString(prefs::kSupervisedUserId,
                                    supervised_user_sync_id);
   } else if (user_manager::UserManager::Get()->
       IsLoggedInAsUserWithGaiaAccount()) {
-    // Get the Gaia ID from the user context.  If it's not available, this may
-    // not be available when unlocking a previously opened profile, or when
-    // creating a supervised users.  However, in these cases the gaia_id should
-    // be already available in the account tracker.
-    std::string gaia_id = user_context.GetGaiaID();
-    if (gaia_id.empty()) {
-      AccountTrackerService* account_tracker =
-          AccountTrackerServiceFactory::GetForProfile(profile);
-      AccountTrackerService::AccountInfo info =
-          account_tracker->FindAccountInfoByEmail(user_context.GetUserID());
-      gaia_id = info.gaia;
-      DCHECK(!gaia_id.empty());
+    user_manager::UserID user_id(user->GetUserID());
+
+    {
+      // Get the Gaia ID from the user context.  If it's not available, this may
+      // not be available when unlocking a previously opened profile, or when
+      // creating a supervised users.  However, in these cases the gaia_id should
+      // be already available in the account tracker.
+      std::string gaia_id = user_context.GetUserID().GetGaiaId();
+      if (gaia_id.empty()) {
+        AccountTrackerService* account_tracker =
+            AccountTrackerServiceFactory::GetForProfile(profile);
+        AccountTrackerService::AccountInfo info =
+            account_tracker->FindAccountInfoByEmail(user_context.GetUserID().GetUserEmail());
+        gaia_id = info.gaia;
+        DCHECK(!gaia_id.empty());
+      }
+      user_id.SetGaiaId(gaia_id);
     }
 
     // Make sure that the google service username is properly set (we do this
     // on every sign in, not just the first login, to deal with existing
     // profiles that might not have it set yet).
     SigninManagerBase* signin_manager =
         SigninManagerFactory::GetForProfile(profile);
-    signin_manager->SetAuthenticatedAccountInfo(gaia_id,
-                                                user_context.GetUserID());
+    signin_manager->SetAuthenticatedAccountInfo(user_id.GetGaiaId(),
+                                                user_id.GetUserEmail());
 
     // Backfill GAIA ID in user prefs stored in Local State.
     std::string tmp_gaia_id;
     user_manager::UserManager* user_manager = user_manager::UserManager::Get();
     if (!user_manager->FindGaiaID(user_context.GetUserID(), &tmp_gaia_id) &&
-        !gaia_id.empty()) {
-      user_manager->UpdateGaiaID(user_context.GetUserID(), gaia_id);
+        !user_id.GetGaiaId().empty()) {
+      user_manager->UpdateGaiaID(user_context.GetUserID(), user_id.GetGaiaId());
     }
   }
 }
 
 void UserSessionManager::UserProfileInitialized(Profile* profile,
                                                 bool is_incognito_profile,
-                                                const std::string& user_id) {
+                                                const user_manager::UserID& user_id) {
   // Demo user signed in.
   if (is_incognito_profile) {
     profile->OnLogin();
 
     // Send the notification before creating the browser so additional objects
     // that need the profile (e.g. the launcher) can be created first.
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
         content::NotificationService::AllSources(),
         content::Details<Profile>(profile));
@@ skipping 364 matching lines @@
     // If we could not get list of active user sessions it is safer to just
     // sign out so that we don't get in the inconsistent state.
     DBusThreadManager::Get()->GetSessionManagerClient()->StopSession();
     return;
   }
 
   // One profile has been already loaded on browser start.
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
   DCHECK(user_manager->GetLoggedInUsers().size() == 1);
   DCHECK(user_manager->GetActiveUser());
-  std::string active_user_id = user_manager->GetActiveUser()->email();
+  const user_manager::UserID& active_user_id = user_manager->GetActiveUser()->GetUserID();

[Denis Kuznetsov (DE-MUC), 2015/06/10 16:50:46]

auto

 
   SessionManagerClient::ActiveSessionsMap::const_iterator it;
   for (it = sessions.begin(); it != sessions.end(); ++it) {
     if (active_user_id == it->first)
       continue;
     pending_user_sessions_[it->first] = it->second;
   }
   RestorePendingUserSessions();
 }
 
 void UserSessionManager::RestorePendingUserSessions() {
   if (pending_user_sessions_.empty()) {
     user_manager::UserManager::Get()->SwitchToLastActiveUser();
     NotifyPendingUserSessionsRestoreFinished();
     return;
   }
 
   // Get next user to restore sessions and delete it from list.
   SessionManagerClient::ActiveSessionsMap::const_iterator it =
       pending_user_sessions_.begin();
-  std::string user_id = it->first;
+  user_manager::UserID user_id = it->first;
   std::string user_id_hash = it->second;
   DCHECK(!user_id.empty());
   DCHECK(!user_id_hash.empty());
   pending_user_sessions_.erase(user_id);
 
   // Check that this user is not logged in yet.
   user_manager::UserList logged_in_users =
       user_manager::UserManager::Get()->GetLoggedInUsers();
   bool user_already_logged_in = false;
   for (user_manager::UserList::const_iterator it = logged_in_users.begin();
        it != logged_in_users.end();
        ++it) {
     const user_manager::User* user = (*it);
-    if (user->email() == user_id) {
+    if (user->GetUserID() == user_id) {
       user_already_logged_in = true;
       break;
     }
   }
   DCHECK(!user_already_logged_in);
 
   if (!user_already_logged_in) {
     UserContext user_context(user_id);
     user_context.SetUserIDHash(user_id_hash);
     user_context.SetIsUsingOAuth(false);
@@ skipping 99 matching lines @@
           OAuth2LoginManager::SESSION_RESTORE_IN_PROGRESS) {
     chrome::AttemptRestart();
     return;
   }
 
   LOG(WARNING) << "Attempting browser restart during session restore.";
   exit_after_session_restore_ = true;
 }
 
 void UserSessionManager::OnEasyUnlockKeyOpsFinished(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     bool success) {
   running_easy_unlock_key_ops_ = false;
   if (!easy_unlock_key_ops_finished_callback_.is_null())
     easy_unlock_key_ops_finished_callback_.Run();
 
   const user_manager::User* user =
       user_manager::UserManager::Get()->FindUser(user_id);
   EasyUnlockService* easy_unlock_service =
         EasyUnlockService::GetForUser(*user);
   easy_unlock_service->CheckCryptohomeKeysAndMaybeHardlock();
@@ skipping 184 matching lines @@
   cros_settings->GetBoolean(kAccountsPrefShowUserNamesOnSignIn,
                             &show_names_on_signin);
   return show_names_on_signin && !ephemeral_users_enabled;
 }
 
 void UserSessionManager::Shutdown() {
   token_handle_util_.reset();
 }
 
 }  // namespace chromeos