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

chromeos/login/auth/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 "chromeos/login/auth/login_performer.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 88 matching lines @@
 void LoginPerformer::OnPasswordChangeDetected() {
   password_changed_ = true;
   password_changed_callback_count_++;
   if (delegate_) {
     delegate_->OnPasswordChangeDetected();
   } else {
     NOTREACHED();
   }
 }
 
-void LoginPerformer::OnChecked(const std::string& user_id, bool success) {
+void LoginPerformer::OnChecked(const user_manager::UserID& user_id, bool success) {
   if (!delegate_) {
     // Delegate is reset in case of successful offline login.
     // See ExistingUserConstoller::OnAuthSuccess().
     // Case when user has changed password and enters old password
     // does not block user from sign in yet.
     return;
   }
   delegate_->OnOnlineChecked(user_id, success);
 }
 
@@ skipping 16 matching lines @@
                                  weak_factory_.GetWeakPtr(),
                                  user_context_,
                                  auth_mode))) {
     return;
   }
   DoPerformLogin(user_context_, auth_mode);
 }
 
 void LoginPerformer::DoPerformLogin(const UserContext& user_context,
                                     AuthorizationMode auth_mode) {
-  std::string email = gaia::CanonicalizeEmail(user_context.GetUserID());
   bool wildcard_match = false;
 
-  if (!IsUserWhitelisted(email, &wildcard_match)) {
+  if (!IsUserWhitelisted(user_context.GetUserID(), &wildcard_match)) {
     NotifyWhitelistCheckFailure();
     return;
   }
 
   if (user_context.GetAuthFlow() == UserContext::AUTH_FLOW_EASY_UNLOCK)
     SetupEasyUnlockUserFlow(user_context.GetUserID());
 
   switch (auth_mode_) {
     case AUTH_MODE_EXTENSION: {
       RunOnlineWhitelistCheck(
-          email, wildcard_match, user_context.GetRefreshToken(),
+          user_context.GetUserID(), wildcard_match, user_context.GetRefreshToken(),
           base::Bind(&LoginPerformer::StartLoginCompletion,
                      weak_factory_.GetWeakPtr()),
           base::Bind(&LoginPerformer::NotifyWhitelistCheckFailure,
                      weak_factory_.GetWeakPtr()));
       break;
     }
     case AUTH_MODE_INTERNAL:
       StartAuthentication();
       break;
   }
 }
 
 void LoginPerformer::LoginAsSupervisedUser(const UserContext& user_context) {
   DCHECK_EQ(chromeos::login::kSupervisedUserDomain,
-            gaia::ExtractDomainName(user_context.GetUserID()));
+            gaia::ExtractDomainName(user_context.GetUserID().GetUserEmail()));
 
   user_context_ = user_context;
   user_context_.SetUserType(user_manager::USER_TYPE_SUPERVISED);
 
   if (RunTrustedCheck(base::Bind(&LoginPerformer::TrustedLoginAsSupervisedUser,
                                  weak_factory_.GetWeakPtr(),
                                  user_context_))) {
     return;
   }
   TrustedLoginAsSupervisedUser(user_context_);
@@ skipping 45 matching lines @@
                                     user_context));
 }
 
 void LoginPerformer::LoginOffTheRecord() {
   EnsureAuthenticator();
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Authenticator::LoginOffTheRecord, authenticator_.get()));
 }
 
-void LoginPerformer::LoginAsKioskAccount(const std::string& app_user_id,
+void LoginPerformer::LoginAsKioskAccount(const user_manager::UserID& app_user_id,
                                          bool use_guest_mount) {
   EnsureAuthenticator();
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&Authenticator::LoginAsKioskAccount,
                                     authenticator_.get(),
                                     app_user_id,
                                     use_guest_mount));
 }
 
 void LoginPerformer::RecoverEncryptedData(const std::string& old_password) {
@@ skipping 50 matching lines @@
   } else {
     NOTREACHED();
   }
   user_context_.ClearSecrets();
 }
 
 void LoginPerformer::EnsureAuthenticator() {
   authenticator_ = CreateAuthenticator();
 }
 }  // namespace chromeos