This CL replaces user_manager::UserID with AccountId.

chrome/browser/chromeos/login/existing_user_controller.cc

 // Copyright (c) 2012 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/existing_user_controller.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 106 matching lines @@
                                    base::Bind(&RefreshPoliciesOnUIThread));
 }
 
 // Record UMA for password login of regular user when Easy sign-in is enabled.
 void RecordPasswordLoginEvent(const UserContext& user_context) {
   EasyUnlockService* easy_unlock_service =
       EasyUnlockService::Get(ProfileHelper::GetSigninProfile());
   if (user_context.GetUserType() == user_manager::USER_TYPE_REGULAR &&
       user_context.GetAuthFlow() == UserContext::AUTH_FLOW_OFFLINE &&
       easy_unlock_service) {
-    easy_unlock_service->RecordPasswordLoginEvent(user_context.GetUserID());
+    easy_unlock_service->RecordPasswordLoginEvent(
+        user_context.GetAccountId().GetUserEmail());
   }
 }
 
 bool CanShowDebuggingFeatures() {
   // We need to be on the login screen and in dev mode to show this menu item.
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
              chromeos::switches::kSystemDevMode) &&
          base::CommandLine::ForCurrentProcess()->HasSwitch(
              chromeos::switches::kLoginManager) &&
          !user_manager::UserManager::Get()->IsSessionStarted();
@@ skipping 209 matching lines @@
       weak_factory_.GetWeakPtr(),
       user_context,
       specifics));
 }
 
 void ExistingUserController::PerformLogin(
     const UserContext& user_context,
     LoginPerformer::AuthorizationMode auth_mode) {
   VLOG(1) << "Setting flow from PerformLogin";
   ChromeUserManager::Get()
-      ->GetUserFlow(user_context.GetUserID())
+      ->GetUserFlow(user_context.GetAccountId())
       ->SetHost(host_);
 
   BootTimesRecorder::Get()->RecordLoginAttempted();
 
   // Use the same LoginPerformer for subsequent login as it has state
   // such as Authenticator instance.
   if (!login_performer_.get() || num_login_attempts_ <= 1) {
     // Only one instance of LoginPerformer should exist at a time.
     login_performer_.reset(NULL);
     login_performer_.reset(new ChromeLoginPerformer(this));
   }
 
-  if (gaia::ExtractDomainName(user_context.GetUserID()) ==
+  if (gaia::ExtractDomainName(user_context.GetAccountId().GetUserEmail()) ==
       chromeos::login::kSupervisedUserDomain) {
     login_performer_->LoginAsSupervisedUser(user_context);
   } else {
     login_performer_->PerformLogin(user_context, auth_mode);
     RecordPasswordLoginEvent(user_context);
   }
   SendAccessibilityAlert(
       l10n_util::GetStringUTF8(IDS_CHROMEOS_ACC_LOGIN_SIGNING_IN));
 }
 
@@ skipping 120 matching lines @@
 // ExistingUserController, LoginPerformer::Delegate implementation:
 //
 
 void ExistingUserController::OnAuthFailure(const AuthFailure& failure) {
   guest_mode_url_ = GURL::EmptyGURL();
   std::string error = failure.GetErrorString();
 
   PerformLoginFinishedActions(false /* don't start public session timer */);
 
   if (ChromeUserManager::Get()
-          ->GetUserFlow(last_login_attempt_username_)
+          ->GetUserFlow(last_login_attempt_account_id_)
           ->HandleLoginFailure(failure)) {
     return;
   }
 
   if (failure.reason() == AuthFailure::OWNER_REQUIRED) {
     ShowError(IDS_LOGIN_ERROR_OWNER_REQUIRED, error);
     content::BrowserThread::PostDelayedTask(
         content::BrowserThread::UI, FROM_HERE,
         base::Bind(&SessionManagerClient::StopSession,
                    base::Unretained(DBusThreadManager::Get()->
                                     GetSessionManagerClient())),
         base::TimeDelta::FromMilliseconds(kSafeModeRestartUiDelayMs));
   } else if (failure.reason() == AuthFailure::TPM_ERROR) {
     ShowTPMError();
-  } else if (last_login_attempt_username_ == chromeos::login::kGuestUserName) {
+  } else if (last_login_attempt_account_id_ == login::GuestAccountId()) {
     // Show no errors, just re-enable input.
     login_display_->ClearAndEnablePassword();
     StartPublicSessionAutoLoginTimer();
   } else {
     // Check networking after trying to login in case user is
     // cached locally or the local admin account.
     bool is_known_user = user_manager::UserManager::Get()->IsKnownUser(

[achuithb, 2015/10/28 23:11:44]

const

[Alexander Alekseev, 2015/10/29 02:00:40]

Done.

-        last_login_attempt_username_);
+        last_login_attempt_account_id_);
     if (!network_state_helper_->IsConnected()) {
       if (is_known_user)
         ShowError(IDS_LOGIN_ERROR_AUTHENTICATING, error);
       else
         ShowError(IDS_LOGIN_ERROR_OFFLINE_FAILED_NETWORK_NOT_CONNECTED, error);
     } else {
       // TODO(nkostylev): Cleanup rest of ClientLogin related code.
       if (failure.reason() == AuthFailure::NETWORK_AUTH_FAILED &&
           failure.error().state() ==
               GoogleServiceAuthError::HOSTED_NOT_ALLOWED) {
         ShowError(IDS_LOGIN_ERROR_AUTHENTICATING_HOSTED, error);
       } else {
         if (!is_known_user)
           ShowError(IDS_LOGIN_ERROR_AUTHENTICATING_NEW, error);
         else
           ShowError(IDS_LOGIN_ERROR_AUTHENTICATING, error);
       }
     }
     login_display_->ClearAndEnablePassword();
     StartPublicSessionAutoLoginTimer();
   }
 
   // Reset user flow to default, so that special flow will not affect next
   // attempt.
-  ChromeUserManager::Get()->ResetUserFlow(last_login_attempt_username_);
+  ChromeUserManager::Get()->ResetUserFlow(last_login_attempt_account_id_);
 
   if (auth_status_consumer_)
     auth_status_consumer_->OnAuthFailure(failure);
 
   // Clear the recorded displayed email so it won't affect any future attempts.
   display_email_.clear();
 
   // TODO(ginkage): Fix this case once crbug.com/469990 is ready.
   /*
     if (failure.reason() == AuthFailure::COULD_NOT_MOUNT_CRYPTOHOME) {
-      RecordReauthReason(last_login_attempt_username_,
+      RecordReauthReason(last_login_attempt_account_id_,
                          ReauthReason::MISSING_CRYPTOHOME);
     }
   */
 }
 
 void ExistingUserController::OnAuthSuccess(const UserContext& user_context) {
   is_login_in_progress_ = false;
   login_display_->set_signin_completed(true);
 
   // Login performer will be gone so cache this value to use
   // once profile is loaded.
   password_changed_ = login_performer_->password_changed();
   auth_mode_ = login_performer_->auth_mode();
 
   ChromeUserManager::Get()
-      ->GetUserFlow(user_context.GetUserID())
+      ->GetUserFlow(user_context.GetAccountId())
       ->HandleLoginSuccess(user_context);
 
   StopPublicSessionAutoLoginTimer();
 
   // Truth table of |has_auth_cookies|:
   //                          Regular        SAML
   //  /ServiceLogin              T            T
   //  /ChromeOsEmbeddedSetup     F            T
   //  Bootstrap experiment       F            N/A
   const bool has_auth_cookies =
@@ skipping 11 matching lines @@
           ? UserSessionManager::SECONDARY_USER_SESSION
           : UserSessionManager::PRIMARY_USER_SESSION;
   UserSessionManager::GetInstance()->StartSession(
       user_context, start_session_type, has_auth_cookies,
       false,  // Start session for user.
       this);
 
   // Update user's displayed email.
   if (!display_email_.empty()) {
     user_manager::UserManager::Get()->SaveUserDisplayEmail(
-        user_context.GetUserID(), display_email_);
+        user_context.GetAccountId(), display_email_);
     display_email_.clear();
   }
 }
 
 void ExistingUserController::OnProfilePrepared(Profile* profile,
                                                bool browser_launched) {
   // Reenable clicking on other windows and status area.
   login_display_->SetUIEnabled(true);
 
   if (browser_launched)
     host_ = NULL;
 
   // Inform |auth_status_consumer_| about successful login.
   // TODO(nkostylev): Pass UserContext back crbug.com/424550
   if (auth_status_consumer_) {
-    auth_status_consumer_->
-        OnAuthSuccess(UserContext(last_login_attempt_username_));
+    auth_status_consumer_->OnAuthSuccess(
+        UserContext(last_login_attempt_account_id_));
   }
 }
 
 void ExistingUserController::OnOffTheRecordAuthSuccess() {
   is_login_in_progress_ = false;
 
   // Mark the device as registered., i.e. the second part of OOBE as completed.
   if (!StartupUtils::IsDeviceRegistered())
     StartupUtils::MarkDeviceRegistered(base::Closure());
 
   UserSessionManager::GetInstance()->CompleteGuestSessionLogin(guest_mode_url_);
 
   if (auth_status_consumer_)
     auth_status_consumer_->OnOffTheRecordAuthSuccess();
 }
 
 void ExistingUserController::OnPasswordChangeDetected() {
   is_login_in_progress_ = false;
 
   // Must not proceed without signature verification.
   if (CrosSettingsProvider::TRUSTED != cros_settings_->PrepareTrustedValues(
       base::Bind(&ExistingUserController::OnPasswordChangeDetected,
                  weak_factory_.GetWeakPtr()))) {
     // Value of owner email is still not verified.
     // Another attempt will be invoked after verification completion.
     return;
   }
 
   if (ChromeUserManager::Get()
-          ->GetUserFlow(last_login_attempt_username_)
+          ->GetUserFlow(last_login_attempt_account_id_)
           ->HandlePasswordChangeDetected()) {
     return;
   }
 
   // True if user has already made an attempt to enter old password and failed.
   bool show_invalid_old_password_error =
       login_performer_->password_changed_callback_count() > 1;
 
   // Note: We allow owner using "full sync" mode which will recreate
   // cryptohome and deal with owner private key being lost. This also allows
@@ skipping 76 matching lines @@
       l10n_util::GetStringUTF8(IDS_CHROMEOS_ACC_LOGIN_SIGNIN_OFFRECORD));
 }
 
 void ExistingUserController::LoginAsPublicSession(
     const UserContext& user_context) {
   PerformPreLoginActions(user_context);
 
   // If there is no public account with the given user ID, logging in is not
   // possible.
   const user_manager::User* user =
-      user_manager::UserManager::Get()->FindUser(user_context.GetUserID());
+      user_manager::UserManager::Get()->FindUser(user_context.GetAccountId());
   if (!user || user->GetType() != user_manager::USER_TYPE_PUBLIC_ACCOUNT) {
     PerformLoginFinishedActions(true /* start public session timer */);
     return;
   }
 
   UserContext new_user_context = user_context;
   std::string locale = user_context.GetPublicSessionLocale();
   if (locale.empty()) {
     // When performing auto-login, no locale is chosen by the user. Check
     // whether a list of recommended locales was set by policy. If so, use its
     // first entry. Otherwise, |locale| will remain blank, indicating that the
     // public session should use the current UI locale.
-    const policy::PolicyMap::Entry* entry = g_browser_process->platform_part()->
-        browser_policy_connector_chromeos()->
-            GetDeviceLocalAccountPolicyService()->
-                GetBrokerForUser(user_context.GetUserID())->core()->store()->
-                    policy_map().Get(policy::key::kSessionLocales);
+    const policy::PolicyMap::Entry* entry =
+        g_browser_process->platform_part()
+            ->browser_policy_connector_chromeos()
+            ->GetDeviceLocalAccountPolicyService()
+            ->GetBrokerForUser(user_context.GetAccountId().GetUserEmail())
+            ->core()
+            ->store()
+            ->policy_map()
+            .Get(policy::key::kSessionLocales);
     base::ListValue const* list = NULL;
     if (entry &&
         entry->level == policy::POLICY_LEVEL_RECOMMENDED &&
         entry->value &&
         entry->value->GetAsList(&list)) {
       if (list->GetString(0, &locale))
         new_user_context.SetPublicSessionLocale(locale);
     }
   }
 
@@ skipping 45 matching lines @@
   for (std::vector<policy::DeviceLocalAccount>::const_iterator
            it = device_local_accounts.begin();
        it != device_local_accounts.end(); ++it) {
     if (it->account_id == auto_login_account_id) {
       public_session_auto_login_username_ = it->user_id;
       break;
     }
   }
 
   const user_manager::User* user = user_manager::UserManager::Get()->FindUser(
-      public_session_auto_login_username_);
+      AccountId::FromUserEmail(public_session_auto_login_username_));
   if (!user || user->GetType() != user_manager::USER_TYPE_PUBLIC_ACCOUNT)
     public_session_auto_login_username_.clear();
 
   if (!cros_settings_->GetInteger(
           kAccountsPrefDeviceLocalAccountAutoLoginDelay,
           &public_session_auto_login_delay_)) {
     public_session_auto_login_delay_ = 0;
   }
 
   if (!public_session_auto_login_username_.empty())
@@ skipping 65 matching lines @@
   } else {
     // login_performer_ will be null if an error occurred during OAuth2 token
     // fetch. In this case, show a generic error.
     help_topic_id = HelpAppLauncher::HELP_CANT_ACCESS_ACCOUNT;
   }
 
   if (error_id == IDS_LOGIN_ERROR_AUTHENTICATING) {
     if (num_login_attempts_ > 1) {
       const user_manager::User* user =
           user_manager::UserManager::Get()->FindUser(
-              last_login_attempt_username_);
+              last_login_attempt_account_id_);
       if (user && (user->GetType() == user_manager::USER_TYPE_SUPERVISED))
         error_id = IDS_LOGIN_ERROR_AUTHENTICATING_2ND_TIME_SUPERVISED;
     }
   }
 
   login_display_->ShowError(error_id, num_login_attempts_, help_topic_id);
 }
 
 void ExistingUserController::SendAccessibilityAlert(
     const std::string& alert_text) {
@@ skipping 30 matching lines @@
   login_performer_->LoginAsPublicSession(user_context);
   SendAccessibilityAlert(
       l10n_util::GetStringUTF8(IDS_CHROMEOS_ACC_LOGIN_SIGNIN_PUBLIC_ACCOUNT));
 }
 
 void ExistingUserController::PerformPreLoginActions(
     const UserContext& user_context) {
   // Disable clicking on other windows and status tray.
   login_display_->SetUIEnabled(false);
 
-  if (last_login_attempt_username_ != user_context.GetUserID()) {
-    last_login_attempt_username_ = user_context.GetUserID();
+  if (last_login_attempt_account_id_ != user_context.GetAccountId()) {
+    last_login_attempt_account_id_ = user_context.GetAccountId();
     num_login_attempts_ = 0;
   }
 
   // Guard in cases when we're called twice but login process is still active.
   // This might happen when login process is paused till signed settings status
   // is verified which results in Login* method called again as a callback.
   if (!is_login_in_progress_)
     num_login_attempts_++;
 
   is_login_in_progress_ = true;
@@ skipping 59 matching lines @@
   }
 
   continuation.Run();
 }
 
 void ExistingUserController::DoCompleteLogin(
     const UserContext& user_context_wo_device_id) {
   UserContext user_context = user_context_wo_device_id;
   std::string device_id =
       user_manager::UserManager::Get()->GetKnownUserDeviceId(
-          user_context.GetUserID());
+          user_context.GetAccountId());
   if (device_id.empty()) {
-    bool is_ephemeral =
-        ChromeUserManager::Get()->AreEphemeralUsersEnabled() &&
-        user_context.GetUserID() != ChromeUserManager::Get()->GetOwnerEmail();
+    bool is_ephemeral = ChromeUserManager::Get()->AreEphemeralUsersEnabled() &&
+                        user_context.GetAccountId() !=
+                            ChromeUserManager::Get()->GetOwnerAccountId();
     device_id = SigninClient::GenerateSigninScopedDeviceID(is_ephemeral);
   }
   user_context.SetDeviceId(device_id);
 
   const std::string& gaps_cookie = user_context.GetGAPSCookie();
   if (!gaps_cookie.empty()) {
     user_manager::UserManager::Get()->SetKnownUserGAPSCookie(
-        user_context.GetUserID(), gaps_cookie);
+        user_context.GetAccountId(), gaps_cookie);
   }
 
   PerformPreLoginActions(user_context);
 
   if (!time_init_.is_null()) {
     base::TimeDelta delta = base::Time::Now() - time_init_;
     UMA_HISTOGRAM_MEDIUM_TIMES("Login.PromptToCompleteLoginTime", delta);
     time_init_ = base::Time();  // Reset to null.
   }
 
@@ skipping 51 matching lines @@
     LoginAsGuest();
     return;
   }
 
   if (user_context.GetUserType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT) {
     LoginAsPublicSession(user_context);
     return;
   }
 
   if (user_context.GetUserType() == user_manager::USER_TYPE_KIOSK_APP) {
-    LoginAsKioskApp(user_context.GetUserID(), specifics.kiosk_diagnostic_mode);
+    LoginAsKioskApp(user_context.GetAccountId().GetUserEmail(),
+                    specifics.kiosk_diagnostic_mode);
     return;
   }
 
   // Regular user or supervised user login.
 
   if (!user_context.HasCredentials()) {
     // If credentials are missing, refuse to log in.
 
     // Reenable clicking on other windows and status area.
     login_display_->SetUIEnabled(true);
@@ skipping 10 matching lines @@
     const UserContext& user_context) {
   if (!success) {
     LOG(ERROR) << "Easy bootstrap failed.";
     OnAuthFailure(AuthFailure(AuthFailure::NETWORK_AUTH_FAILED));
     return;
   }
 
   // Setting a customized login user flow to perform additional initializations
   // for bootstrap after the user session is started.
   ChromeUserManager::Get()->SetUserFlow(
-      user_context.GetUserID(),
+      user_context.GetAccountId(),
       new BootstrapUserFlow(
           user_context,
           bootstrap_user_context_initializer_->random_key_used()));
 
   PerformLogin(user_context, LoginPerformer::AUTH_MODE_EXTENSION);
 }
 
 void ExistingUserController::OnOAuth2TokensFetched(
     bool success,
     const UserContext& user_context) {
   if (!success) {
     LOG(ERROR) << "OAuth2 token fetch failed.";
     OnAuthFailure(AuthFailure(AuthFailure::FAILED_TO_INITIALIZE_TOKEN));
     return;
   }
   UserSessionManager::GetInstance()->OnOAuth2TokensFetched(user_context);
   PerformLogin(user_context, LoginPerformer::AUTH_MODE_EXTENSION);
 }
 
 }  // namespace chromeos