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

chrome/browser/signin/easy_unlock_auth_attempt.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 CHROME_BROWSER_SIGNIN_EASY_UNLOCK_AUTH_ATTEMPT_H_
 #define CHROME_BROWSER_SIGNIN_EASY_UNLOCK_AUTH_ATTEMPT_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/macros.h"
+#include "components/user_manager/user_id.h"
 
 class EasyUnlockAppManager;
 
 // Class responsible for handling easy unlock auth attempts (both for unlocking
 // the screen and logging in). The auth protocol is started by calling |Start|,
 // which notifies the easy unlock app about auth attempt. When the auth result
 // is available, |FinalizeUnlock| or |FinalizeSignin| should be called,
 // depending on auth type.
 // To cancel the in progress auth attempt, delete the |EasyUnlockAuthAttempt|
 // object.
 class EasyUnlockAuthAttempt {
  public:
   // The auth type.
   enum Type {
     TYPE_UNLOCK,
     TYPE_SIGNIN
   };
 
   // A callback to be invoked after the auth attempt is finalized. |success|
   // indicates whether the attempt is successful or not. |user_id| is the
   // associated user. |key_secret| is the user secret for a sign-in attempt
   // and |key_label| is the label of the corresponding cryptohome key.
   typedef base::Callback<void(Type auth_attempt_type,
                               bool success,
-                              const std::string& user_id,
+                              const user_manager::UserID& user_id,
                               const std::string& key_secret,
                               const std::string& key_label)>
       FinalizedCallback;
 
   EasyUnlockAuthAttempt(EasyUnlockAppManager* app_manager,
-                        const std::string& user_id,
+                        const user_manager::UserID& user_id,
                         Type type,
                         const FinalizedCallback& finalized_callback);
   ~EasyUnlockAuthAttempt();
 
   // Starts the auth attempt by sending screenlockPrivate.onAuthAttempted event
   // to easy unlock app. Returns whether the event was successfully dispatched.
   bool Start();
 
   // Finalizes an unlock attempt. It unlocks the screen if |success| is true.
   // If |this| has TYPE_SIGNIN type, calling this method will cause signin
   // failure equivalent to cancelling the attempt.
-  void FinalizeUnlock(const std::string& user_id, bool success);
+  void FinalizeUnlock(const user_manager::UserID& user_id, bool success);
 
   // Finalizes signin attempt. It tries to log in using the secret derived from
   // |wrapped_secret| decrypted by |session_key|. If the decryption fails, it
   // fails the signin attempt.
   // If called on an object with TYPE_UNLOCK type, it will cause unlock failure
   // equivalent to cancelling the request.
-  void FinalizeSignin(const std::string& user_id,
+  void FinalizeSignin(const user_manager::UserID& user_id,
                       const std::string& wrapped_secret,
                       const std::string& session_key);
 
  private:
   // The internal attempt state.
   enum State {
     STATE_IDLE,
     STATE_RUNNING,
     STATE_DONE
   };
 
   // Cancels the attempt.
-  void Cancel(const std::string& user_id);
+  void Cancel(const user_manager::UserID& user_id);
 
   EasyUnlockAppManager* app_manager_;
   State state_;
-  std::string user_id_;
+  user_manager::UserID user_id_;
   Type type_;
 
   FinalizedCallback finalized_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(EasyUnlockAuthAttempt);
 };
 
 #endif  // CHROME_BROWSER_SIGNIN_EASY_UNLOCK_AUTH_ATTEMPT_H_