GCMS has automatic checks for CheckExternalConnections. It will be

components/signin/core/browser/gaia_cookie_manager_service.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/gaia_cookie_manager_service.h"
 
 #include <queue>
 #include <vector>
 
 #include "base/json/json_reader.h"
@@ skipping 118 matching lines @@
     results.push_back(it->first + ":" + it->second);
   }
   return JoinString(results, ",");
 }
 
 void GaiaCookieManagerService::ExternalCcResultFetcher::Start() {
   m_external_cc_result_start_time_ = base::Time::Now();
 
   CleanupTransientState();
   results_.clear();
-  gaia_auth_fetcher_.reset(
+  helper_->gaia_auth_fetcher_.reset(
       new GaiaAuthFetcher(this, helper_->source_, helper_->request_context()));
-  gaia_auth_fetcher_->StartGetCheckConnectionInfo();
+  helper_->gaia_auth_fetcher_->StartGetCheckConnectionInfo();
 
   // Some fetches may timeout.  Start a timer to decide when the result fetcher
   // has waited long enough.
   // TODO(rogerta): I have no idea how long to wait before timing out.
   // Gaia folks say this should take no more than 2 second even in mobile.
   // This will need to be tweaked.
   timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(5), this,
                &GaiaCookieManagerService::ExternalCcResultFetcher::Timeout);
 }
 
 bool GaiaCookieManagerService::ExternalCcResultFetcher::IsRunning() {
-  return gaia_auth_fetcher_ || fetchers_.size() > 0u;
+  return helper_->gaia_auth_fetcher_ || fetchers_.size() > 0u;
 }
 
 void GaiaCookieManagerService::ExternalCcResultFetcher::TimeoutForTests() {
   Timeout();
 }
 
 void GaiaCookieManagerService::ExternalCcResultFetcher::
     OnGetCheckConnectionInfoSuccess(const std::string& data) {
+  helper_->gaia_auth_fetcher_backoff_.InformOfRequest(true);
+  gaia_auth_fetcher_timer_.Stop();
   scoped_ptr<base::Value> value(base::JSONReader::Read(data));
   const base::ListValue* list;
   if (!value || !value->GetAsList(&list)) {
     CleanupTransientState();
-    FireGetCheckConnectionInfoCompleted(false);
+    GetCheckConnectionInfoCompleted(false);
     return;
   }
 
   // If there is nothing to check, terminate immediately.
   if (list->GetSize() == 0) {
     CleanupTransientState();
-    FireGetCheckConnectionInfoCompleted(true);
+    GetCheckConnectionInfoCompleted(true);
     return;
   }
 
   // Start a fetcher for each connection URL that needs to be checked.
   for (size_t i = 0; i < list->GetSize(); ++i) {
     const base::DictionaryValue* dict;
     if (list->GetDictionary(i, &dict)) {
       std::string token;
       std::string url;
       if (dict->GetString("carryBackToken", &token) &&
           dict->GetString("url", &url)) {
         results_[token] = "null";
         net::URLFetcher* fetcher = CreateFetcher(GURL(url));
         fetchers_[fetcher->GetOriginalURL()] = std::make_pair(token, fetcher);
         fetcher->Start();
       }
     }
   }
 }
 
 void GaiaCookieManagerService::ExternalCcResultFetcher::
     OnGetCheckConnectionInfoError(const GoogleServiceAuthError& error) {
+  if (++helper_->gaia_auth_fetcher_retries_ < kMaxGaiaAuthFetcherRetries &&
+      IsTransientError(error)) {
+    helper_->gaia_auth_fetcher_backoff_.InformOfRequest(false);
+    gaia_auth_fetcher_timer_.Start(
+        FROM_HERE, helper_->gaia_auth_fetcher_backoff_.GetTimeUntilRelease(),
+        this, &GaiaCookieManagerService::ExternalCcResultFetcher::Start);
+    return;
+  }
+
   CleanupTransientState();
-  FireGetCheckConnectionInfoCompleted(false);
+  GetCheckConnectionInfoCompleted(false);
 }
 
 net::URLFetcher*
 GaiaCookieManagerService::ExternalCcResultFetcher::CreateFetcher(
     const GURL& url) {
   net::URLFetcher* fetcher =
       net::URLFetcher::Create(0, url, net::URLFetcher::GET, this);
   fetcher->SetRequestContext(helper_->request_context());
   fetcher->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                         net::LOAD_DO_NOT_SAVE_COOKIES);
@@ skipping 22 matching lines @@
     // Clean up tracking of this fetcher.  The rest will be cleaned up after
     // the timer expires in CleanupTransientState().
     DCHECK_EQ(source, fetchers_[url].second);
     fetchers_.erase(url);
     delete source;
 
     // If all expected responses have been received, cancel the timer and
     // report the result.
     if (fetchers_.empty()) {
       CleanupTransientState();
-      FireGetCheckConnectionInfoCompleted(true);
+      GetCheckConnectionInfoCompleted(true);
     }
   }
 }
 
 void GaiaCookieManagerService::ExternalCcResultFetcher::Timeout() {
   CleanupTransientState();
-  FireGetCheckConnectionInfoCompleted(false);
+  GetCheckConnectionInfoCompleted(false);
 }
 
 void GaiaCookieManagerService::ExternalCcResultFetcher::
     CleanupTransientState() {
   timer_.Stop();
-  gaia_auth_fetcher_.reset();
+  helper_->gaia_auth_fetcher_.reset();
 
   for (URLToTokenAndFetcher::const_iterator it = fetchers_.begin();
        it != fetchers_.end(); ++it) {
     delete it->second.second;
   }
   fetchers_.clear();
 }
 
 void GaiaCookieManagerService::ExternalCcResultFetcher::
-    FireGetCheckConnectionInfoCompleted(bool succeeded) {
+    GetCheckConnectionInfoCompleted(bool succeeded) {
   base::TimeDelta time_to_check_connections =
       base::Time::Now() - m_external_cc_result_start_time_;
   signin_metrics::LogExternalCcResultFetches(succeeded,
                                              time_to_check_connections);
-  FOR_EACH_OBSERVER(Observer, helper_->observer_list_,
-                    GetCheckConnectionInfoCompleted(succeeded));
+
+  helper_->external_cc_result_fetched_ = true;
+  // Since the ExternalCCResultFetcher is only Started in place of calling
+  // StartFetchingMergeSession, we can assume we need to call
+  // StartFetchingMergeSession. If this assumption becomes invalid, a Callback
+  // will need to be passed to Start() and Run() here.
+  helper_->StartFetchingMergeSession();
 }
 
 GaiaCookieManagerService::GaiaCookieManagerService(
     OAuth2TokenService* token_service,
     const std::string& source,
     SigninClient* signin_client)
     : token_service_(token_service),
       signin_client_(signin_client),
       external_cc_result_fetcher_(this),
       gaia_auth_fetcher_backoff_(&kBackoffPolicy),
       gaia_auth_fetcher_retries_(0),
-      source_(source) {
+      source_(source),
+      external_cc_result_fetched_(false) {
 }
 
 GaiaCookieManagerService::~GaiaCookieManagerService() {
   CancelAll();
   DCHECK(requests_.empty());
 }
 
 void GaiaCookieManagerService::AddAccountToCookie(
     const std::string& account_id) {
   DCHECK(!account_id.empty());
@@ skipping 88 matching lines @@
 void GaiaCookieManagerService::SignalComplete(
     const std::string& account_id,
     const GoogleServiceAuthError& error) {
   // Its possible for the observer to delete |this| object.  Don't access
   // access any members after this calling the observer.  This method should
   // be the last call in any other method.
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     OnAddAccountToCookieCompleted(account_id, error));
 }
 
-void GaiaCookieManagerService::StartFetchingExternalCcResult() {
-  if (!external_cc_result_fetcher_.IsRunning())
-    external_cc_result_fetcher_.Start();
-}
-
 void GaiaCookieManagerService::StartLogOutUrlFetch() {
   DCHECK(requests_.front().request_type() == GaiaCookieRequestType::LOG_OUT);
   VLOG(1) << "GaiaCookieManagerService::StartLogOutUrlFetch";
   GURL logout_url(GaiaUrls::GetInstance()->service_logout_url().Resolve(
       base::StringPrintf("?source=%s", source_.c_str())));
   net::URLFetcher* fetcher =
       net::URLFetcher::Create(logout_url, net::URLFetcher::GET, this);
   fetcher->SetRequestContext(signin_client_->GetURLRequestContext());
   fetcher->Start();
 }
 
 void GaiaCookieManagerService::OnUbertokenSuccess(
     const std::string& uber_token) {
+  DCHECK(requests_.front().request_type() ==
+      GaiaCookieRequestType::ADD_ACCOUNT);
   VLOG(1) << "GaiaCookieManagerService::OnUbertokenSuccess"
           << " account=" << requests_.front().account_id();
   gaia_auth_fetcher_retries_ = 0;
   uber_token_ = uber_token;
+
+  if (!external_cc_result_fetched_ &&
+      !external_cc_result_fetcher_.IsRunning()) {
+    external_cc_result_fetcher_.Start();
+    return;
+  }
+
   StartFetchingMergeSession();
 }
 
 void GaiaCookieManagerService::OnUbertokenFailure(
     const GoogleServiceAuthError& error) {
   VLOG(1) << "Failed to retrieve ubertoken"
           << " account=" << requests_.front().account_id()
           << " error=" << error.ToString();
   const std::string account_id = requests_.front().account_id();
   HandleNextRequest();
@@ skipping 40 matching lines @@
                            signin_client_->GetURLRequestContext()));
   uber_token_fetcher_->StartFetchingToken(requests_.front().account_id());
 }
 
 void GaiaCookieManagerService::StartFetchingMergeSession() {
   DCHECK(!uber_token_.empty());
   gaia_auth_fetcher_.reset(
       new GaiaAuthFetcher(this, source_,
                           signin_client_->GetURLRequestContext()));
 
-  // It's possible that not all external checks have completed.
-  // GetExternalCcResult() returns results for those that have.
   gaia_auth_fetcher_->StartMergeSession(uber_token_,
       external_cc_result_fetcher_.GetExternalCcResult());
 }
 
 void GaiaCookieManagerService::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK(requests_.front().request_type() == GaiaCookieRequestType::LOG_OUT);
   VLOG(1) << "GaiaCookieManagerService::OnURLFetchComplete";
   HandleNextRequest();
 }
@@ skipping 11 matching lines @@
         StartFetchingUbertoken();
         break;
       case GaiaCookieRequestType::LOG_OUT:
         StartLogOutUrlFetch();
         break;
       case GaiaCookieRequestType::LIST_ACCOUNTS:
         break;
     };
   }
 }