This CL replaces e-mail with AccountId in easy signin code.

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"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "chromeos/chromeos_export.h"
 #include "chromeos/login/auth/auth_status_consumer.h"
 #include "chromeos/login/auth/authenticator.h"
 #include "chromeos/login/auth/extended_authenticator.h"
 #include "chromeos/login/auth/user_context.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 
+class AccountId;
+
 namespace net {
 class URLRequestContextGetter;
 }
 
 namespace policy {
 class WildcardLoginChecker;
 }
 
 namespace content {
 class BrowserContext;
@@ skipping 78 matching lines @@
     return password_changed_callback_count_;
   }
 
   void set_delegate(Delegate* delegate) { delegate_ = delegate; }
 
   AuthorizationMode auth_mode() const { return auth_mode_; }
 
   // 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 AccountId& account_id,
                                  bool* wildcard_match) = 0;
 
  protected:
   // 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;
 
   // 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 AccountId& account_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 AccountId& account_id) = 0;
 
   // Set up sign-in flow for Easy Unlock.
-  virtual void SetupEasyUnlockUserFlow(const std::string& user_id) = 0;
+  virtual void SetupEasyUnlockUserFlow(const AccountId& account_id) = 0;
 
-  // Run policy check for |user_id|. If something is wrong, delegate's
+  // Run policy check for |account_id|. If something is wrong, delegate's
   // PolicyLoadFailed is called.
-  virtual bool CheckPolicyForUser(const std::string& user_id) = 0;
+  virtual bool CheckPolicyForUser(const AccountId& account_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 46 matching lines @@
   // Authorization mode type.
   AuthorizationMode auth_mode_;
 
   base::WeakPtrFactory<LoginPerformer> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(LoginPerformer);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_LOGIN_AUTH_LOGIN_PERFORMER_H_