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

chrome/browser/signin/easy_unlock_service_signin_chromeos.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_signin_chromeos.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 20 matching lines @@
 
 // Calculates the backoff interval that should be used next.
 // |backoff| The last backoff interval used.
 uint32 GetNextBackoffInterval(uint32 backoff) {
   if (backoff == 0u)
     return kInitialCryptohomeBackoffIntervalMs;
   return backoff * 2;
 }
 
 void LoadDataForUser(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     uint32 backoff_ms,
     const chromeos::EasyUnlockKeyManager::GetDeviceDataListCallback& callback);
 
 // Callback passed to |LoadDataForUser()|.
 // If |LoadDataForUser| function succeeded, it invokes |callback| with the
 // results.
 // If |LoadDataForUser| failed and further retries are allowed, schedules new
 // |LoadDataForUser| call with some backoff. If no further retires are allowed,
 // it invokes |callback| with the |LoadDataForUser| results.
 void RetryDataLoadOnError(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     uint32 backoff_ms,
     const chromeos::EasyUnlockKeyManager::GetDeviceDataListCallback& callback,
     bool success,
     const chromeos::EasyUnlockDeviceKeyDataList& data_list) {
   if (success) {
     callback.Run(success, data_list);
     return;
   }
 
   uint32 next_backoff_ms = GetNextBackoffInterval(backoff_ms);
   if (next_backoff_ms > kMaxCryptohomeBackoffIntervalMs) {
     callback.Run(false, data_list);
     return;
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&LoadDataForUser, user_id, next_backoff_ms, callback),
       base::TimeDelta::FromMilliseconds(next_backoff_ms));
 }
 
 // Loads device data list associated with the user's Easy unlock keys.
 void LoadDataForUser(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     uint32 backoff_ms,
     const chromeos::EasyUnlockKeyManager::GetDeviceDataListCallback& callback) {
   chromeos::EasyUnlockKeyManager* key_manager =
       chromeos::UserSessionManager::GetInstance()->GetEasyUnlockKeyManager();
   DCHECK(key_manager);
 
   key_manager->GetDeviceDataList(
       chromeos::UserContext(user_id),
       base::Bind(&RetryDataLoadOnError, user_id, backoff_ms, callback));
 }
 
 }  // namespace
 
 EasyUnlockServiceSignin::UserData::UserData()
     : state(EasyUnlockServiceSignin::USER_DATA_STATE_INITIAL) {
 }
 
 EasyUnlockServiceSignin::UserData::~UserData() {}
 
 EasyUnlockServiceSignin::EasyUnlockServiceSignin(Profile* profile)
     : EasyUnlockService(profile),
+      user_id_(std::string(), std::string()),
       allow_cryptohome_backoff_(true),
       service_active_(false),
       user_pod_last_focused_timestamp_(base::TimeTicks::Now()),
       weak_ptr_factory_(this) {
 }
 
 EasyUnlockServiceSignin::~EasyUnlockServiceSignin() {
 }
 
-void EasyUnlockServiceSignin::SetCurrentUser(const std::string& user_id) {
+void EasyUnlockServiceSignin::SetCurrentUser(const user_manager::UserID& user_id) {
   OnFocusedUserChanged(user_id);
 }
 
 EasyUnlockService::Type EasyUnlockServiceSignin::GetType() const {
   return EasyUnlockService::TYPE_SIGNIN;
 }
 
-std::string EasyUnlockServiceSignin::GetUserEmail() const {
+user_manager::UserID EasyUnlockServiceSignin::GetUserID() const {
   return user_id_;
 }
 
 void EasyUnlockServiceSignin::LaunchSetup() {
   NOTREACHED();
 }
 
 const base::DictionaryValue* EasyUnlockServiceSignin::GetPermitAccess() const {
   return NULL;
 }
@@ skipping 44 matching lines @@
 std::string EasyUnlockServiceSignin::GetWrappedSecret() const {
   const UserData* data = FindLoadedDataForCurrentUser();
   // TODO(xiyuan): Use correct remote device instead of hard coded first one.
   uint32 device_index = 0;
   if (!data || data->devices.size() <= device_index)
     return std::string();
   return data->devices[device_index].wrapped_secret;
 }
 
 void EasyUnlockServiceSignin::RecordEasySignInOutcome(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     bool success) const {
-  DCHECK_EQ(GetUserEmail(), user_id);
+  DCHECK(GetUserID() == user_id);
 
   RecordEasyUnlockSigninEvent(
       success ? EASY_UNLOCK_SUCCESS : EASY_UNLOCK_FAILURE);
   if (success) {
     RecordEasyUnlockSigninDuration(
         base::TimeTicks::Now() - user_pod_last_focused_timestamp_);
   }
   DVLOG(1) << "Easy sign-in " << (success ? "success" : "failure");
 }
 
 void EasyUnlockServiceSignin::RecordPasswordLoginEvent(
-    const std::string& user_id) const {
+    const user_manager::UserID& user_id) const {
   // This happens during tests, where a user could log in without the user pod
   // being focused.
-  if (GetUserEmail() != user_id)
+  if (GetUserID() != user_id)
     return;
 
   if (!IsEnabled())
     return;
 
   EasyUnlockAuthEvent event = GetPasswordAuthEvent();
   RecordEasyUnlockSigninEvent(event);
   DVLOG(1) << "Easy Sign-in password login event, event=" << event;
 }
 
@@ skipping 69 matching lines @@
   // in tests, the screen type might be different.
   if (screen_type !=
           proximity_auth::ScreenlockBridge::LockHandler::SIGNIN_SCREEN)
     return;
 
   DisableAppWithoutResettingScreenlockState();
 
   Shutdown();
 }
 
-void EasyUnlockServiceSignin::OnFocusedUserChanged(const std::string& user_id) {
+void EasyUnlockServiceSignin::OnFocusedUserChanged(const user_manager::UserID& user_id) {
   if (user_id_ == user_id)
     return;
 
   // Setting or clearing the user_id may changed |IsAllowed| value, so in these
   // cases update the app state. Otherwise, it's enough to notify the app the
   // user data has been updated.
   bool should_update_app_state = user_id_.empty() != user_id.empty();
   user_id_ = user_id;
   user_pod_last_focused_timestamp_ = base::TimeTicks::Now();
 
@@ skipping 25 matching lines @@
 }
 
 void EasyUnlockServiceSignin::LoadCurrentUserDataIfNeeded() {
   // TODO(xiyuan): Revisit this when adding tests.
   if (!base::SysInfo::IsRunningOnChromeOS())
     return;
 
   if (user_id_.empty() || !service_active_)
     return;
 
-  std::map<std::string, UserData*>::iterator it = user_data_.find(user_id_);
+  std::map<user_manager::UserID, UserData*>::iterator it = user_data_.find(user_id_);
   if (it == user_data_.end())
     user_data_.insert(std::make_pair(user_id_, new UserData()));
 
   UserData* data = user_data_[user_id_];
 
   if (data->state != USER_DATA_STATE_INITIAL)
     return;
   data->state = USER_DATA_STATE_LOADING;
 
   LoadDataForUser(
       user_id_,
       allow_cryptohome_backoff_ ? 0u : kMaxCryptohomeBackoffIntervalMs,
       base::Bind(&EasyUnlockServiceSignin::OnUserDataLoaded,
                  weak_ptr_factory_.GetWeakPtr(),
                  user_id_));
 }
 
 void EasyUnlockServiceSignin::OnUserDataLoaded(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     bool success,
     const chromeos::EasyUnlockDeviceKeyDataList& devices) {
   allow_cryptohome_backoff_ = false;
 
   UserData* data = user_data_[user_id];
   data->state = USER_DATA_STATE_LOADED;
   if (success) {
     data->devices = devices;
     chromeos::EasyUnlockKeyManager::DeviceDataListToRemoteDeviceList(
         user_id, devices, &data->remote_devices_value);
@@ skipping 15 matching lines @@
   // that it has to refresh it's user data.
   if (user_id == user_id_)
     NotifyUserUpdated();
 }
 
 const EasyUnlockServiceSignin::UserData*
     EasyUnlockServiceSignin::FindLoadedDataForCurrentUser() const {
   if (user_id_.empty())
     return NULL;
 
-  std::map<std::string, UserData*>::const_iterator it =
+  std::map<user_manager::UserID, UserData*>::const_iterator it =
       user_data_.find(user_id_);
   if (it == user_data_.end())
     return NULL;
   if (it->second->state != USER_DATA_STATE_LOADED)
     return NULL;
   return it->second;
 }