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

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/bind.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
@@ skipping 75 matching lines @@
       weak_ptr_factory_(this) {
 }
 
 EasyUnlockServiceRegular::~EasyUnlockServiceRegular() {
 }
 
 EasyUnlockService::Type EasyUnlockServiceRegular::GetType() const {
   return EasyUnlockService::TYPE_REGULAR;
 }
 
-std::string EasyUnlockServiceRegular::GetUserEmail() 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->GetAuthenticatedUsername();
-  return user_email.empty() ? user_email : gaia::CanonicalizeEmail(user_email);
+user_manager::UserID EasyUnlockServiceRegular::GetUserID() const {
+  return user_manager::UserID::FromUserEmail(GetUserEmail());
 }
 
 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(GetUserID(), 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 95 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 user_manager::UserID& user_id,
     bool success) const {
   NOTREACHED();
 }
 
 void EasyUnlockServiceRegular::RecordPasswordLoginEvent(
-    const std::string& user_id) const {
+    const user_manager::UserID& user_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 98 matching lines @@
     if (will_unlock_using_easy_unlock_) {
       RecordEasyUnlockScreenUnlockDuration(
           base::TimeTicks::Now() - lock_screen_last_shown_timestamp_);
     }
   }
 
   will_unlock_using_easy_unlock_ = false;
 }
 
 void EasyUnlockServiceRegular::OnFocusedUserChanged(
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
   // Nothing to do.
 }
 
+std::string EasyUnlockServiceRegular::GetUserEmail() 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->GetAuthenticatedUsername();
+  return user_email.empty() ? user_email : gaia::CanonicalizeEmail(user_email);
+}
+
 void EasyUnlockServiceRegular::OnPrefsChanged() {
   SyncProfilePrefsToLocalState();
   UpdateAppState();
 }
 
 void EasyUnlockServiceRegular::SetTurnOffFlowStatus(TurnOffFlowStatus status) {
   turn_off_flow_status_ = status;
   NotifyTurnOffOperationStatusChanged();
 }
 
@@ skipping 25 matching lines @@
       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());
 }