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

chrome/browser/signin/easy_unlock_service_regular.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/signin/easy_unlock_service_regular.h"
 
 #include "base/base64url.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 81 matching lines @@
   return device_manager_.get();
 }
 
 proximity_auth::ProximityAuthPrefManager*
 EasyUnlockServiceRegular::GetProximityAuthPrefManager() {
   return pref_manager_.get();
 }
 
 void EasyUnlockServiceRegular::LoadRemoteDevices() {
   if (device_manager_->unlock_keys().empty()) {
-    SetProximityAuthDevices(GetUserEmail(), proximity_auth::RemoteDeviceList());
+    SetProximityAuthDevices(GetAccountId(), proximity_auth::RemoteDeviceList());
     return;
   }
 
   remote_device_loader_.reset(new proximity_auth::RemoteDeviceLoader(
       device_manager_->unlock_keys(), proximity_auth_client()->GetAccountId(),
       enrollment_manager_->GetUserPrivateKey(),
       proximity_auth_client()->CreateSecureMessageDelegate(),
       pref_manager_.get()));
   remote_device_loader_->Load(
       base::Bind(&EasyUnlockServiceRegular::OnRemoteDevicesLoaded,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void EasyUnlockServiceRegular::OnRemoteDevicesLoaded(
     const proximity_auth::RemoteDeviceList& remote_devices) {
-  SetProximityAuthDevices(GetUserEmail(), remote_devices);
+  SetProximityAuthDevices(GetAccountId(), remote_devices);
 
 #if defined(OS_CHROMEOS)
   // We need to store a copy of |remote devices_| in the TPM, so it can be
   // retrieved on the sign-in screen when a user session has not been started
   // yet.
   scoped_ptr<base::ListValue> device_list(new base::ListValue());
   for (const auto& device : remote_devices) {
     scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
     std::string b64_public_key, b64_psk;
     base::Base64UrlEncode(device.public_key,
@@ skipping 17 matching lines @@
 
   // TODO(tengs): Rename this function after the easy_unlock app is replaced.
   SetRemoteDevices(*device_list);
 #endif
 }
 
 EasyUnlockService::Type EasyUnlockServiceRegular::GetType() const {
   return EasyUnlockService::TYPE_REGULAR;
 }
 
-std::string EasyUnlockServiceRegular::GetUserEmail() const {
+AccountId EasyUnlockServiceRegular::GetAccountId() const {
   const SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfileIfExists(profile());
   // |profile| has to be a signed-in profile with SigninManager already
   // created. Otherwise, just crash to collect stack.
   DCHECK(signin_manager);
   const std::string user_email =
       signin_manager->GetAuthenticatedAccountInfo().email;
-  return user_email.empty() ? user_email : gaia::CanonicalizeEmail(user_email);
+  return user_email.empty()
+             ? EmptyAccountId()
+             : AccountId::FromUserEmail(gaia::CanonicalizeEmail(user_email));
 }
 
 void EasyUnlockServiceRegular::LaunchSetup() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 #if defined(OS_CHROMEOS)
   // Force the user to reauthenticate by showing a modal overlay (similar to the
   // lock screen). The password obtained from the reauth is cached for a short
   // period of time and used to create the cryptohome keys for sign-in.
   if (short_lived_user_context_ && short_lived_user_context_->user_context()) {
     OpenSetupApp();
@@ skipping 30 matching lines @@
         base::Bind(&EasyUnlockServiceRegular::SetHardlockAfterKeyOperation,
                    weak_ptr_factory_.GetWeakPtr(),
                    EasyUnlockScreenlockStateHandler::NO_PAIRING));
   }
 }
 
 void EasyUnlockServiceRegular::SetHardlockAfterKeyOperation(
     EasyUnlockScreenlockStateHandler::HardlockState state_on_success,
     bool success) {
   if (success)
-    SetHardlockStateForUser(GetUserEmail(), state_on_success);
+    SetHardlockStateForUser(GetAccountId(), state_on_success);
 
   // Even if the refresh keys operation suceeded, we still fetch and check the
   // cryptohome keys against the keys in local preferences as a sanity check.
   CheckCryptohomeKeysAndMaybeHardlock();
 }
 #endif
 
 const base::DictionaryValue* EasyUnlockServiceRegular::GetPermitAccess() const {
   const base::DictionaryValue* pairing_dict =
       profile()->GetPrefs()->GetDictionary(prefs::kEasyUnlockPairing);
@@ skipping 136 matching lines @@
 
 std::string EasyUnlockServiceRegular::GetChallenge() const {
   return std::string();
 }
 
 std::string EasyUnlockServiceRegular::GetWrappedSecret() const {
   return std::string();
 }
 
 void EasyUnlockServiceRegular::RecordEasySignInOutcome(
-    const std::string& user_id,
+    const AccountId& account_id,
     bool success) const {
   NOTREACHED();
 }
 
 void EasyUnlockServiceRegular::RecordPasswordLoginEvent(
-    const std::string& user_id) const {
+    const AccountId& account_id) const {
   NOTREACHED();
 }
 
 void EasyUnlockServiceRegular::StartAutoPairing(
     const AutoPairingResultCallback& callback) {
   if (!auto_pairing_callback_.is_null()) {
     LOG(ERROR)
         << "Start auto pairing when there is another auto pairing requested.";
     callback.Run(false, std::string());
     return;
@@ skipping 147 matching lines @@
   // If we synced remote devices while the screen was locked, we can now load
   // the new remote devices.
   if (deferring_device_load_) {
     PA_LOG(INFO) << "Loading deferred devices after screen unlock.";
     deferring_device_load_ = false;
     LoadRemoteDevices();
   }
 }
 
 void EasyUnlockServiceRegular::OnFocusedUserChanged(
-    const std::string& user_id) {
+    const AccountId& account_id) {
   // Nothing to do.
 }
 
 void EasyUnlockServiceRegular::OnPrefsChanged() {
   SyncProfilePrefsToLocalState();
   UpdateAppState();
 }
 
 void EasyUnlockServiceRegular::SetTurnOffFlowStatus(TurnOffFlowStatus status) {
   turn_off_flow_status_ = status;
@@ skipping 25 matching lines @@
   // Create the dictionary of Easy Unlock preferences for the current user. The
   // items in the dictionary are the same profile prefs used for Easy Unlock.
   scoped_ptr<base::DictionaryValue> user_prefs_dict(
       new base::DictionaryValue());
   user_prefs_dict->SetBooleanWithoutPathExpansion(
       prefs::kEasyUnlockProximityRequired,
       profile_prefs->GetBoolean(prefs::kEasyUnlockProximityRequired));
 
   DictionaryPrefUpdate update(local_state,
                               prefs::kEasyUnlockLocalStateUserPrefs);
-  std::string user_email = GetUserEmail();
-  update->SetWithoutPathExpansion(user_email, user_prefs_dict.Pass());
+  update->SetWithoutPathExpansion(GetAccountId().GetUserEmail(),
+                                  user_prefs_dict.Pass());
 }
 
 cryptauth::GcmDeviceInfo EasyUnlockServiceRegular::GetGcmDeviceInfo() {
   cryptauth::GcmDeviceInfo device_info;
   device_info.set_long_device_id(EasyUnlockService::GetDeviceId());
   device_info.set_device_type(cryptauth::CHROME);
   device_info.set_device_software_version(version_info::GetVersionNumber());
   google::protobuf::int64 software_version_code =
       proximity_auth::HashStringToInt64(version_info::GetLastChange());
   device_info.set_device_software_version_code(software_version_code);
@@ skipping 66 matching lines @@
     PA_LOG(INFO) << "Refresh token not yet available, "
                  << "waiting before starting CryptAuth managers";
     token_service->AddObserver(this);
   }
 
   device_manager_->AddObserver(this);
   enrollment_manager_->Start();
   device_manager_->Start();
 }
 #endif