This CL replaces user_manager::UserID with AccountId.

chrome/browser/ui/webui/chromeos/login/gaia_screen_handler.cc

 // Copyright 2013 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 "chrome/browser/ui/webui/chromeos/login/gaia_screen_handler.h"
 
 #include "ash/system/chromeos/devicetype_utils.h"
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
@@ skipping 418 matching lines @@
   else
     frame_error_ = net::ERR_INTERNET_DISCONNECTED;
 
   LOG(ERROR) << "Gaia webview error: " << error_reason_str;
   NetworkError::ErrorReason error_reason =
       NetworkError::ERROR_REASON_FRAME_ERROR;
   frame_state_ = FRAME_STATE_ERROR;
   UpdateState(error_reason);
 }
 
-std::string GaiaScreenHandler::GetCanonicalEmail(
+AccountId GaiaScreenHandler::GetAccountId(
     const std::string& authenticated_email,
     const std::string& gaia_id) const {
-  const std::string sanitized_email = gaia::SanitizeEmail(authenticated_email);
+  const std::string canonicalized_email =
+      gaia::CanonicalizeEmail(gaia::SanitizeEmail(authenticated_email));
+  const AccountId authenticated_account_id(
+      AccountId::FromUserEmailGaiaId(canonicalized_email, gaia_id));
 
-  const std::string canonicalized_email =
-      gaia::CanonicalizeEmail(sanitized_email);
+  // If we don't have UserManager instance (i.e. we are in unit test),
+  // or a known user has authenticated, just log in.
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
-  if (user_manager && !user_manager->IsKnownUser(canonicalized_email)) {
-    std::string old_canonical_email;
-    if (user_manager->GetKnownUserCanonicalEmail(gaia_id,
-                                                 &old_canonical_email)) {
-      if (old_canonical_email != canonicalized_email) {
-        LOG(WARNING) << "Existing user '" << old_canonical_email
-                     << "' authenticated by alias '" << sanitized_email << "'.";
-        return old_canonical_email;
-      }
-    }
+  if (!user_manager || user_manager->IsKnownUser(authenticated_account_id))
+    return authenticated_account_id;
+
+  // If [part of] user id has changed, update stored data and connect user
+  // to existing home directory.
+  AccountId old_account_id(EmptyAccountId());
+  if (!user_manager->GetKnownUserAccountId(authenticated_account_id,
+                                           &old_account_id)) {
+    return authenticated_account_id;
   }
-  // For compatibility reasons, sanitized email is used.
-  return sanitized_email;
+
+  if (old_account_id.GetUserEmail() != canonicalized_email) {
+    LOG(WARNING) << "Existing user '" << old_account_id.GetUserEmail()
+                 << "' authenticated by alias '" << canonicalized_email << "'.";
+    return old_account_id;
+  }
+
+  return authenticated_account_id;
 }
 
 void GaiaScreenHandler::HandleCompleteAuthentication(
     const std::string& gaia_id,
     const std::string& email,
     const std::string& password,
     const std::string& auth_code,
     bool using_saml,
     const std::string& gaps_cookie) {
   if (!Delegate())
     return;
 
   DCHECK(!email.empty());
   DCHECK(!gaia_id.empty());
   const std::string sanitized_email = gaia::SanitizeEmail(email);
   Delegate()->SetDisplayEmail(sanitized_email);
 
-  const std::string canonical_email = GetCanonicalEmail(email, gaia_id);
-  UserContext user_context(canonical_email);
+  UserContext user_context(GetAccountId(email, gaia_id));
   user_context.SetGaiaID(gaia_id);
   user_context.SetKey(Key(password));
   user_context.SetAuthCode(auth_code);
   user_context.SetAuthFlow(using_saml
                                ? UserContext::AUTH_FLOW_GAIA_WITH_SAML
                                : UserContext::AUTH_FLOW_GAIA_WITHOUT_SAML);
   user_context.SetGAPSCookie(gaps_cookie);
   Delegate()->CompleteLogin(user_context);
 }
 
@@ skipping 12 matching lines @@
                                             const std::string& typed_email,
                                             const std::string& password,
                                             bool using_saml) {
   if (!is_enrolling_consumer_management_) {
     DoCompleteLogin(gaia_id, typed_email, password, using_saml);
     return;
   }
 
   // Consumer management enrollment is in progress.
   const std::string owner_email =
-      user_manager::UserManager::Get()->GetOwnerEmail();
+      user_manager::UserManager::Get()->GetOwnerAccountId().GetUserEmail();
   if (typed_email != owner_email) {
     // Show Gaia sign-in screen again, since we only allow the owner to sign
     // in.
     populated_email_ = owner_email;
     ShowGaiaAsync(is_enrolling_consumer_management_);
     return;
   }
 
   CHECK(consumer_management_);
   consumer_management_->SetOwner(owner_email,
@@ skipping 66 matching lines @@
   if (!Delegate())
     return;
 
   if (using_saml && !using_saml_api_)
     RecordSAMLScrapingVerificationResultInHistogram(true);
 
   DCHECK(!typed_email.empty());
   DCHECK(!gaia_id.empty());
   const std::string sanitized_email = gaia::SanitizeEmail(typed_email);
   Delegate()->SetDisplayEmail(sanitized_email);
-  const std::string canonical_email = GetCanonicalEmail(typed_email, gaia_id);
-  UserContext user_context(canonical_email);
+  UserContext user_context(GetAccountId(typed_email, gaia_id));
   user_context.SetGaiaID(gaia_id);
   user_context.SetKey(Key(password));
   user_context.SetAuthFlow(using_saml
                                ? UserContext::AUTH_FLOW_GAIA_WITH_SAML
                                : UserContext::AUTH_FLOW_GAIA_WITHOUT_SAML);
   Delegate()->CompleteLogin(user_context);
 
   if (test_expects_complete_login_) {
     VLOG(2) << "Complete test login for " << typed_email
             << ", requested=" << test_user_;
@@ skipping 138 matching lines @@
   imm->SetState(gaia_ime_state);
 
   // Set Least Recently Used input method for the user.
   if (!populated_email_.empty()) {
     SigninScreenHandler::SetUserInputMethod(populated_email_,
                                             gaia_ime_state.get());
   } else {
     std::vector<std::string> input_methods =
         imm->GetInputMethodUtil()->GetHardwareLoginInputMethodIds();
     const std::string owner_im = SigninScreenHandler::GetUserLRUInputMethod(
-        user_manager::UserManager::Get()->GetOwnerEmail());
+        user_manager::UserManager::Get()->GetOwnerAccountId().GetUserEmail());
     const std::string system_im = g_browser_process->local_state()->GetString(
         language_prefs::kPreferredKeyboardLayout);
 
     PushFrontIMIfNotExists(owner_im, &input_methods);
     PushFrontIMIfNotExists(system_im, &input_methods);
 
     gaia_ime_state->EnableLoginLayouts(
         g_browser_process->GetApplicationLocale(), input_methods);
 
     if (!system_im.empty()) {
@@ skipping 63 matching lines @@
   VLOG(1) << "LoadAuthExtension, force: " << force
           << ", offline: " << offline;
   GaiaContext context;
   context.force_reload = force;
   context.is_local = offline;
   context.use_offline = offline;
   context.email = populated_email_;
   context.is_enrolling_consumer_management = is_enrolling_consumer_management_;
 
   std::string gaia_id;
-  if (user_manager::UserManager::Get()->FindGaiaID(context.email, &gaia_id))
+  if (user_manager::UserManager::Get()->FindGaiaID(
+          AccountId::FromUserEmail(context.email), &gaia_id))
     context.gaia_id = gaia_id;
 
   if (Delegate()) {
     context.show_users = Delegate()->IsShowUsers();
   }
 
   if (!context.email.empty()) {
     context.gaps_cookie =
         user_manager::UserManager::Get()->GetKnownUserGAPSCookie(
-            gaia::CanonicalizeEmail(context.email));
+            AccountId::FromUserEmail(gaia::CanonicalizeEmail(context.email)));
   }
 
   populated_email_.clear();
 
   LoadGaia(context);
 }
 
 void GaiaScreenHandler::UpdateState(NetworkError::ErrorReason reason) {
   if (signin_screen_handler_)
     signin_screen_handler_->UpdateState(reason);
@@ skipping 11 matching lines @@
              NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL ||
          captive_portal_status_ ==
              NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_OFFLINE;
 }
 
 void GaiaScreenHandler::DisableRestrictiveProxyCheckForTest() {
   disable_restrictive_proxy_check_for_test_ = true;
 }
 
 }  // namespace chromeos