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

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

 // Copyright (c) 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/signin_screen_handler.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/shell.h"
@@ skipping 159 matching lines @@
 // Returns network name by service path.
 std::string GetNetworkName(const std::string& service_path) {
   const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
       GetNetworkState(service_path);
   if (!network)
     return std::string();
   return network->name();
 }
 
 static bool SetUserInputMethodImpl(
-    const std::string& username,
+    const user_manager::UserID& user_id,
     const std::string& user_input_method,
     input_method::InputMethodManager::State* ime_state) {
   if (!chromeos::input_method::InputMethodManager::Get()->IsLoginKeyboard(
           user_input_method)) {
-    LOG(WARNING) << "SetUserInputMethod('" << username
+    LOG(WARNING) << "SetUserInputMethod('" << user_id.GetUserEmail()
                  << "'): stored user LRU input method '" << user_input_method
                  << "' is no longer Full Latin Keyboard Language"
                  << " (entry dropped). Use hardware default instead.";
 
     PrefService* const local_state = g_browser_process->local_state();
     DictionaryPrefUpdate updater(local_state, prefs::kUsersLRUInputMethod);
 
     base::DictionaryValue* const users_lru_input_methods = updater.Get();
     if (users_lru_input_methods != NULL) {
-      users_lru_input_methods->SetStringWithoutPathExpansion(username, "");
+      users_lru_input_methods->SetStringWithoutPathExpansion(user_id.GetUserEmail(), "");
     }
     return false;
   }
 
   if (!Contains(ime_state->GetActiveInputMethodIds(), user_input_method)) {
     if (!ime_state->EnableInputMethod(user_input_method)) {
-      DLOG(ERROR) << "SigninScreenHandler::SetUserInputMethod('" << username
+      DLOG(ERROR) << "SigninScreenHandler::SetUserInputMethod('" << user_id.GetUserEmail()
                   << "'): user input method '" << user_input_method
                   << "' is not enabled and enabling failed (ignored!).";
     }
   }
   ime_state->ChangeInputMethod(user_input_method, false /* show_message */);
 
   return true;
 }
 
 }  // namespace
@@ skipping 77 matching lines @@
     keyboard->RemoveObserver(this);
   weak_factory_.InvalidateWeakPtrs();
   if (delegate_)
     delegate_->SetWebUIHandler(NULL);
   network_state_informer_->RemoveObserver(this);
   if (max_mode_delegate_) {
     max_mode_delegate_->RemoveObserver(this);
     max_mode_delegate_.reset(NULL);
   }
   GetScreenlockBridgeInstance()->SetLockHandler(NULL);
-  GetScreenlockBridgeInstance()->SetFocusedUser("");
+  GetScreenlockBridgeInstance()->SetFocusedUser(user_manager::UserID(std::string(), std::string()));
 }
 
 // static
 std::string SigninScreenHandler::GetUserLRUInputMethod(
-    const std::string& username) {
+    const user_manager::UserID& user_id) {
   PrefService* const local_state = g_browser_process->local_state();
   const base::DictionaryValue* users_lru_input_methods =
       local_state->GetDictionary(prefs::kUsersLRUInputMethod);
 
   if (!users_lru_input_methods) {
-    DLOG(WARNING) << "GetUserLRUInputMethod('" << username
+    DLOG(WARNING) << "GetUserLRUInputMethod('" << user_id.GetUserEmail()
                   << "'): no kUsersLRUInputMethod";
     return std::string();
   }
 
   std::string input_method;
 
-  if (!users_lru_input_methods->GetStringWithoutPathExpansion(username,
+  if (!users_lru_input_methods->GetStringWithoutPathExpansion(user_id.GetUserEmail(),
                                                               &input_method)) {
-    DVLOG(0) << "GetUserLRUInputMethod('" << username
+    DVLOG(0) << "GetUserLRUInputMethod('" << user_id.GetUserEmail()
              << "'): no input method for this user";
     return std::string();
   }
 
   return input_method;
 }
 
 // static
 // Update keyboard layout to least recently used by the user.
 void SigninScreenHandler::SetUserInputMethod(
-    const std::string& username,
+    const user_manager::UserID& user_id,
     input_method::InputMethodManager::State* ime_state) {
   bool succeed = false;
 
-  const std::string input_method = GetUserLRUInputMethod(username);
+  const std::string input_method = GetUserLRUInputMethod(user_id);
 
   if (!input_method.empty())
-    succeed = SetUserInputMethodImpl(username, input_method, ime_state);
+    succeed = SetUserInputMethodImpl(user_id, input_method, ime_state);
 
   // This is also a case when LRU layout is set only for a few local users,
   // thus others need to be switched to default locale.
   // Otherwise they will end up using another user's locale to log in.
   if (!succeed) {
-    DVLOG(0) << "SetUserInputMethod('" << username
+    DVLOG(0) << "SetUserInputMethod('" << user_id.GetUserEmail()
              << "'): failed to set user layout. Switching to default.";
 
     ime_state->SetInputMethodLoginDefault();
   }
 }
 
 void SigninScreenHandler::DeclareLocalizedValues(
     ::login::LocalizedValuesBuilder* builder) {
   builder->Add("passwordHint", IDS_LOGIN_POD_EMPTY_PASSWORD_TEXT);
   builder->Add("signingIn", IDS_LOGIN_POD_SIGNING_IN);
@@ skipping 524 matching lines @@
 }
 
 void SigninScreenHandler::ClearUserPodPassword() {
   core_oobe_actor_->ClearUserPodPassword();
 }
 
 void SigninScreenHandler::RefocusCurrentPod() {
   core_oobe_actor_->RefocusCurrentPod();
 }
 
-void SigninScreenHandler::OnUserRemoved(const std::string& username) {
-  CallJS("login.AccountPickerScreen.removeUser", username);
+void SigninScreenHandler::OnUserRemoved(const user_manager::UserID& user_id) {
+  CallJS("login.AccountPickerScreen.removeUser", user_id.GetUserEmail());
   if (delegate_->GetUsers().empty())
     OnShowAddUser();
 }
 
 void SigninScreenHandler::OnUserImageChanged(const user_manager::User& user) {
   if (page_is_ready())
-    CallJS("login.AccountPickerScreen.updateUserImage", user.email());
+    CallJS("login.AccountPickerScreen.updateUserImage", user.GetUserID().GetUserEmail());
 }
 
 void SigninScreenHandler::OnPreferencesChanged() {
   // Make sure that one of the login UI is fully functional now, otherwise
   // preferences update would be picked up next time it will be shown.
   if (!webui_visible_) {
     LOG(WARNING) << "Login UI is not active - postponed prefs change.";
     preferences_changed_delayed_ = true;
     return;
   }
@@ skipping 24 matching lines @@
   switch (error_id) {
     case LoginDisplay::TPM_ERROR:
       core_oobe_actor_->ShowTpmError();
       break;
     default:
       NOTREACHED() << "Unknown sign in error";
       break;
   }
 }
 
-void SigninScreenHandler::ShowSigninUI(const std::string& email) {
-  core_oobe_actor_->ShowSignInUI(email);
+void SigninScreenHandler::ShowSigninUI(const user_manager::UserID& user_id) {
+  core_oobe_actor_->ShowSignInUI(user_id);
 }
 
-void SigninScreenHandler::ShowGaiaPasswordChanged(const std::string& username) {
-  gaia_screen_handler_->PasswordChangedFor(username);
-  gaia_screen_handler_->PopulateEmail(username);
-  core_oobe_actor_->ShowSignInUI(username);
-  CallJS("login.setAuthType", username,
+void SigninScreenHandler::ShowGaiaPasswordChanged(const user_manager::UserID& user_id) {
+  gaia_screen_handler_->PasswordChangedFor(user_id);
+  gaia_screen_handler_->PopulateEmail(user_id.GetUserEmail());
+  core_oobe_actor_->ShowSignInUI(user_id);
+  CallJS("login.setAuthType", user_id.GetUserEmail(),
          static_cast<int>(UserSelectionScreen::ONLINE_SIGN_IN),
          base::StringValue(""));
 }
 
 void SigninScreenHandler::ShowPasswordChangedDialog(bool show_password_error,
-                                                    const std::string& email) {
-  core_oobe_actor_->ShowPasswordChangedScreen(show_password_error, email);
+                                                    const user_manager::UserID& user_id) {
+  core_oobe_actor_->ShowPasswordChangedScreen(show_password_error, user_id);
 }
 
 void SigninScreenHandler::ShowSigninScreenForCreds(
-    const std::string& username,
+    const user_manager::UserID& user_id,
     const std::string& password) {
   DCHECK(gaia_screen_handler_);
-  gaia_screen_handler_->ShowSigninScreenForCreds(username, password);
+  gaia_screen_handler_->ShowSigninScreenForCreds(user_id, password);
 }
 
 void SigninScreenHandler::ShowWhitelistCheckFailedError() {
   DCHECK(gaia_screen_handler_);
   gaia_screen_handler_->ShowWhitelistCheckFailedError();
 }
 
 void SigninScreenHandler::Observe(int type,
                                   const content::NotificationSource& source,
                                   const content::NotificationDetails& details) {
@@ skipping 47 matching lines @@
 
 void SigninScreenHandler::UpdateAddButtonStatus() {
   CallJS("cr.ui.login.DisplayManager.updateAddUserButtonStatus",
          AllWhitelistedUsersPresent());
 }
 
 void SigninScreenHandler::HandleAuthenticateUser(const std::string& username,
                                                  const std::string& password) {
   if (!delegate_)
     return;
-  UserContext user_context(gaia::SanitizeEmail(username));
+  UserContext user_context(user_manager::UserID::FromUserEmail(gaia::SanitizeEmail(username)));
   user_context.SetKey(Key(password));
   delegate_->Login(user_context, SigninSpecifics());
 }
 
 void SigninScreenHandler::HandleLaunchIncognito() {
-  UserContext context(user_manager::USER_TYPE_GUEST, std::string());
+  UserContext context(user_manager::USER_TYPE_GUEST, user_manager::UserID(std::string(), std::string()));
   if (delegate_)
     delegate_->Login(context, SigninSpecifics());
 }
 
 void SigninScreenHandler::HandleShowSupervisedUserCreationScreen() {
   if (!user_manager::UserManager::Get()->AreSupervisedUsersAllowed()) {
     LOG(ERROR) << "Managed users not allowed.";
     return;
   }
   LoginDisplayHostImpl::default_host()->
       StartWizard(WizardController::kSupervisedUserCreationScreenName);
 }
 
 void SigninScreenHandler::HandleLaunchPublicSession(
-    const std::string& user_id,
+    const std::string& user_id_str,
     const std::string& locale,
     const std::string& input_method) {
   if (!delegate_)
     return;
 
+  const user_manager::UserID user_id(user_manager::UserID::FromUserEmail(user_id_str));
+
   UserContext context(user_manager::USER_TYPE_PUBLIC_ACCOUNT, user_id);
   context.SetPublicSessionLocale(locale),
   context.SetPublicSessionInputMethod(input_method);
   delegate_->Login(context, SigninSpecifics());
 }
 
 void SigninScreenHandler::HandleOfflineLogin(const base::ListValue* args) {
   if (!delegate_ || delegate_->IsShowUsers()) {
     NOTREACHED();
     return;
   }
   std::string email;
   args->GetString(0, &email);
 
   gaia_screen_handler_->PopulateEmail(email);
   // Load auth extension. Parameters are: force reload, do not load extension in
   // background, use offline version.
   gaia_screen_handler_->LoadAuthExtension(true, false, true);
   UpdateUIState(UI_STATE_GAIA_SIGNIN, NULL);
 }
 
 void SigninScreenHandler::HandleShutdownSystem() {
   ash::Shell::GetInstance()->lock_state_controller()->RequestShutdown();
 }
 
 void SigninScreenHandler::HandleLoadWallpaper(const std::string& email) {
   if (delegate_)
-    delegate_->LoadWallpaper(email);
+    delegate_->LoadWallpaper(user_manager::UserID::FromUserEmail(email));
 }
 
 void SigninScreenHandler::HandleRebootSystem() {
   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
 }
 
 void SigninScreenHandler::HandleRemoveUser(const std::string& email) {
   if (!delegate_)
     return;
-  delegate_->RemoveUser(email);
+  delegate_->RemoveUser(user_manager::UserID::FromUserEmail(email));
   UpdateAddButtonStatus();
 }
 
 void SigninScreenHandler::HandleShowAddUser(const base::ListValue* args) {
   TRACE_EVENT_ASYNC_STEP_INTO0("ui",
                                "ShowLoginWebUI",
                                LoginDisplayHostImpl::kShowLoginWebUIid,
                                "ShowAddUser");
   std::string email;
   // |args| can be null if it's OOBE.
   if (args)
     args->GetString(0, &email);
   gaia_screen_handler_->PopulateEmail(email);
   if (!email.empty())
-    SendReauthReason(email);
+    SendReauthReason(user_manager::UserID::FromUserEmail(email));
   OnShowAddUser();
 }
 
 void SigninScreenHandler::HandleToggleEnrollmentScreen() {
   if (delegate_)
     delegate_->ShowEnterpriseEnrollmentScreen();
 }
 
 void SigninScreenHandler::HandleToggleEnableDebuggingScreen() {
   if (delegate_)
@@ skipping 85 matching lines @@
         content::NotificationService::NoDetails());
     TRACE_EVENT_ASYNC_END0(
         "ui", "ShowLoginWebUI", LoginDisplayHostImpl::kShowLoginWebUIid);
   }
   webui_visible_ = true;
   if (preferences_changed_delayed_)
     OnPreferencesChanged();
 }
 
 void SigninScreenHandler::HandleCancelPasswordChangedFlow(
-    const std::string& user_id) {
-  if (!user_id.empty())
-    RecordReauthReason(user_id, ReauthReason::PASSWORD_UPDATE_SKIPPED);
+    const std::string& user_id_str) {
+  if (!user_id_str.empty())
+    RecordReauthReason(user_manager::UserID::FromUserEmail(user_id_str), ReauthReason::PASSWORD_UPDATE_SKIPPED);
   gaia_screen_handler_->StartClearingCookies(
       base::Bind(&SigninScreenHandler::CancelPasswordChangedFlowInternal,
                  weak_factory_.GetWeakPtr()));
 }
 
 void SigninScreenHandler::HandleCancelUserAdding() {
   if (delegate_)
     delegate_->CancelUserAdding();
 }
 
@@ skipping 41 matching lines @@
 }
 
 void SigninScreenHandler::HandleShowLoadingTimeoutError() {
   UpdateState(NetworkError::ERROR_REASON_LOADING_TIMEOUT);
 }
 
 void SigninScreenHandler::HandleUpdateOfflineLogin(bool offline_login_active) {
   offline_login_active_ = offline_login_active;
 }
 
-void SigninScreenHandler::HandleFocusPod(const std::string& user_id) {
+void SigninScreenHandler::HandleFocusPod(const std::string& user_id_str) {
+  const user_manager::UserID user_id(user_manager::UserID::FromUserEmail(user_id_str));
   SetUserInputMethod(user_id, ime_state_.get());
   WallpaperManager::Get()->SetUserWallpaperDelayed(user_id);
   GetScreenlockBridgeInstance()->SetFocusedUser(user_id);
   if (delegate_)
     delegate_->CheckUserStatus(user_id);
   if (!test_focus_pod_callback_.is_null())
     test_focus_pod_callback_.Run();
 }
 
 void SigninScreenHandler::HandleGetPublicSessionKeyboardLayouts(
-    const std::string& user_id,
+    const std::string& user_id_str,
     const std::string& locale) {
   GetKeyboardLayoutsForLocale(
       base::Bind(&SigninScreenHandler::SendPublicSessionKeyboardLayouts,
                  weak_factory_.GetWeakPtr(),
-                 user_id,
+                 user_manager::UserID::FromUserEmail(user_id_str),
                  locale),
       locale);
 }
 
 void SigninScreenHandler::SendPublicSessionKeyboardLayouts(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const std::string& locale,
     scoped_ptr<base::ListValue> keyboard_layouts) {
   CallJS("login.AccountPickerScreen.setPublicSessionKeyboardLayouts",
-         user_id,
+         user_id.GetUserEmail(),
          locale,
          *keyboard_layouts);
 }
 
 void SigninScreenHandler::HandleLaunchKioskApp(const std::string& app_id,
                                                bool diagnostic_mode) {
-  UserContext context(user_manager::USER_TYPE_KIOSK_APP, app_id);
+  const user_manager::UserID app_user_id(user_manager::UserID::FromUserEmail(app_id));
+  UserContext context(user_manager::USER_TYPE_KIOSK_APP, app_user_id);
   SigninSpecifics specifics;
   specifics.kiosk_diagnostic_mode = diagnostic_mode;
   if (delegate_)
     delegate_->Login(context, specifics);
 }
 
 void SigninScreenHandler::HandleCancelConsumerManagementEnrollment() {
   policy::ConsumerManagementService* consumer_management =
       g_browser_process->platform_part()->browser_policy_connector_chromeos()->
           GetConsumerManagementService();
@@ skipping 20 matching lines @@
     const std::string& email) {
   // TODO(ginkage): Fix this case once crbug.com/469987 is ready.
   /*
     if (user_manager::UserManager::Get()->FindUsingSAML(email))
       RecordReauthReason(email, ReauthReason::INCORRECT_SAML_PASSWORD_ENTERED);
   */
 }
 
 void SigninScreenHandler::HandleMaxIncorrectPasswordAttempts(
     const std::string& email) {
-  RecordReauthReason(email, ReauthReason::INCORRECT_PASSWORD_ENTERED);
+  RecordReauthReason(user_manager::UserID::FromUserEmail(email), ReauthReason::INCORRECT_PASSWORD_ENTERED);
 }
 
 bool SigninScreenHandler::AllWhitelistedUsersPresent() {
   CrosSettings* cros_settings = CrosSettings::Get();
   bool allow_new_user = false;
   cros_settings->GetBoolean(kAccountsPrefAllowNewUser, &allow_new_user);
   if (allow_new_user)
     return false;
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
   const user_manager::UserList& users = user_manager->GetUsers();
   if (!delegate_ || users.size() > kMaxUsers) {
     return false;
   }
   const base::ListValue* whitelist = NULL;
   if (!cros_settings->GetList(kAccountsPrefUsers, &whitelist) || !whitelist)
     return false;
   for (size_t i = 0; i < whitelist->GetSize(); ++i) {
     std::string whitelisted_user;
     // NB: Wildcards in the whitelist are also detected as not present here.
     if (!whitelist->GetString(i, &whitelisted_user) ||
-        !user_manager->IsKnownUser(whitelisted_user)) {
+        !user_manager->IsKnownUser(user_manager::UserID::FromUserEmail(whitelisted_user))) {
       return false;
     }
   }
   return true;
 }
 
 void SigninScreenHandler::CancelPasswordChangedFlowInternal() {
   if (delegate_) {
     ShowImpl();
     delegate_->CancelPasswordChangedFlow();
@@ skipping 58 matching lines @@
   return gaia_screen_handler_->frame_error();
 }
 
 void SigninScreenHandler::OnCapsLockChanged(bool enabled) {
   caps_lock_enabled_ = enabled;
   if (page_is_ready())
     CallJS("login.AccountPickerScreen.setCapsLockState", caps_lock_enabled_);
 }
 
 }  // namespace chromeos