This CL replaces user_manager::UserID with AccountId.

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"
 #include "base/metrics/user_metrics.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "chromeos/login/user_names.h"
 #include "chromeos/login_event_recorder.h"
 #include "chromeos/settings/cros_settings_names.h"
+#include "components/signin/core/account_id/account_id.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/cookies/cookie_store.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using base::UserMetricsAction;
 
 namespace chromeos {
 
@@ skipping 69 matching lines @@
   } else {
     NOTREACHED();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LoginPerformer, public:
 
 void LoginPerformer::NotifyWhitelistCheckFailure() {
   if (delegate_)
-    delegate_->WhiteListCheckFailed(user_context_.GetUserID());
+    delegate_->WhiteListCheckFailed(user_context_.GetUserID().GetUserEmail());
   else
     NOTREACHED();
 }
 
 void LoginPerformer::PerformLogin(const UserContext& user_context,
                                   AuthorizationMode auth_mode) {
   auth_mode_ = auth_mode;
   user_context_ = user_context;
 
   if (RunTrustedCheck(base::Bind(&LoginPerformer::DoPerformLogin,
                                  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());
+  std::string email =

[achuithb, 2015/10/23 00:08:51]

const, isn't this already canonicalized?

[Alexander Alekseev, 2015/10/23 09:11:24]

No ;-(

+      gaia::CanonicalizeEmail(user_context.GetUserID().GetUserEmail());
   bool wildcard_match = false;
 
   if (!IsUserWhitelisted(email, &wildcard_match)) {
     NotifyWhitelistCheckFailure();
     return;
   }
 
   if (user_context.GetAuthFlow() == UserContext::AUTH_FLOW_EASY_UNLOCK)
-    SetupEasyUnlockUserFlow(user_context.GetUserID());
+    SetupEasyUnlockUserFlow(user_context.GetUserID().GetUserEmail());
 
   switch (auth_mode_) {
     case AUTH_MODE_EXTENSION: {
       RunOnlineWhitelistCheck(
           email, 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_);
 }
 
 void LoginPerformer::TrustedLoginAsSupervisedUser(
     const UserContext& user_context) {
   if (!AreSupervisedUsersAllowed()) {
     LOG(ERROR) << "Login attempt of supervised user detected.";
-    delegate_->WhiteListCheckFailed(user_context.GetUserID());
+    delegate_->WhiteListCheckFailed(user_context.GetUserID().GetUserEmail());
     return;
   }
 
-  SetupSupervisedUserFlow(user_context.GetUserID());
+  SetupSupervisedUserFlow(user_context.GetUserID().GetUserEmail());
   UserContext user_context_copy = TransformSupervisedKey(user_context);
 
   if (UseExtendedAuthenticatorForSupervisedUser(user_context)) {
     EnsureExtendedAuthenticator();
     // TODO(antrim) : Replace empty callback with explicit method.
     // http://crbug.com/351268
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&ExtendedAuthenticator::AuthenticateToMount,
                    extended_authenticator_.get(),
                    user_context_copy,
                    ExtendedAuthenticator::ResultCallback()));
 
   } else {
     EnsureAuthenticator();
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&Authenticator::LoginAsSupervisedUser,
                                       authenticator_.get(),
                                       user_context_copy));
   }
 }
 
 void LoginPerformer::LoginAsPublicSession(const UserContext& user_context) {
-  if (!CheckPolicyForUser(user_context.GetUserID())) {
+  if (!CheckPolicyForUser(user_context.GetUserID().GetUserEmail())) {
     DCHECK(delegate_);
     if (delegate_)
       delegate_->PolicyLoadFailed();
     return;
   }
 
   EnsureAuthenticator();
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&Authenticator::LoginAsPublicSession,
                                     authenticator_.get(),
@@ skipping 66 matching lines @@
   } else {
     NOTREACHED();
   }
   user_context_.ClearSecrets();
 }
 
 void LoginPerformer::EnsureAuthenticator() {
   authenticator_ = CreateAuthenticator();
 }
 }  // namespace chromeos