This CL replaces e-mail with AccountId on user selection screen.

components/user_manager/user_manager_base.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 "components/user_manager/user_manager_base.h"
 
 #include <cstddef>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 102 matching lines @@
 void ResolveLocale(const std::string& raw_locale,
                    std::string* resolved_locale) {
   ignore_result(l10n_util::CheckAndResolveLocale(raw_locale, resolved_locale));
 }
 
 // Checks if values in |dict| correspond with |account_id| identity.
 bool UserMatches(const AccountId& account_id,
                  const base::DictionaryValue& dict) {
   std::string value;
 
+  // TODO(antrim): update code once user id is really a struct.

[dzhioev (left Google), 2015/11/12 00:46:24]

TODO(alemate)?

[Alexander Alekseev, 2015/11/12 06:53:04]

Done.

+  bool has_gaia_id = dict.GetString(kGAIAIdKey, &value);
+  if (has_gaia_id && account_id.GetGaiaId() == value)
+    return true;
+
   bool has_email = dict.GetString(kCanonicalEmail, &value);
   if (has_email && account_id.GetUserEmail() == value)
     return true;
 
-  // TODO(antrim): update code once user id is really a struct.
-  bool has_gaia_id = dict.GetString(kGAIAIdKey, &value);
-  if (has_gaia_id && account_id.GetUserEmail() == value)
-    return true;
-
   return false;
 }
 
 // Fills relevant |dict| values based on |account_id|.
 void UpdateIdentity(const AccountId& account_id, base::DictionaryValue& dict) {
   dict.SetString(kCanonicalEmail, account_id.GetUserEmail());
 }
 
 }  // namespace
 
@@ skipping 433 matching lines @@
     if (!IsUserNonCryptohomeDataEphemeral(account_id)) {
       DictionaryPrefUpdate given_name_update(GetLocalState(), kUserGivenName);
       given_name_update->SetWithoutPathExpansion(
           account_id.GetUserEmail(), new base::StringValue(given_name));
     }
   }
 
   UpdateUserAccountLocale(account_id, account_data.locale());
 }
 
-// static
 void UserManagerBase::ParseUserList(const base::ListValue& users_list,
                                     const std::set<AccountId>& existing_users,
                                     std::vector<AccountId>* users_vector,
                                     std::set<AccountId>* users_set) {
   users_vector->clear();
   users_set->clear();
   for (size_t i = 0; i < users_list.GetSize(); ++i) {
     std::string email;
     if (!users_list.GetString(i, &email) || email.empty()) {
       LOG(ERROR) << "Corrupt entry in user list at index " << i << ".";
       continue;
     }
-    const AccountId account_id(AccountId::FromUserEmail(email));
+
+    const AccountId partial_account_id(AccountId::FromUserEmail(email));
+    AccountId account_id(EmptyAccountId());
+
+    const bool lookup_result =
+        GetKnownUserAccountId(partial_account_id, &account_id);
+    // TODO(alemate):
+    // DCHECK(lookup_result) << "KnownUser lookup falied for '" << email << "'";
+    // (tests do not initialize KnownUserData)
+
+    if (!lookup_result) {
+      account_id = partial_account_id;
+      LOG(WARNING) << "KnownUser lookup falied for '" << email << "'";
+    }
+
     if (existing_users.find(account_id) != existing_users.end() ||
         !users_set->insert(account_id).second) {
       LOG(ERROR) << "Duplicate user: " << email;
       continue;
     }
     users_vector->push_back(account_id);
   }
 }
 
 bool UserManagerBase::IsCurrentUserOwner() const {
@@ skipping 233 matching lines @@
       user = User::CreateSupervisedUser(*it);
     } else {
       user = User::CreateRegularUser(*it);
       int user_type;
       if (prefs_user_types->GetIntegerWithoutPathExpansion(it->GetUserEmail(),
                                                            &user_type) &&
           user_type == USER_TYPE_CHILD) {
         ChangeUserChildStatus(user, true /* is child */);
       }
     }
+    const AccountId account_id = user->GetAccountId();
     user->set_oauth_token_status(LoadUserOAuthStatus(*it));
     user->set_force_online_signin(LoadForceOnlineSignin(*it));
     user->set_using_saml(FindUsingSAML(*it));
     users_.push_back(user);
 
     base::string16 display_name;
     if (prefs_display_names->GetStringWithoutPathExpansion(it->GetUserEmail(),
                                                            &display_name)) {
       user->set_display_name(display_name);
     }
@@ skipping 283 matching lines @@
 
   ListPrefUpdate update(local_state, kKnownUsers);
   base::DictionaryValue dict;
   dict.SetInteger(path, in_value);
   UpdateKnownUserPrefs(account_id, dict, false);
 }
 
 bool UserManagerBase::GetKnownUserAccountId(
     const AccountId& authenticated_account_id,
     AccountId* out_account_id) {
-  DCHECK(!authenticated_account_id.GetGaiaId().empty());
-  std::string canonical_email;
-  if (!GetKnownUserStringPref(
-          AccountId::FromGaiaId(authenticated_account_id.GetGaiaId()),
-          kCanonicalEmail, &canonical_email))
+  if (!authenticated_account_id.GetGaiaId().empty()) {
+    std::string canonical_email;
+    if (!GetKnownUserStringPref(
+            AccountId::FromGaiaId(authenticated_account_id.GetGaiaId()),
+            kCanonicalEmail, &canonical_email)) {
+      return false;
+    }
+
+    *out_account_id = AccountId::FromUserEmailGaiaId(
+        canonical_email, authenticated_account_id.GetGaiaId());
+    return true;
+  }
+  DCHECK(!authenticated_account_id.GetUserEmail().empty());
+  std::string gaia_id;
+  if (!GetKnownUserStringPref(authenticated_account_id, kGAIAIdKey, &gaia_id))
     return false;
 
-  *out_account_id = authenticated_account_id;
-  out_account_id->SetUserEmail(canonical_email);
+  *out_account_id = AccountId::FromUserEmailGaiaId(
+      authenticated_account_id.GetUserEmail(), gaia_id);
   return true;
 }
 
 void UserManagerBase::UpdateGaiaID(const AccountId& account_id,
                                    const std::string& gaia_id) {
   SetKnownUserStringPref(account_id, kGAIAIdKey, gaia_id);
 }
 
 bool UserManagerBase::FindGaiaID(const AccountId& account_id,
                                  std::string* out_value) {
@@ skipping 193 matching lines @@
 }
 
 void UserManagerBase::DeleteUser(User* user) {
   const bool is_active_user = (user == active_user_);
   delete user;
   if (is_active_user)
     active_user_ = nullptr;
 }
 
 }  // namespace user_manager