This CL replaces e-mail with AccountId in easy signin code.

chrome/browser/chromeos/login/auth/chrome_login_performer.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/auth/chrome_login_performer.h"
 
 #include "base/bind.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/easy_unlock/easy_unlock_user_login_flow.h"
@@ skipping 66 matching lines @@
   } else if (status == CrosSettingsProvider::TEMPORARILY_UNTRUSTED) {
     // Value of AllowNewUser setting is still not verified.
     // Another attempt will be invoked after verification completion.
     return;
   } else {
     DCHECK(status == CrosSettingsProvider::TRUSTED);
     callback.Run();
   }
 }
 
-bool ChromeLoginPerformer::IsUserWhitelisted(const std::string& user_id,
+bool ChromeLoginPerformer::IsUserWhitelisted(const AccountId& account_id,
                                              bool* wildcard_match) {
-  return CrosSettings::IsWhitelisted(user_id, wildcard_match);
+  return CrosSettings::IsWhitelisted(account_id.GetUserEmail(), wildcard_match);
 }
 
 void ChromeLoginPerformer::RunOnlineWhitelistCheck(
-    const std::string& user_id,
+    const AccountId& account_id,
     bool wildcard_match,
     const std::string& refresh_token,
     const base::Closure& success_callback,
     const base::Closure& failure_callback) {
   // On enterprise devices, reconfirm login permission with the server.
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   if (connector->IsEnterpriseManaged() && wildcard_match &&
-      !connector->IsNonEnterpriseUser(user_id)) {
+      !connector->IsNonEnterpriseUser(account_id.GetUserEmail())) {
     wildcard_login_checker_.reset(new policy::WildcardLoginChecker());
     if (refresh_token.empty()) {
       wildcard_login_checker_->StartWithSigninContext(
           GetSigninRequestContext(),
           base::Bind(&ChromeLoginPerformer::OnlineWildcardLoginCheckCompleted,
                      weak_factory_.GetWeakPtr(), success_callback,
                      failure_callback));
     } else {
       wildcard_login_checker_->StartWithRefreshToken(
           refresh_token,
@@ skipping 23 matching lines @@
          SupervisedUserAuthentication::SCHEMA_SALT_HASHED;
 }
 
 UserContext ChromeLoginPerformer::TransformSupervisedKey(
     const UserContext& context) {
   SupervisedUserAuthentication* authentication =
       ChromeUserManager::Get()->GetSupervisedUserManager()->GetAuthentication();
   return authentication->TransformKey(context);
 }
 
-void ChromeLoginPerformer::SetupSupervisedUserFlow(const std::string& user_id) {
-  SupervisedUserLoginFlow* new_flow = new SupervisedUserLoginFlow(user_id);
-  new_flow->SetHost(ChromeUserManager::Get()
-                        ->GetUserFlow(AccountId::FromUserEmail(user_id))
-                        ->host());
-  ChromeUserManager::Get()->SetUserFlow(AccountId::FromUserEmail(user_id),
-                                        new_flow);
+void ChromeLoginPerformer::SetupSupervisedUserFlow(
+    const AccountId& account_id) {
+  SupervisedUserLoginFlow* new_flow = new SupervisedUserLoginFlow(account_id);
+  new_flow->SetHost(ChromeUserManager::Get()->GetUserFlow(account_id)->host());
+  ChromeUserManager::Get()->SetUserFlow(account_id, new_flow);
 }
 
-void ChromeLoginPerformer::SetupEasyUnlockUserFlow(const std::string& user_id) {
-  ChromeUserManager::Get()->SetUserFlow(AccountId::FromUserEmail(user_id),
-                                        new EasyUnlockUserLoginFlow(user_id));
+void ChromeLoginPerformer::SetupEasyUnlockUserFlow(
+    const AccountId& account_id) {
+  ChromeUserManager::Get()->SetUserFlow(
+      account_id, new EasyUnlockUserLoginFlow(account_id));
 }
 
-bool ChromeLoginPerformer::CheckPolicyForUser(const std::string& user_id) {
+bool ChromeLoginPerformer::CheckPolicyForUser(const AccountId& account_id) {
   // Login is not allowed if policy could not be loaded for the account.
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   policy::DeviceLocalAccountPolicyService* policy_service =
       connector->GetDeviceLocalAccountPolicyService();
-  return policy_service && policy_service->IsPolicyAvailableForUser(user_id);
+  return policy_service &&
+         policy_service->IsPolicyAvailableForUser(account_id.GetUserEmail());
 }
 ////////////////////////////////////////////////////////////////////////////////
 // ChromeLoginPerformer, private:
 
 content::BrowserContext* ChromeLoginPerformer::GetSigninContext() {
   return ProfileHelper::GetSigninProfile();
 }
 
 net::URLRequestContextGetter* ChromeLoginPerformer::GetSigninRequestContext() {
   return login::GetSigninContext();
 }
 
 void ChromeLoginPerformer::OnlineWildcardLoginCheckCompleted(
     const base::Closure& success_callback,
     const base::Closure& failure_callback,
     policy::WildcardLoginChecker::Result result) {
   if (result == policy::WildcardLoginChecker::RESULT_ALLOWED) {
     success_callback.Run();
   } else {
     failure_callback.Run();
   }
 }
 
 }  // namespace chromeos