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

chrome/browser/signin/easy_unlock_screenlock_state_handler.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_screenlock_state_handler.h"
 
 #include "base/bind.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chromeos/chromeos_utils.h"
@@ skipping 82 matching lines @@
 
 // Returns true iff the |state| corresponds to a locked remote device.
 bool IsLockedState(ScreenlockState state) {
   return (state == ScreenlockState::PHONE_LOCKED ||
           state == ScreenlockState::PHONE_LOCKED_AND_TX_POWER_TOO_HIGH);
 }
 
 }  // namespace
 
 EasyUnlockScreenlockStateHandler::EasyUnlockScreenlockStateHandler(
-    const std::string& user_email,
+    const user_manager::UserID& user_id,
     HardlockState initial_hardlock_state,
     proximity_auth::ScreenlockBridge* screenlock_bridge)
     : state_(ScreenlockState::INACTIVE),
-      user_email_(user_email),
+      user_id_(user_id),
       screenlock_bridge_(screenlock_bridge),
       hardlock_state_(initial_hardlock_state),
       hardlock_ui_shown_(false),
       is_trial_run_(false),
       did_see_locked_phone_(false) {
   DCHECK(screenlock_bridge_);
   screenlock_bridge_->AddObserver(this);
 }
 
 EasyUnlockScreenlockStateHandler::~EasyUnlockScreenlockStateHandler() {
@@ skipping 19 matching lines @@
     return;
 
   state_ = new_state;
 
   // If lock screen is not active or it forces offline password, just cache the
   // current state. The screenlock state will get refreshed in |ScreenDidLock|.
   if (!screenlock_bridge_->IsLocked())
     return;
 
   // Do nothing when auth type is online.
-  if (screenlock_bridge_->lock_handler()->GetAuthType(user_email_) ==
+  if (screenlock_bridge_->lock_handler()->GetAuthType(user_id_) ==
       proximity_auth::ScreenlockBridge::LockHandler::ONLINE_SIGN_IN) {
     return;
   }
 
   if (IsLockedState(state_))
     did_see_locked_phone_ = true;
 
   // No hardlock UI for trial run.
   if (!is_trial_run_ && hardlock_state_ != NO_HARDLOCK) {
     ShowHardlockUI();
     return;
   }
 
   UpdateScreenlockAuthType();
 
   proximity_auth::ScreenlockBridge::UserPodCustomIcon icon =
       GetIconForState(state_);
 
   if (icon == proximity_auth::ScreenlockBridge::USER_POD_CUSTOM_ICON_NONE) {
-    screenlock_bridge_->lock_handler()->HideUserPodCustomIcon(user_email_);
+    screenlock_bridge_->lock_handler()->HideUserPodCustomIcon(user_id_);
     return;
   }
 
   proximity_auth::ScreenlockBridge::UserPodCustomIconOptions icon_options;
   icon_options.SetIcon(icon);
 
   // Don't hardlock on trial run.
   if (is_trial_run_)
     icon_options.SetTrialRun();
   else if (HardlockOnClick(state_))
     icon_options.SetHardlockOnClick();
 
   UpdateTooltipOptions(&icon_options);
 
   // For states without tooltips, we still need to set an accessibility label.
   if (state_ == ScreenlockState::BLUETOOTH_CONNECTING) {
     icon_options.SetAriaLabel(
         l10n_util::GetStringUTF16(IDS_SMART_LOCK_SPINNER_ACCESSIBILITY_LABEL));
   }
 
-  screenlock_bridge_->lock_handler()->ShowUserPodCustomIcon(user_email_,
+  screenlock_bridge_->lock_handler()->ShowUserPodCustomIcon(user_id_,
                                                             icon_options);
 }
 
 void EasyUnlockScreenlockStateHandler::SetHardlockState(
     HardlockState new_state) {
   if (hardlock_state_ == new_state)
     return;
 
   if (new_state == LOGIN_FAILED && hardlock_state_ != NO_HARDLOCK)
     return;
@@ skipping 42 matching lines @@
   is_trial_run_ = false;
 
   // Upon a successful unlock event, record whether the user's phone was locked
   // at any point while the lock screen was up.
   if (state_ == ScreenlockState::AUTHENTICATED)
     RecordEasyUnlockDidUserManuallyUnlockPhone(did_see_locked_phone_);
   did_see_locked_phone_ = false;
 }
 
 void EasyUnlockScreenlockStateHandler::OnFocusedUserChanged(
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
 }
 
 void EasyUnlockScreenlockStateHandler::RefreshScreenlockState() {
   ScreenlockState last_state = state_;
   // This should force updating screenlock state.
   state_ = ScreenlockState::INACTIVE;
   ChangeState(last_state);
 }
 
 void EasyUnlockScreenlockStateHandler::ShowHardlockUI() {
   DCHECK(hardlock_state_ != NO_HARDLOCK);
 
   if (!screenlock_bridge_->IsLocked())
     return;
 
   // Do not override online signin.
   const proximity_auth::ScreenlockBridge::LockHandler::AuthType
       existing_auth_type =
-          screenlock_bridge_->lock_handler()->GetAuthType(user_email_);
+          screenlock_bridge_->lock_handler()->GetAuthType(user_id_);
   if (existing_auth_type ==
       proximity_auth::ScreenlockBridge::LockHandler::ONLINE_SIGN_IN)
     return;
 
   if (existing_auth_type !=
       proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD) {
     screenlock_bridge_->lock_handler()->SetAuthType(
-        user_email_,
+        user_id_,
         proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
         base::string16());
   }
 
   if (hardlock_state_ == NO_PAIRING) {
-    screenlock_bridge_->lock_handler()->HideUserPodCustomIcon(user_email_);
+    screenlock_bridge_->lock_handler()->HideUserPodCustomIcon(user_id_);
     hardlock_ui_shown_ = false;
     return;
   }
 
   if (hardlock_ui_shown_)
     return;
 
   proximity_auth::ScreenlockBridge::UserPodCustomIconOptions icon_options;
   if (hardlock_state_ == LOGIN_FAILED) {
     icon_options.SetIcon(
@@ skipping 20 matching lines @@
         IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_HARDLOCK_PAIRING_ADDED, device_name,
         device_name);
   } else if (hardlock_state_ == LOGIN_FAILED) {
     tooltip = l10n_util::GetStringUTF16(
         IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_LOGIN_FAILURE);
   } else {
     LOG(ERROR) << "Unknown hardlock state " << hardlock_state_;
   }
   icon_options.SetTooltip(tooltip, true /* autoshow */);
 
-  screenlock_bridge_->lock_handler()->ShowUserPodCustomIcon(user_email_,
+  screenlock_bridge_->lock_handler()->ShowUserPodCustomIcon(user_id_,
                                                             icon_options);
   hardlock_ui_shown_ = true;
 }
 
 void EasyUnlockScreenlockStateHandler::UpdateTooltipOptions(
     proximity_auth::ScreenlockBridge::UserPodCustomIconOptions* icon_options) {
   size_t resource_id = 0;
   base::string16 device_name;
   if (is_trial_run_ && state_ == ScreenlockState::AUTHENTICATED) {
     resource_id = IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_INITIAL_AUTHENTICATED;
@@ skipping 30 matching lines @@
 #endif
 }
 
 void EasyUnlockScreenlockStateHandler::UpdateScreenlockAuthType() {
   if (!is_trial_run_ && hardlock_state_ != NO_HARDLOCK)
     return;
 
   // Do not override online signin.
   const proximity_auth::ScreenlockBridge::LockHandler::AuthType
       existing_auth_type =
-          screenlock_bridge_->lock_handler()->GetAuthType(user_email_);
+          screenlock_bridge_->lock_handler()->GetAuthType(user_id_);
   DCHECK_NE(proximity_auth::ScreenlockBridge::LockHandler::ONLINE_SIGN_IN,
             existing_auth_type);
 
   if (state_ == ScreenlockState::AUTHENTICATED) {
     if (existing_auth_type !=
         proximity_auth::ScreenlockBridge::LockHandler::USER_CLICK) {
       screenlock_bridge_->lock_handler()->SetAuthType(
-          user_email_,
+          user_id_,
           proximity_auth::ScreenlockBridge::LockHandler::USER_CLICK,
           l10n_util::GetStringUTF16(
               IDS_EASY_UNLOCK_SCREENLOCK_USER_POD_AUTH_VALUE));
     }
   } else if (existing_auth_type !=
              proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD) {
     screenlock_bridge_->lock_handler()->SetAuthType(
-        user_email_,
+        user_id_,
         proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
         base::string16());
   }
 }