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

chrome/browser/ui/webui/chromeos/login/gaia_screen_handler.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/webui/chromeos/login/gaia_screen_handler.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
@@ skipping 486 matching lines @@
     bool using_saml) {
   if (!Delegate())
     return;
 
   RecordGAIAFlowTypeHistogram();
 
   DCHECK(!email.empty());
   DCHECK(!gaia_id.empty());
   const std::string sanitized_email = gaia::SanitizeEmail(email);
   Delegate()->SetDisplayEmail(sanitized_email);
-  UserContext user_context(sanitized_email);
-  user_context.SetGaiaID(gaia_id);
+
+  user_manager::UserID user_id(user_manager::UserID::FromUserEmail(sanitized_email));
+  user_id.SetGaiaId(gaia_id);
+  UserContext user_context(user_id);
   user_context.SetKey(Key(password));
   user_context.SetAuthCode(auth_code);
   user_context.SetAuthFlow(using_saml
                                ? UserContext::AUTH_FLOW_GAIA_WITH_SAML
                                : UserContext::AUTH_FLOW_GAIA_WITHOUT_SAML);
   Delegate()->CompleteLogin(user_context);
 }
 
 void GaiaScreenHandler::HandleCompleteAuthenticationAuthCodeOnly(
     const std::string& auth_code) {
@@ skipping 11 matching lines @@
 void GaiaScreenHandler::HandleCompleteLogin(const std::string& gaia_id,
                                             const std::string& typed_email,
                                             const std::string& password,
                                             bool using_saml) {
   if (!is_enrolling_consumer_management_) {
     DoCompleteLogin(gaia_id, typed_email, password, using_saml);
     return;
   }
 
   // Consumer management enrollment is in progress.
-  const std::string owner_email =
-      user_manager::UserManager::Get()->GetOwnerEmail();
-  if (typed_email != owner_email) {
+  const user_manager::UserID owner_id =
+      user_manager::UserManager::Get()->GetOwnerID();
+  if (user_manager::UserID::FromUserEmail(typed_email) != owner_id) {
     // Show Gaia sign-in screen again, since we only allow the owner to sign
     // in.
-    populated_email_ = owner_email;
+    populated_email_ = owner_id.GetUserEmail();
     ShowGaiaAsync(is_enrolling_consumer_management_);
     return;
   }
 
   CHECK(consumer_management_);
-  consumer_management_->SetOwner(owner_email,
+  consumer_management_->SetOwner(owner_id,
                                  base::Bind(&GaiaScreenHandler::OnSetOwnerDone,
                                             weak_factory_.GetWeakPtr(),
                                             gaia_id,
                                             typed_email,
                                             password,
                                             using_saml));
 }
 
 void GaiaScreenHandler::HandleUsingSAMLAPI() {
   SetSAMLPrincipalsAPIUsed(true);
@@ skipping 95 matching lines @@
     return;
 
   if (using_saml && !using_saml_api_)
     RecordSAMLScrapingVerificationResultInHistogram(true);
   RecordGAIAFlowTypeHistogram();
 
   DCHECK(!typed_email.empty());
   DCHECK(!gaia_id.empty());
   const std::string sanitized_email = gaia::SanitizeEmail(typed_email);
   Delegate()->SetDisplayEmail(sanitized_email);
-  UserContext user_context(sanitized_email);
-  user_context.SetGaiaID(gaia_id);
+
+  user_manager::UserID user_id(user_manager::UserID::FromUserEmail(sanitized_email));
+  user_id.SetGaiaId(gaia_id);
+  UserContext user_context(user_id);
   user_context.SetKey(Key(password));
   user_context.SetAuthFlow(using_saml
                                ? UserContext::AUTH_FLOW_GAIA_WITH_SAML
                                : UserContext::AUTH_FLOW_GAIA_WITHOUT_SAML);
   Delegate()->CompleteLogin(user_context);
 
   if (test_expects_complete_login_) {
     VLOG(2) << "Complete test login for " << typed_email
             << ", requested=" << test_user_;
 
     test_expects_complete_login_ = false;
     test_user_.clear();
     test_pass_.clear();
   }
 }
 
 void GaiaScreenHandler::PopulateEmail(const std::string& user_id) {
   populated_email_ = user_id;
 }
 
-void GaiaScreenHandler::PasswordChangedFor(const std::string& user_id) {
+void GaiaScreenHandler::PasswordChangedFor(const user_manager::UserID& user_id) {
   password_changed_for_.insert(user_id);
 }
 
 void GaiaScreenHandler::StartClearingDnsCache() {
   if (dns_clear_task_running_ || !g_browser_process->io_thread())
     return;
 
   dns_cleared_ = false;
   BrowserThread::PostTaskAndReply(
       BrowserThread::IO,
@@ skipping 21 matching lines @@
                  weak_factory_.GetWeakPtr(), on_clear_callback));
 }
 
 void GaiaScreenHandler::OnCookiesCleared(
     const base::Closure& on_clear_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   cookies_cleared_ = true;
   on_clear_callback.Run();
 }
 
-void GaiaScreenHandler::ShowSigninScreenForCreds(const std::string& username,
+void GaiaScreenHandler::ShowSigninScreenForCreds(const user_manager::UserID& user_id,
                                                  const std::string& password) {
-  VLOG(2) << "ShowSigninScreenForCreds  for user " << username
+  VLOG(2) << "ShowSigninScreenForCreds  for user " << user_id.GetUserEmail()
           << ", frame_state=" << frame_state();
 
-  test_user_ = username;
+  test_user_ = user_id.GetUserEmail();
   test_pass_ = password;
   test_expects_complete_login_ = true;
 
   // Submit login form for test if gaia is ready. If gaia is loading, login
   // will be attempted in HandleLoginWebuiReady after gaia is ready. Otherwise,
   // reload gaia then follow the loading case.
   if (frame_state() == GaiaScreenHandler::FRAME_STATE_LOADED) {
     SubmitLoginFormForTest();
   } else if (frame_state() != GaiaScreenHandler::FRAME_STATE_LOADING) {
     DCHECK(signin_screen_handler_);
@@ skipping 71 matching lines @@
   std::string active_network_path = network_state_informer_->network_path();
   if (gaia_silent_load_ &&
       (network_state_informer_->state() != NetworkStateInformer::ONLINE ||
        gaia_silent_load_network_ != active_network_path)) {
     // Network has changed. Force Gaia reload.
     gaia_silent_load_ = false;
     // Gaia page will be realoded, so focus isn't stolen anymore.
     focus_stolen_ = false;
   }
 
-  // Note that LoadAuthExtension clears |populated_email_|.
-  if (populated_email_.empty())
+  const user_manager::UserID populated_user_id = user_manager::UserID::FromUserEmail(populated_email_);
+
+  // Note that LoadAuthExtension clears |populated_user_id|.
+  if (populated_user_id.empty())
     Delegate()->LoadSigninWallpaper();
   else
-    Delegate()->LoadWallpaper(populated_email_);
+    Delegate()->LoadWallpaper(populated_user_id);
 
   input_method::InputMethodManager* imm =
       input_method::InputMethodManager::Get();
 
   scoped_refptr<input_method::InputMethodManager::State> gaia_ime_state =
       imm->GetActiveIMEState()->Clone();
   imm->SetState(gaia_ime_state);
 
   // Set Least Recently Used input method for the user.
-  if (!populated_email_.empty()) {
-    SigninScreenHandler::SetUserInputMethod(populated_email_,
+  if (!populated_user_id.empty()) {
+    SigninScreenHandler::SetUserInputMethod(populated_user_id,
                                             gaia_ime_state.get());
   } else {
     std::vector<std::string> input_methods =
         imm->GetInputMethodUtil()->GetHardwareLoginInputMethodIds();
     const std::string owner_im = SigninScreenHandler::GetUserLRUInputMethod(
-        user_manager::UserManager::Get()->GetOwnerEmail());
+        user_manager::UserManager::Get()->GetOwnerID());
     const std::string system_im = g_browser_process->local_state()->GetString(
         language_prefs::kPreferredKeyboardLayout);
 
     PushFrontIMIfNotExists(owner_im, &input_methods);
     PushFrontIMIfNotExists(system_im, &input_methods);
 
     gaia_ime_state->EnableLoginLayouts(
         g_browser_process->GetApplicationLocale(), input_methods);
 
     if (!system_im.empty()) {
@@ skipping 47 matching lines @@
   params.SetBoolean("enterpriseManaged",
                     g_browser_process->platform_part()
                         ->browser_policy_connector_chromeos()
                         ->IsEnterpriseManaged());
   CallJS("showWhitelistCheckFailedError", true, params);
 }
 
 void GaiaScreenHandler::LoadAuthExtension(bool force,
                                           bool silent_load,
                                           bool offline) {
+  const user_manager::UserID populated_user_id = user_manager::UserID::FromUserEmail(populated_email_);
+
   GaiaContext context;
   context.force_reload = force;
   context.is_local = offline;
-  context.password_changed = !populated_email_.empty() &&
-                             password_changed_for_.count(populated_email_);
+  context.password_changed = !populated_user_id.empty() &&
+                             password_changed_for_.count(populated_user_id);
   context.use_offline = offline;
-  context.email = populated_email_;
+  context.email = populated_user_id.GetUserEmail();
   context.is_enrolling_consumer_management = is_enrolling_consumer_management_;
 
   std::string gaia_id;
-  if (user_manager::UserManager::Get()->FindGaiaID(context.email, &gaia_id))
+  if (user_manager::UserManager::Get()->FindGaiaID(populated_user_id, &gaia_id))
     context.gaia_id = gaia_id;
 
   if (Delegate()) {
     context.show_users = Delegate()->IsShowUsers();
     context.has_users = !Delegate()->GetUsers().empty();
   }
 
   populated_email_.clear();
 
   LoadGaia(context);
 }
 
 void GaiaScreenHandler::UpdateState(NetworkError::ErrorReason reason) {
   if (signin_screen_handler_)
     signin_screen_handler_->UpdateState(reason);
 }
 
 SigninScreenHandlerDelegate* GaiaScreenHandler::Delegate() {
   DCHECK(signin_screen_handler_);
   return signin_screen_handler_->delegate_;
 }
 
 void GaiaScreenHandler::SetSigninScreenHandler(SigninScreenHandler* handler) {
   signin_screen_handler_ = handler;
 }
 
 }  // namespace chromeos