When the user signs in, make sure to set cookies on all reachable google

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"
@@ skipping 413 matching lines @@
 }
 
 void AccountReconcilor::StartReconcile() {
   if (!IsProfileConnected() || is_reconcile_started_ ||
       get_gaia_accounts_callbacks_.size() > 0 ||
       merge_session_helper_.is_running())
     return;
 
   is_reconcile_started_ = true;
 
+  StartFetchingExternalCcResult();
+
   // Reset state for validating gaia cookie.
   are_gaia_accounts_set_ = false;
   gaia_accounts_.clear();
   GetAccountsFromCookie(base::Bind(
       &AccountReconcilor::ContinueReconcileActionAfterGetGaiaAccounts,
       base::Unretained(this)));
 
   // Reset state for validating oauth2 tokens.
   primary_account_.clear();
   chrome_accounts_.clear();
   DeleteFetchers();
   valid_chrome_accounts_.clear();
   invalid_chrome_accounts_.clear();
   add_to_cookie_.clear();
   add_to_chrome_.clear();
   ValidateAccountsFromTokenService();
 }
 
 void AccountReconcilor::GetAccountsFromCookie(
     GetAccountsFromCookieCallback callback) {
   get_gaia_accounts_callbacks_.push_back(callback);
   if (!gaia_fetcher_) {
     // There is no list account request in flight.
     gaia_fetcher_.reset(new GaiaAuthFetcher(
         this, GaiaConstants::kChromeSource, client_->GetURLRequestContext()));
     gaia_fetcher_->StartListAccounts();
   }
 }
 
+void AccountReconcilor::StartFetchingExternalCcResult() {
+  merge_session_helper_.StartFetchingExternalCcResult();
+}
+
 void AccountReconcilor::OnListAccountsSuccess(const std::string& data) {
   gaia_fetcher_.reset();
 
   // Get account information from response data.
   std::vector<std::pair<std::string, bool> > gaia_accounts;
   bool valid_json = gaia::ParseListAccountsData(data, &gaia_accounts);
   if (!valid_json) {
     VLOG(1) << "AccountReconcilor::OnListAccountsSuccess: parsing error";
   } else if (gaia_accounts.size() > 0) {
     VLOG(1) << "AccountReconcilor::OnListAccountsSuccess: "
@@ skipping 170 matching lines @@
     if (*i != primary_account_)
       add_to_cookie_.push_back(*i);
   }
 
   // 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;
+  bool external_cc_result_completed =
+      !merge_session_helper_.StillFetchingExternalCcResult();
   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)))) {
       merge_session_helper_.SignalComplete(
           add_to_cookie_copy[i],
           GoogleServiceAuthError::AuthErrorNone());
     } else {
       PerformMergeAction(add_to_cookie_copy[i]);
       added_to_cookie++;
     }
   }
 
+  // Log whether the external connection checks were completed when we tried
+  // to add the accounts to the cookie.
+  if (added_to_cookie > 0)
+    signin_metrics::LogExternalCcResultFetches(external_cc_result_completed);
+
   std::string signin_scoped_device_id = client_->GetSigninScopedDeviceId();
   // For each account in the gaia cookie not known to chrome,
   // PerformAddToChromeAction. Make a copy of |add_to_chrome| since calls to
   // PerformAddToChromeAction() may modify this array.
   std::vector<std::pair<std::string, int> > add_to_chrome_copy = add_to_chrome_;
   for (std::vector<std::pair<std::string, int> >::const_iterator i =
            add_to_chrome_copy.begin();
        i != add_to_chrome_copy.end();
        ++i) {
     PerformAddToChromeAction(i->first, i->second, signin_scoped_device_id);
@@ skipping 105 matching lines @@
 
 void AccountReconcilor::HandleRefreshTokenFetched(
     const std::string& account_id,
     const std::string& refresh_token) {
   if (!refresh_token.empty())
     PerformAddAccountToTokenService(account_id, refresh_token);
 
   MarkAccountAsAddedToChrome(account_id);
   CalculateIfReconcileIsDone();
 }