ListAccounts will return the Gaia ID as well as the email of the account.

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/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_number_conversions.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<std::pair<std::string, bool> > {
+class EmailEqualToFunc : public std::equal_to<gaia::ListedAccount> {
  public:
-  bool operator()(const std::pair<std::string, bool>& p1,
-                  const std::pair<std::string, bool>& p2) const;
+  bool operator()(const gaia::ListedAccount& p1,
+                  const gaia::ListedAccount& p2) const;
 };
 
 bool EmailEqualToFunc::operator()(
-    const std::pair<std::string, bool>& p1,
-    const std::pair<std::string, bool>& p2) const {
-  return p1.second == p2.second && gaia::AreEmailsSame(p1.first, p2.first);
+    const gaia::ListedAccount& p1,
+    const gaia::ListedAccount& p2) const {
+  return p1.valid == p2.valid && gaia::AreEmailsSame(p1.email, p2.email);

[Roger Tawa OOO till Jul 10th, 2015/06/02 21:58:41]

Instead of:

   gaia::AreEmailsSame(p1.email, p2.email)

shouldn't this be:

   p1.account_id == p2.account_id

Same for line 47 below.  Doing it this way means the code will work whether we
use gaiaid or email as the account id, and that after we switch to gaiaids, we
will not look at the email at all.

 }
 
 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 account;
+  account.email = email;
+  account.gaia_id = std::string();
+  account.valid = true;
+  return account;
+}

[Roger Tawa OOO till Jul 10th, 2015/06/02 21:58:41]

You probably want a function called AccountFromAccountId() which does pretty
much the same thing except with the account_id.

About renaming, probably want to rename the two classes above:

EmailEqualToFunc --> AccountEqualToFunc
AreEmailsSameFunc --> AreAccountsSameFunc

+
 }  // namespace
 
 
 AccountReconcilor::AccountReconcilor(
     ProfileOAuth2TokenService* token_service,
     SigninManagerBase* signin_manager,
     SigninClient* client,
     GaiaCookieManagerService* cookie_manager_service)
     : token_service_(token_service),
       signin_manager_(signin_manager),
@@ skipping 215 matching lines @@
   ValidateAccountsFromTokenService();
 
   // Rely on the GCMS to manage calls to and responses from ListAccounts.
   if (cookie_manager_service_->ListAccounts(&gaia_accounts_)) {
     OnGaiaAccountsInCookieUpdated(
         gaia_accounts_, GoogleServiceAuthError(GoogleServiceAuthError::NONE));
   }
 }
 
 void AccountReconcilor::OnGaiaAccountsInCookieUpdated(
-        const std::vector<std::pair<std::string, bool> >& accounts,
+        const std::vector<gaia::ListedAccount>& accounts,
         const GoogleServiceAuthError& error) {
   VLOG(1) << "AccountReconcilor::OnGaiaAccountsInCookieUpdated: "
           << "CookieJar " << accounts.size() << " accounts, "
           << "Reconcilor's state is " << is_reconcile_started_ << ", "
           << "Error was " << error.ToString();
   if (error.state() == GoogleServiceAuthError::NONE) {
     gaia_accounts_ = accounts;
 
     // It is possible that O2RT is not available at this moment.
     if (token_service_->GetAccounts().empty())
@@ skipping 29 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].first);
+      gaia::AreEmailsSame(primary_account_, gaia_accounts_[0].email);

[Roger Tawa OOO till Jul 10th, 2015/06/02 21:58:41]

This should be:

   primary_account_id_ == gaia_accounts_[0].account_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].first;
-    if (gaia_accounts_[i].second &&
+    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))) {
       ++removed_from_cookie;
     }
   }
 
   bool rebuild_cookie = !are_primaries_equal || removed_from_cookie > 0;
-  std::vector<std::pair<std::string, bool> > original_gaia_accounts =
+  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
     // rebuild it, making sure the primary account as specified by the
     // SigninManager is the first session in the gaia cookie.
     PerformLogoutAllAccountsAction();
     gaia_accounts_.clear();
   }
 
@@ skipping 10 matching lines @@
   // 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(),
-                                      std::make_pair(add_to_cookie_copy[i],
-                                                     true)))) {
+                                      AccountFromEmail(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(),
-                                        std::make_pair(add_to_cookie_copy[i],
-                                                       true)))) {
+                                        AccountFromEmail(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();
   }
 }