Revert of This CL replaces e-mail with AccountId on user selection screen.

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 856 matching lines @@
 
 void SigninScreenHandler::OnUserRemoved(const std::string& username,
                                         bool last_user_removed) {
   CallJS("login.AccountPickerScreen.removeUser", username);
   if (last_user_removed)
     OnShowAddUser();
 }
 
 void SigninScreenHandler::OnUserImageChanged(const user_manager::User& user) {
   if (page_is_ready())
-    CallJS("login.AccountPickerScreen.updateUserImage", user.GetAccountId());
+    CallJS("login.AccountPickerScreen.updateUserImage", user.email());
 }
 
 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 93 matching lines @@
   // Do not load the extension for the screen locker, see crosbug.com/25018.
   return !ScreenLocker::default_screen_locker() &&
          is_account_picker_showing_first_time_;
 }
 
 void SigninScreenHandler::UpdateAddButtonStatus() {
   CallJS("cr.ui.login.DisplayManager.updateAddUserButtonStatus",
          AllWhitelistedUsersPresent());
 }
 
-void SigninScreenHandler::HandleAuthenticateUser(const AccountId& account_id,
+void SigninScreenHandler::HandleAuthenticateUser(const std::string& username,
                                                  const std::string& password) {
   if (!delegate_)
     return;
-  DCHECK_EQ(account_id.GetUserEmail(),
-            gaia::SanitizeEmail(account_id.GetUserEmail()));
-
-  UserContext user_context(account_id);
+  UserContext user_context(
+      AccountId::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());
   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 AccountId& account_id,
+    const std::string& user_id,
     const std::string& locale,
     const std::string& input_method) {
   if (!delegate_)
     return;
 
-  UserContext context(user_manager::USER_TYPE_PUBLIC_ACCOUNT,
-                      account_id.GetUserEmail());
+  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_->set_populated_email(email);
   gaia_screen_handler_->LoadAuthExtension(true /* force */, true /* offline */);
   UpdateUIState(UI_STATE_GAIA_SIGNIN, nullptr);
 }
 
 void SigninScreenHandler::HandleShutdownSystem() {
   ash::Shell::GetInstance()->lock_state_controller()->RequestShutdown();
 }
 
-void SigninScreenHandler::HandleLoadWallpaper(const AccountId& account_id) {
+void SigninScreenHandler::HandleLoadWallpaper(const std::string& email) {
   if (delegate_)
-    delegate_->LoadWallpaper(account_id.GetUserEmail());
+    delegate_->LoadWallpaper(email);
 }
 
 void SigninScreenHandler::HandleRebootSystem() {
   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
 }
 
-void SigninScreenHandler::HandleRemoveUser(const AccountId& account_id) {
+void SigninScreenHandler::HandleRemoveUser(const std::string& email) {
   ProfileMetrics::LogProfileDeleteUser(
       ProfileMetrics::DELETE_PROFILE_USER_MANAGER);
 
   if (!delegate_)
     return;
-  delegate_->RemoveUser(account_id.GetUserEmail());
+  delegate_->RemoveUser(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.
@@ skipping 95 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 AccountId& account_id) {
-  if (account_id.is_valid()) {
-    RecordReauthReason(account_id, ReauthReason::PASSWORD_UPDATE_SKIPPED);
-  }
+    const std::string& user_id) {
+  if (!user_id.empty())
+    RecordReauthReason(AccountId::FromUserEmail(user_id),
+                       ReauthReason::PASSWORD_UPDATE_SKIPPED);
   gaia_screen_handler_->StartClearingCookies(
       base::Bind(&SigninScreenHandler::CancelPasswordChangedFlowInternal,
                  weak_factory_.GetWeakPtr()));
 }
 
 void SigninScreenHandler::HandleCancelUserAdding() {
   if (delegate_)
     delegate_->CancelUserAdding();
 }
 
@@ skipping 37 matching lines @@
 void SigninScreenHandler::HandleUnlockOnLoginSuccess() {
   DCHECK(user_manager::UserManager::Get()->IsUserLoggedIn());
   if (ScreenLocker::default_screen_locker())
     ScreenLocker::default_screen_locker()->UnlockOnLoginSuccess();
 }
 
 void SigninScreenHandler::HandleShowLoadingTimeoutError() {
   UpdateState(NetworkError::ERROR_REASON_LOADING_TIMEOUT);
 }
 
-void SigninScreenHandler::HandleFocusPod(const AccountId& account_id) {
-  SetUserInputMethod(account_id.GetUserEmail(), ime_state_.get());
-  WallpaperManager::Get()->SetUserWallpaperDelayed(account_id.GetUserEmail());
-  proximity_auth::ScreenlockBridge::Get()->SetFocusedUser(
-      account_id.GetUserEmail());
+void SigninScreenHandler::HandleFocusPod(const std::string& user_id) {
+  SetUserInputMethod(user_id, ime_state_.get());
+  WallpaperManager::Get()->SetUserWallpaperDelayed(user_id);
+  proximity_auth::ScreenlockBridge::Get()->SetFocusedUser(user_id);
   if (delegate_)
-    delegate_->CheckUserStatus(account_id);
+    delegate_->CheckUserStatus(user_id);
   if (!test_focus_pod_callback_.is_null())
     test_focus_pod_callback_.Run();
 
   bool use_24hour_clock = false;
   if (user_manager::UserManager::Get()->GetKnownUserBooleanPref(
-          account_id, prefs::kUse24HourClock, &use_24hour_clock)) {
+          AccountId::FromUserEmail(user_id), prefs::kUse24HourClock,
+          &use_24hour_clock)) {
     g_browser_process->platform_part()
         ->GetSystemClock()
         ->SetLastFocusedPodHourClockType(use_24hour_clock ? base::k24HourClock
                                                           : base::k12HourClock);
   }
 }
 
 void SigninScreenHandler::HandleGetPublicSessionKeyboardLayouts(
-    const AccountId& account_id,
+    const std::string& user_id,
     const std::string& locale) {
   GetKeyboardLayoutsForLocale(
       base::Bind(&SigninScreenHandler::SendPublicSessionKeyboardLayouts,
-                 weak_factory_.GetWeakPtr(), account_id, locale),
+                 weak_factory_.GetWeakPtr(),
+                 user_id,
+                 locale),
       locale);
 }
 
 void SigninScreenHandler::SendPublicSessionKeyboardLayouts(
-    const AccountId& account_id,
+    const std::string& user_id,
     const std::string& locale,
     scoped_ptr<base::ListValue> keyboard_layouts) {
   CallJS("login.AccountPickerScreen.setPublicSessionKeyboardLayouts",
-         account_id, locale, *keyboard_layouts);
+         user_id,
+         locale,
+         *keyboard_layouts);
 }
 
-void SigninScreenHandler::HandleLaunchKioskApp(const AccountId& app_account_id,
+void SigninScreenHandler::HandleLaunchKioskApp(const std::string& app_id,
                                                bool diagnostic_mode) {
-  UserContext context(user_manager::USER_TYPE_KIOSK_APP,
-                      app_account_id.GetUserEmail());
+  UserContext context(user_manager::USER_TYPE_KIOSK_APP, app_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 10 matching lines @@
            max_mode_delegate_->IsMaximizeModeEnabled());
   }
 }
 
 void SigninScreenHandler::HandleLogRemoveUserWarningShown() {
   ProfileMetrics::LogProfileDeleteUser(
       ProfileMetrics::DELETE_PROFILE_USER_MANAGER_SHOW_WARNING);
 }
 
 void SigninScreenHandler::HandleFirstIncorrectPasswordAttempt(
-    const AccountId& account_id) {
+    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 AccountId& account_id) {
-  RecordReauthReason(account_id, ReauthReason::INCORRECT_PASSWORD_ENTERED);
+    const std::string& email) {
+  RecordReauthReason(AccountId::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();
@@ skipping 78 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