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

chromeos/login/auth/login_performer.h

 // 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.
 
 #ifndef CHROMEOS_LOGIN_AUTH_LOGIN_PERFORMER_H_
 #define CHROMEOS_LOGIN_AUTH_LOGIN_PERFORMER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 13 matching lines @@
 }
 
 namespace policy {
 class WildcardLoginChecker;
 }
 
 namespace content {
 class BrowserContext;
 }
 
+namespace user_manager {
+class UserID;
+} // namespace user_manager
+
 namespace chromeos {
 
 // This class encapsulates sign in operations.
 // Sign in is performed in a way that offline auth is executed first.
 // Once offline auth is OK - user homedir is mounted, UI is launched.
 // At this point LoginPerformer |delegate_| is destroyed and it releases
 // LP instance ownership. LP waits for online login result.
 // If auth is succeeded, cookie fetcher is executed, LP instance deletes itself.
 //
 // If |delegate_| is not NULL it will handle error messages, password input.
 class CHROMEOS_EXPORT LoginPerformer : public AuthStatusConsumer,
                                        public OnlineAttemptHost::Delegate {
  public:
   typedef enum AuthorizationMode {
     // Authorization performed internally by Chrome.
     AUTH_MODE_INTERNAL,
     // Authorization performed by an extension.
     AUTH_MODE_EXTENSION
   } AuthorizationMode;
 
   // Delegate class to get notifications from the LoginPerformer.
   class Delegate : public AuthStatusConsumer {
    public:
     ~Delegate() override {}
-    virtual void WhiteListCheckFailed(const std::string& email) = 0;
+    virtual void WhiteListCheckFailed(const user_manager::UserID& user_id) = 0;
     virtual void PolicyLoadFailed() = 0;
-    virtual void OnOnlineChecked(const std::string& email, bool success) = 0;
+    virtual void OnOnlineChecked(const user_manager::UserID& user_id, bool success) = 0;
   };
 
   LoginPerformer(scoped_refptr<base::TaskRunner> task_runner,
                  Delegate* delegate,
                  bool disable_client_login);
   ~LoginPerformer() override;
 
   // Performs a login for |user_context|.
   // If auth_mode is AUTH_MODE_EXTENSION, there are no further auth checks,
   // AUTH_MODE_INTERNAL will perform auth checks.
   void PerformLogin(const UserContext& user_context,
                     AuthorizationMode auth_mode);
 
   // Performs supervised user login with a given |user_context|.
   void LoginAsSupervisedUser(const UserContext& user_context);
 
   // Performs actions to prepare guest mode login.
   void LoginOffTheRecord();
 
   // Performs public session login with a given |user_context|.
   void LoginAsPublicSession(const UserContext& user_context);
 
   // Performs a login into the kiosk mode account with |app_user_id|.
-  void LoginAsKioskAccount(const std::string& app_user_id,
+  void LoginAsKioskAccount(const user_manager::UserID& app_user_id,
                            bool use_guest_mount);
 
   // AuthStatusConsumer implementation:
   void OnAuthFailure(const AuthFailure& error) override;
   void OnAuthSuccess(const UserContext& user_context) override;
   void OnOffTheRecordAuthSuccess() override;
   void OnPasswordChangeDetected() override;
 
   // Migrates cryptohome using |old_password| specified.
   void RecoverEncryptedData(const std::string& old_password);
@@ skipping 17 matching lines @@
   int password_changed_callback_count() {
     return password_changed_callback_count_;
   }
 
   void set_delegate(Delegate* delegate) { delegate_ = delegate; }
 
   AuthorizationMode auth_mode() const { return auth_mode_; }
 
  protected:
   // Implements OnlineAttemptHost::Delegate.
-  void OnChecked(const std::string& user_id, bool success) override;
+  void OnChecked(const user_manager::UserID& user_id, bool success) override;
 
   // Platform-dependant methods to be implemented by concrete class.
 
   // Run trusted check for a platform. If trusted check have to be performed
   // asynchronously, |false| will be returned, and either delegate's
   // PolicyLoadFailed() or |callback| will be called upon actual check.
   virtual bool RunTrustedCheck(const base::Closure& callback) = 0;
 
   // Check if user is allowed to sign in on device. |wildcard_match| will
   // contain additional information whether this user is explicitly listed or
   // not (may be relevant for extension-based sign-in).
-  virtual bool IsUserWhitelisted(const std::string& user_id,
+  virtual bool IsUserWhitelisted(const user_manager::UserID& user_id,
                                  bool* wildcard_match) = 0;
 
   // This method should run addional online check if user can sign in on device.
   // Either |success_callback| or |failure_callback| should be called upon this
   // check.
   virtual void RunOnlineWhitelistCheck(
-      const std::string& user_id,
+      const user_manager::UserID& user_id,
       bool wildcard_match,
       const std::string& refresh_token,
       const base::Closure& success_callback,
       const base::Closure& failure_callback) = 0;
 
   // Supervised users-related methods.
 
   // Check if supervised users are allowed on this device.
   virtual bool AreSupervisedUsersAllowed() = 0;
 
   // Check which authenticator should be used for supervised user.
   virtual bool UseExtendedAuthenticatorForSupervisedUser(
       const UserContext& user_context) = 0;
 
   // Probably transform supervised user's authentication key.
   virtual UserContext TransformSupervisedKey(const UserContext& context) = 0;
 
   // Set up sign-in flow for supervised user.
-  virtual void SetupSupervisedUserFlow(const std::string& user_id) = 0;
+  virtual void SetupSupervisedUserFlow(const user_manager::UserID& user_id) = 0;
 
   // Set up sign-in flow for Easy Unlock.
-  virtual void SetupEasyUnlockUserFlow(const std::string& user_id) = 0;
+  virtual void SetupEasyUnlockUserFlow(const user_manager::UserID& user_id) = 0;
 
   // Run policy check for |user_id|. If something is wrong, delegate's
   // PolicyLoadFailed is called.
-  virtual bool CheckPolicyForUser(const std::string& user_id) = 0;
+  virtual bool CheckPolicyForUser(const user_manager::UserID& user_id) = 0;
 
   // Look up browser context to use during signin.
   virtual content::BrowserContext* GetSigninContext() = 0;
 
   // Get RequestContext used for sign in.
   virtual net::URLRequestContextGetter* GetSigninRequestContext() = 0;
 
   // Create authenticator implementation.
   virtual scoped_refptr<Authenticator> CreateAuthenticator() = 0;
 
@@ skipping 52 matching lines @@
   // TODO(antrim): remove once we got rid of /ClientLogin.
   bool disable_client_login_;
 
   base::WeakPtrFactory<LoginPerformer> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(LoginPerformer);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_LOGIN_AUTH_LOGIN_PERFORMER_H_