Prefer to use the AccountID to the Email from ListAccounts.

components/signin/core/browser/account_reconcilor.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/signin/core/browser/account_reconcilor.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_client.h"
 #include "components/signin/core/browser/signin_metrics.h"
 #include "components/signin/core/common/profile_management_switches.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/gaia_oauth_client.h"
 #include "google_apis/gaia/gaia_urls.h"
 
 
 namespace {
 
-class EmailEqualToFunc : public std::equal_to<gaia::ListedAccount> {
+class AccountEqualToFunc : public std::equal_to<gaia::ListedAccount> {
  public:
   bool operator()(const gaia::ListedAccount& p1,
                   const gaia::ListedAccount& p2) const;
 };
 
-bool EmailEqualToFunc::operator()(
+bool AccountEqualToFunc::operator()(
     const gaia::ListedAccount& p1,
     const gaia::ListedAccount& p2) const {
-  return p1.valid == p2.valid && gaia::AreEmailsSame(p1.email, p2.email);
+  return p1.valid == p2.valid && p1.id == p2.id;
 }
 
-class AreEmailsSameFunc : public std::equal_to<std::string> {
- public:
-  bool operator()(const std::string& p1,
-                  const std::string& p2) const;
-};
-
-bool AreEmailsSameFunc::operator()(
-    const std::string& p1,
-    const std::string& p2) const {
-  return gaia::AreEmailsSame(p1, p2);
-}
-
-gaia::ListedAccount AccountFromEmail(const std::string& email) {
+gaia::ListedAccount AccountForId(const std::string& account_id) {
   gaia::ListedAccount account;
-  account.email = email;
+  account.id = account_id;
   account.gaia_id = std::string();
+  account.email = std::string();
   account.valid = true;
   return account;
 }
 
 }  // namespace
 
 
 AccountReconcilor::AccountReconcilor(
     ProfileOAuth2TokenService* token_service,
     SigninManagerBase* signin_manager,
@@ skipping 267 matching lines @@
   } else {
     Shutdown();
   }
 }
 
 void AccountReconcilor::FinishReconcile() {
   VLOG(1) << "AccountReconcilor::FinishReconcile";
   DCHECK(add_to_cookie_.empty());
   int number_gaia_accounts = gaia_accounts_.size();
   bool are_primaries_equal = number_gaia_accounts > 0 &&
-      gaia::AreEmailsSame(primary_account_, gaia_accounts_[0].email);
+      primary_account_ == gaia_accounts_[0].id;
 
   // If there are any accounts in the gaia cookie but not in chrome, then
   // those accounts need to be removed from the cookie.  This means we need
   // to blow the cookie away.
   int removed_from_cookie = 0;
   for (size_t i = 0; i < gaia_accounts_.size(); ++i) {
-    const std::string& gaia_account = gaia_accounts_[i].email;
     if (gaia_accounts_[i].valid &&
-        chrome_accounts_.end() ==
-            std::find_if(chrome_accounts_.begin(),
-                         chrome_accounts_.end(),
-                         std::bind1st(AreEmailsSameFunc(), gaia_account))) {
+        chrome_accounts_.end() == std::find(chrome_accounts_.begin(),
+                                            chrome_accounts_.end(),
+                                            gaia_accounts_[i].id)) {
       ++removed_from_cookie;
     }
   }
 
   bool rebuild_cookie = !are_primaries_equal || removed_from_cookie > 0;
   std::vector<gaia::ListedAccount> original_gaia_accounts =
       gaia_accounts_;
   if (rebuild_cookie) {
     VLOG(1) << "AccountReconcilor::FinishReconcile: rebuild cookie";
     // Really messed up state.  Blow away the gaia cookie completely and
@@ skipping 15 matching lines @@
   // For each account known to chrome, PerformMergeAction() if the account is
   // not already in the cookie jar or its state is invalid, or signal merge
   // completed otherwise.  Make a copy of |add_to_cookie_| since calls to
   // SignalComplete() will change the array.
   std::vector<std::string> add_to_cookie_copy = add_to_cookie_;
   int added_to_cookie = 0;
   for (size_t i = 0; i < add_to_cookie_copy.size(); ++i) {
     if (gaia_accounts_.end() !=
             std::find_if(gaia_accounts_.begin(),
                          gaia_accounts_.end(),
-                         std::bind1st(EmailEqualToFunc(),
-                                      AccountFromEmail(add_to_cookie_copy[i]
-                                                       )))) {
+                         std::bind1st(AccountEqualToFunc(),
+                                      AccountForId(add_to_cookie_copy[i])))) {
       cookie_manager_service_->SignalComplete(
           add_to_cookie_copy[i],
           GoogleServiceAuthError::AuthErrorNone());
     } else {
       PerformMergeAction(add_to_cookie_copy[i]);
       if (original_gaia_accounts.end() ==
               std::find_if(original_gaia_accounts.begin(),
                            original_gaia_accounts.end(),
-                           std::bind1st(EmailEqualToFunc(),
-                                        AccountFromEmail(add_to_cookie_copy[i]
-                                                         )))) {
+                           std::bind1st(AccountEqualToFunc(),
+                                        AccountForId(add_to_cookie_copy[i])))) {
         added_to_cookie++;
       }
     }
   }
 
   signin_metrics::LogSigninAccountReconciliation(chrome_accounts_.size(),
                                                  added_to_cookie,
                                                  removed_from_cookie,
                                                  are_primaries_equal,
                                                  first_execution_,
@@ skipping 50 matching lines @@
           << "Account added: " << account_id << ", "
           << "Error was " << error.ToString();
   // Always listens to GaiaCookieManagerService. Only proceed if reconciling.
   if (is_reconcile_started_ && MarkAccountAsAddedToCookie(account_id)) {
     if (error.state() != GoogleServiceAuthError::State::NONE)
       error_during_last_reconcile_ = true;
     CalculateIfReconcileIsDone();
     ScheduleStartReconcileIfChromeAccountsChanged();
   }
 }