This CL replaces user_manager::UserID with AccountId.

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 432 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.GetAccountId().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();
 
   if (!user_context.GetDeviceId().empty()) {
     user_manager::UserManager::Get()->SetKnownUserDeviceId(
-        user_context.GetUserID(), user_context.GetDeviceId());
+        user_context.GetAccountId(), user_context.GetDeviceId());
   }
 
   PrepareProfile();
 }
 
 void UserSessionManager::DelegateDeleted(UserSessionManagerDelegate* delegate) {
   if (delegate_ == delegate)
     delegate_ = nullptr;
 }
 
@@ skipping 215 matching lines @@
   // 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);
   AttemptRestart(profile);
   return true;
 }
 
 bool UserSessionManager::NeedsToUpdateEasyUnlockKeys() const {
-  return !user_context_.GetUserID().empty() &&
+  return user_context_.GetAccountId().is_valid() &&
          user_manager::User::TypeHasGaiaAccount(user_context_.GetUserType()) &&
          user_context_.GetKey() && !user_context_.GetKey()->GetSecret().empty();
 }
 
 bool UserSessionManager::CheckEasyUnlockKeyOps(const base::Closure& callback) {
   if (!running_easy_unlock_key_ops_)
     return false;
 
   // Assumes only one deferred callback is needed.
   DCHECK(easy_unlock_key_ops_finished_callback_.is_null());
@@ skipping 37 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()->GetAccountId(),
         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 82 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()) {
-    user_manager::UserManager::Get()->UpdateGaiaID(user_context_.GetUserID(),
+    user_manager::UserManager::Get()->UpdateGaiaID(user_context_.GetAccountId(),
                                                    user_context_.GetGaiaID());
   }
 }
 
 void UserSessionManager::StartCrosSession() {
   BootTimesRecorder* btl = BootTimesRecorder::Get();
   btl->AddLoginTimeMarker("StartSession-Start", false);
-  DBusThreadManager::Get()->GetSessionManagerClient()->
-      StartSession(user_context_.GetUserID());
+  DBusThreadManager::Get()->GetSessionManagerClient()->StartSession(
+      user_context_.GetAccountId().GetUserEmail());
   btl->AddLoginTimeMarker("StartSession-End", false);
 }
 
 void UserSessionManager::NotifyUserLoggedIn() {
   BootTimesRecorder* btl = BootTimesRecorder::Get();
   btl->AddLoginTimeMarker("UserLoggedIn-Start", false);
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
-  user_manager->UserLoggedIn(user_context_.GetUserID(),
-                             user_context_.GetUserIDHash(),
-                             false);
+  user_manager->UserLoggedIn(user_context_.GetAccountId(),
+                             user_context_.GetUserIDHash(), false);
   btl->AddLoginTimeMarker("UserLoggedIn-End", false);
 }
 
 void UserSessionManager::PrepareProfile() {
-  bool is_demo_session =
-      DemoAppLauncher::IsDemoAppSession(user_context_.GetUserID());
+  const bool is_demo_session = DemoAppLauncher::IsDemoAppSession(
+      user_context_.GetAccountId().GetUserEmail());
 
   // 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());
 }
 
 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:
       // Profile created but before initializing extensions and promo resources.
       InitProfilePreferences(profile, user_context);
       break;
     case Profile::CREATE_STATUS_INITIALIZED:
       // Profile is created, extensions and promo resources are initialized.
       // At this point all other Chrome OS services will be notified that it is
       // safe to use this profile.
-      UserProfileInitialized(profile,
-                             is_incognito_profile,
-                             user_context.GetUserID());
+      UserProfileInitialized(profile, is_incognito_profile,
+                             user_context.GetAccountId());
       break;
     case Profile::CREATE_STATUS_LOCAL_FAIL:
     case Profile::CREATE_STATUS_REMOTE_FAIL:
     case Profile::CREATE_STATUS_CANCELED:
     case Profile::MAX_CREATE_STATUS:
       NOTREACHED();
       break;
   }
 }
 
@@ skipping 29 matching lines @@
   } 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);
-      AccountInfo info =
-          account_tracker->FindAccountInfoByEmail(user_context.GetUserID());
+      const AccountInfo info = account_tracker->FindAccountInfoByEmail(
+          user_context.GetAccountId().GetUserEmail());
       gaia_id = info.gaia;
       DCHECK(!gaia_id.empty());
     }
 
     // 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(
+        gaia_id, user_context.GetAccountId().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) &&
+    if (!user_manager->FindGaiaID(user_context.GetAccountId(), &tmp_gaia_id) &&
         !gaia_id.empty()) {
-      user_manager->UpdateGaiaID(user_context.GetUserID(), gaia_id);
+      user_manager->UpdateGaiaID(user_context.GetAccountId(), gaia_id);
     }
   }
 }
 
 void UserSessionManager::UserProfileInitialized(Profile* profile,
                                                 bool is_incognito_profile,
-                                                const std::string& user_id) {
+                                                const AccountId& account_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));
 
     if (delegate_)
       delegate_->OnProfilePrepared(profile, false);
 
     return;
   }
 
   BootTimesRecorder* btl = BootTimesRecorder::Get();
   btl->AddLoginTimeMarker("UserProfileGotten", false);
 
   if (user_context_.IsUsingOAuth()) {
     // Retrieve the policy that indicates whether to continue copying
     // authentication cookies set by a SAML IdP on subsequent logins after the
     // first.
     bool transfer_saml_auth_cookies_on_subsequent_login = false;
     if (has_auth_cookies_ &&
-        g_browser_process->platform_part()->
-            browser_policy_connector_chromeos()->GetUserAffiliation(user_id) ==
-                policy::USER_AFFILIATION_MANAGED) {
+        g_browser_process->platform_part()
+                ->browser_policy_connector_chromeos()
+                ->GetUserAffiliation(account_id.GetUserEmail()) ==
+            policy::USER_AFFILIATION_MANAGED) {
       CrosSettings::Get()->GetBoolean(
           kAccountsPrefTransferSAMLCookies,
           &transfer_saml_auth_cookies_on_subsequent_login);
     }
 
     // Transfers authentication-related data from the profile that was used for
     // authentication to the user's profile. The proxy authentication state is
     // transferred unconditionally. If the user authenticated via an auth
     // extension, authentication cookies and channel IDs will be transferred as
     // well when the user's cookie jar is empty. If the cookie jar is not empty,
@@ skipping 48 matching lines @@
     if (cryptohome_util::TpmIsOwned())
       client->CallTpmClearStoredPasswordAndBlock();
     else
       client->TpmCanAttemptOwnership(EmptyVoidDBusMethodCallback());
   }
   btl->AddLoginTimeMarker("TPMOwn-End", false);
 
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
   if (user_manager->IsLoggedInAsUserWithGaiaAccount()) {
     if (user_context_.GetAuthFlow() == UserContext::AUTH_FLOW_GAIA_WITH_SAML)
-      user_manager->UpdateUsingSAML(user_context_.GetUserID(), true);
+      user_manager->UpdateUsingSAML(user_context_.GetAccountId(), true);
     SAMLOfflineSigninLimiter* saml_offline_signin_limiter =
         SAMLOfflineSigninLimiterFactory::GetForProfile(profile);
     if (saml_offline_signin_limiter)
       saml_offline_signin_limiter->SignedIn(user_context_.GetAuthFlow());
   }
 
   profile->OnLogin();
 
   g_browser_process->platform_part()->SessionManager()->SetSessionState(
       session_manager::SESSION_STATE_LOGGED_IN_NOT_ACTIVE);
@@ skipping 12 matching lines @@
     InitRlz(profile);
     InitializeCerts(profile);
     InitializeCRLSetFetcher(user);
     InitializeEVCertificatesWhitelistComponent(user);
   }
 
   UpdateEasyUnlockKeys(user_context_);
   user_context_.ClearSecrets();
   if (TokenHandlesEnabled()) {
     CreateTokenUtilIfMissing();
-    if (token_handle_util_->ShouldObtainHandle(user->GetUserID())) {
+    if (token_handle_util_->ShouldObtainHandle(user->GetAccountId())) {
       if (!token_handle_fetcher_.get()) {
         token_handle_fetcher_.reset(new TokenHandleFetcher(
-            token_handle_util_.get(), user->GetUserID()));
+            token_handle_util_.get(), user->GetAccountId()));
         token_handle_fetcher_->BackfillToken(
             profile, base::Bind(&UserSessionManager::OnTokenHandleObtained,
                                 weak_factory_.GetWeakPtr()));
       }
     }
   }
 
   // Now that profile is ready, proceed to either alternative login flows or
   // launch browser.
   bool browser_launched = InitializeUserSession(profile);
@@ skipping 291 matching lines @@
        ++it) {
     const user_manager::User* user = (*it);
     if (user->email() == user_id) {
       user_already_logged_in = true;
       break;
     }
   }
   DCHECK(!user_already_logged_in);
 
   if (!user_already_logged_in) {
-    UserContext user_context(user_id);
+    UserContext user_context(AccountId::FromUserEmail(user_id));
     user_context.SetUserIDHash(user_id_hash);
     user_context.SetIsUsingOAuth(false);
 
     // Will call OnProfilePrepared() once profile has been loaded.
     // Only handling secondary users here since primary user profile
     // (and session) has been loaded on Chrome startup.
     StartSession(user_context,
                  SECONDARY_USER_SESSION_AFTER_CRASH,
                  false,  // has_auth_cookies
                  true,   // has_active_session, this is restart after crash
@@ skipping 17 matching lines @@
   // and RefreshKeys op expects a failure to stop. As a result, some tests would
   // timeout.
   // TODO(xiyuan): Revisit this when adding tests.
   if (!base::SysInfo::IsRunningOnChromeOS())
     return;
 
   // Only update Easy unlock keys for regular user.
   // TODO(xiyuan): Fix inconsistency user type of |user_context| introduced in
   // authenticator.
   const user_manager::User* user =
-      user_manager::UserManager::Get()->FindUser(user_context.GetUserID());
+      user_manager::UserManager::Get()->FindUser(user_context.GetAccountId());
   if (!user || !user->HasGaiaAccount())
     return;
 
   // Bail if |user_context| does not have secret.
   if (user_context.GetKey()->GetSecret().empty())
     return;
 
   const base::ListValue* device_list = NULL;
   EasyUnlockService* easy_unlock_service = EasyUnlockService::GetForUser(*user);
   if (easy_unlock_service) {
     device_list = easy_unlock_service->GetRemoteDevices();
     easy_unlock_service->SetHardlockState(
         EasyUnlockScreenlockStateHandler::NO_HARDLOCK);
   }
 
   base::ListValue empty_list;
   if (!device_list)
     device_list = &empty_list;
 
   EasyUnlockKeyManager* key_manager = GetEasyUnlockKeyManager();
   running_easy_unlock_key_ops_ = true;
   key_manager->RefreshKeys(
       user_context, *device_list,
       base::Bind(&UserSessionManager::OnEasyUnlockKeyOpsFinished, AsWeakPtr(),
-                 user_context.GetUserID()));
+                 user_context.GetAccountId().GetUserEmail()));
 }
 
 net::URLRequestContextGetter*
 UserSessionManager::GetAuthRequestContext() const {
   net::URLRequestContextGetter* auth_request_context = nullptr;
 
   if (StartupUtils::IsWebviewSigninEnabled()) {
     // Webview uses different partition storage than iframe. We need to get
     // cookies from the right storage for url request to get auth token into
     // session.
@@ skipping 40 matching lines @@
   exit_after_session_restore_ = true;
 }
 
 void UserSessionManager::OnEasyUnlockKeyOpsFinished(
     const std::string& 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);
+  const user_manager::User* user = user_manager::UserManager::Get()->FindUser(
+      AccountId::FromUserEmail(user_id));
   EasyUnlockService* easy_unlock_service =
         EasyUnlockService::GetForUser(*user);
   easy_unlock_service->CheckCryptohomeKeysAndMaybeHardlock();
 }
 
 void UserSessionManager::ActiveUserChanged(
     const user_manager::User* active_user) {
   if (!user_manager::UserManager::Get()->IsCurrentUserNew())
     SendUserPodsMetrics();
 
@@ skipping 140 matching lines @@
     else
       display = USER_PODS_DISPLAY_DISABLED_REGULAR;
   }
   UMA_HISTOGRAM_ENUMERATION("UserSessionManager.UserPodsDisplay", display,
                             NUM_USER_PODS_DISPLAY);
 }
 
 void UserSessionManager::OnOAuth2TokensFetched(UserContext context) {
   if (StartupUtils::IsWebviewSigninEnabled() && TokenHandlesEnabled()) {
     CreateTokenUtilIfMissing();
-    if (token_handle_util_->ShouldObtainHandle(context.GetUserID())) {
+    if (token_handle_util_->ShouldObtainHandle(context.GetAccountId())) {
       token_handle_fetcher_.reset(new TokenHandleFetcher(
-          token_handle_util_.get(), context.GetUserID()));
+          token_handle_util_.get(), context.GetAccountId()));
       token_handle_fetcher_->FillForNewUser(
           context.GetAccessToken(),
           base::Bind(&UserSessionManager::OnTokenHandleObtained,
                      weak_factory_.GetWeakPtr()));
     }
   }
 }
 
-void UserSessionManager::OnTokenHandleObtained(const user_manager::UserID& id,
+void UserSessionManager::OnTokenHandleObtained(const AccountId& account_id,
                                                bool success) {
   if (!success)
     LOG(ERROR) << "OAuth2 token handle fetch failed.";
   token_handle_fetcher_.reset();
 }
 
 bool UserSessionManager::TokenHandlesEnabled() {
   if (!should_obtain_handles_)
     return false;
   bool ephemeral_users_enabled = false;
@@ skipping 12 matching lines @@
   first_run::GoodiesDisplayer::Delete();
 }
 
 void UserSessionManager::CreateTokenUtilIfMissing() {
   if (!token_handle_util_.get())
     token_handle_util_.reset(
         new TokenHandleUtil(user_manager::UserManager::Get()));
 }
 
 }  // namespace chromeos