Revert of This CL replaces user_manager::UserID with AccountId.

chrome/browser/chromeos/login/screens/user_selection_screen.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/screens/user_selection_screen.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
 #include "chrome/browser/chromeos/login/reauth_stats.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/ui/views/user_board_view.h"
 #include "chrome/browser/chromeos/login/users/chrome_user_manager.h"
 #include "chrome/browser/chromeos/login/users/multi_profile_user_controller.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/signin/easy_unlock_service.h"
 #include "chrome/browser/ui/webui/chromeos/login/l10n_util.h"
 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
 #include "components/proximity_auth/screenlock_bridge.h"
-#include "components/signin/core/account_id/account_id.h"
+#include "components/user_manager/user_id.h"
 #include "components/user_manager/user_manager.h"
 #include "components/user_manager/user_type.h"
 #include "ui/base/user_activity/user_activity_detector.h"
 
 namespace chromeos {
 
 namespace {
 
 // User dictionary keys.
 const char kKeyUsername[] = "username";
@@ skipping 99 matching lines @@
 }
 
 // static
 void UserSelectionScreen::FillUserDictionary(
     user_manager::User* user,
     bool is_owner,
     bool is_signin_to_add,
     AuthType auth_type,
     const std::vector<std::string>* public_session_recommended_locales,
     base::DictionaryValue* user_dict) {
+  const user_manager::UserID user_id = user->email();
   const bool is_public_session =
       user->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT;
   const bool is_legacy_supervised_user =
       user->GetType() == user_manager::USER_TYPE_SUPERVISED;
   const bool is_child_user = user->GetType() == user_manager::USER_TYPE_CHILD;
 
-  user_dict->SetString(kKeyUsername, user->GetAccountId().GetUserEmail());
+  user_dict->SetString(kKeyUsername, user_id);
   user_dict->SetString(kKeyEmailAddress, user->display_email());
   user_dict->SetString(kKeyDisplayName, user->GetDisplayName());
   user_dict->SetBoolean(kKeyPublicAccount, is_public_session);
   user_dict->SetBoolean(kKeyLegacySupervisedUser, is_legacy_supervised_user);
   user_dict->SetBoolean(kKeyChildUser, is_child_user);
   user_dict->SetBoolean(kKeyDesktopUser, false);
   user_dict->SetInteger(kKeyInitialAuthType, auth_type);
   user_dict->SetBoolean(kKeySignedIn, user->is_logged_in());
   user_dict->SetBoolean(kKeyIsOwner, is_owner);
 
   FillMultiProfileUserPrefs(user, user_dict, is_signin_to_add);
   FillKnownUserPrefs(user, user_dict);
 
   if (is_public_session) {
     AddPublicSessionDetailsToUserDictionaryEntry(
         user_dict, public_session_recommended_locales);
   }
 }
 
 // static
 void UserSelectionScreen::FillKnownUserPrefs(user_manager::User* user,
                                              base::DictionaryValue* user_dict) {
   std::string gaia_id;
-  if (user_manager::UserManager::Get()->FindGaiaID(user->GetAccountId(),
-                                                   &gaia_id)) {
+  if (user_manager::UserManager::Get()->FindGaiaID(user->email(), &gaia_id)) {
     user_dict->SetString(kKeyGaiaID, gaia_id);
   }
 }
 
 // static
 void UserSelectionScreen::FillMultiProfileUserPrefs(
     user_manager::User* user,
     base::DictionaryValue* user_dict,
     bool is_signin_to_add) {
   const std::string& user_id = user->email();
@@ skipping 45 matching lines @@
       token_status == user_manager::User::OAUTH_TOKEN_STATUS_UNKNOWN) {
     return false;
   }
 
   if (is_public_session)
     return false;
 
   // At this point the reason for invalid token should be already set. If not,
   // this might be a leftover from an old version.
   if (token_status == user_manager::User::OAUTH2_TOKEN_STATUS_INVALID)
-    RecordReauthReason(user->GetAccountId(), ReauthReason::OTHER);
+    RecordReauthReason(user->email(), ReauthReason::OTHER);
 
   return user->force_online_signin() ||
          (token_status == user_manager::User::OAUTH2_TOKEN_STATUS_INVALID) ||
          (token_status == user_manager::User::OAUTH_TOKEN_STATUS_UNKNOWN);
 }
 
 void UserSelectionScreen::SetHandler(LoginDisplayWebUIHandler* handler) {
   handler_ = handler;
 }
 
@@ skipping 144 matching lines @@
     users_list.Append(user_dict);
   }
 
   handler_->LoadUsers(users_list, show_guest_);
 }
 
 void UserSelectionScreen::HandleGetUsers() {
   SendUserList();
 }
 
-void UserSelectionScreen::CheckUserStatus(const std::string& user_email) {
+void UserSelectionScreen::CheckUserStatus(const std::string& user_id) {
   // No checks on lock screen.
   if (ScreenLocker::default_screen_locker())
     return;
 
   if (!token_handle_util_.get()) {
     token_handle_util_.reset(
         new TokenHandleUtil(user_manager::UserManager::Get()));
   }
 
-  const AccountId account_id = AccountId::FromUserEmail(user_email);
-  if (token_handle_util_->HasToken(account_id)) {
+  if (token_handle_util_->HasToken(user_id)) {
     token_handle_util_->CheckToken(
-        account_id, base::Bind(&UserSelectionScreen::OnUserStatusChecked,
-                               weak_factory_.GetWeakPtr()));
+        user_id, base::Bind(&UserSelectionScreen::OnUserStatusChecked,
+                            weak_factory_.GetWeakPtr()));
   }
 }
 
 void UserSelectionScreen::OnUserStatusChecked(
-    const AccountId& account_id,
+    const user_manager::UserID& user_id,
     TokenHandleUtil::TokenHandleStatus status) {
   if (status == TokenHandleUtil::INVALID) {
-    RecordReauthReason(account_id, ReauthReason::INVALID_TOKEN_HANDLE);
-    token_handle_util_->MarkHandleInvalid(account_id);
-    SetAuthType(account_id.GetUserEmail(), ONLINE_SIGN_IN, base::string16());
+    RecordReauthReason(user_id, ReauthReason::INVALID_TOKEN_HANDLE);
+    token_handle_util_->MarkHandleInvalid(user_id);
+    SetAuthType(user_id, ONLINE_SIGN_IN, base::string16());
   }
 }
 
 // EasyUnlock stuff
 
 void UserSelectionScreen::SetAuthType(const std::string& user_id,
                                       AuthType auth_type,
                                       const base::string16& initial_value) {
   if (GetAuthType(user_id) == FORCE_OFFLINE_PASSWORD)
     return;
@@ skipping 50 matching lines @@
 void UserSelectionScreen::Unlock(const std::string& user_email) {
   DCHECK_EQ(GetScreenType(), LOCK_SCREEN);
   ScreenLocker::Hide();
 }
 
 void UserSelectionScreen::AttemptEasySignin(const std::string& user_id,
                                             const std::string& secret,
                                             const std::string& key_label) {
   DCHECK_EQ(GetScreenType(), SIGNIN_SCREEN);
 
-  UserContext user_context(AccountId::FromUserEmail(user_id));
+  UserContext user_context(user_id);
   user_context.SetAuthFlow(UserContext::AUTH_FLOW_EASY_UNLOCK);
   user_context.SetKey(Key(secret));
   user_context.GetKey()->SetLabel(key_label);
 
   login_display_delegate_->Login(user_context, SigninSpecifics());
 }
 
 void UserSelectionScreen::HardLockPod(const std::string& user_id) {
   view_->SetAuthType(user_id, OFFLINE_PASSWORD, base::string16());
   EasyUnlockService* service = GetEasyUnlockServiceForUser(user_id);
@@ skipping 37 matching lines @@
   // The user profile should exist if and only if this is the lock screen.
   DCHECK_EQ(!!profile, GetScreenType() == LOCK_SCREEN);
 
   if (!profile)
     profile = profile_helper->GetSigninProfile();
 
   return EasyUnlockService::Get(profile);
 }
 
 }  // namespace chromeos