Avoid re-starting a ExternalCCResultFetcher if a previous has finished or timed out.

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 <stddef.h>
 
 #include <queue>
 
@@ skipping 39 matching lines @@
     1000 * 60 * 60 * 4,  // 15 minutes.
 
     // Time to keep an entry from being discarded even when it
     // has no significant state, -1 to never discard.
     -1,
 
     // Don't use initial delay unless the last request was an error.
     false,
 };
 
+// The maximum number of retries for a fetcher used in this class.
 const int kMaxFetcherRetries = 8;
 
 // Name of the GAIA cookie that is being observed to detect when available
 // accounts have changed in the content-area.
 const char* kGaiaCookieName = "APISID";
 
 enum GaiaCookieRequestType {
   ADD_ACCOUNT,
   LOG_OUT_ALL_ACCOUNTS,
   LOG_OUT_ONE_ACCOUNT,
@@ skipping 53 matching lines @@
 GaiaCookieManagerService::ExternalCcResultFetcher::GetExternalCcResult() {
   std::vector<std::string> results;
   for (ResultMap::const_iterator it = results_.begin(); it != results_.end();
        ++it) {
     results.push_back(it->first + ":" + it->second);
   }
   return base::JoinString(results, ",");
 }
 
 void GaiaCookieManagerService::ExternalCcResultFetcher::Start() {
+  DCHECK(!helper_->external_cc_result_fetched_);
   m_external_cc_result_start_time_ = base::Time::Now();
 
   CleanupTransientState();
   results_.clear();
   helper_->gaia_auth_fetcher_.reset(
       helper_->signin_client_->CreateGaiaAuthFetcher(
           this, helper_->GetDefaultSourceForRequest(),
           helper_->request_context()));
   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 helper_->gaia_auth_fetcher_ || fetchers_.size() > 0u;
+  return helper_->gaia_auth_fetcher_ || fetchers_.size() > 0u ||
+         timer_.IsRunning();

[Roger Tawa OOO till Jul 10th, 2017/03/10 16:48:51]

Since there are no longer retries, this change is no longer strictly needed. 
But seems fine to keep it in anyway.

[msarda, 2017/03/10 16:53:20]

This fetcher is running as long as the timer did not fire (once it fires, it is
stopped, right?) So I prefer keeping this check for completeness.

 }
 
 void GaiaCookieManagerService::ExternalCcResultFetcher::TimeoutForTests() {
   Timeout();
 }
 
 void GaiaCookieManagerService::ExternalCcResultFetcher::
     OnGetCheckConnectionInfoSuccess(const std::string& data) {
-  helper_->fetcher_backoff_.InformOfRequest(true);
-  gaia_auth_fetcher_timer_.Stop();
   std::unique_ptr<base::Value> value = base::JSONReader::Read(data);
   const base::ListValue* list;
   if (!value || !value->GetAsList(&list)) {
     CleanupTransientState();
     GetCheckConnectionInfoCompleted(false);
     return;
   }
 
   // If there is nothing to check, terminate immediately.
   if (list->GetSize() == 0) {
@@ skipping 14 matching lines @@
         net::URLFetcher* fetcher = CreateFetcher(GURL(url)).release();
         fetchers_[fetcher->GetOriginalURL()] = std::make_pair(token, fetcher);
         fetcher->Start();
       }
     }
   }
 }
 
 void GaiaCookieManagerService::ExternalCcResultFetcher::
     OnGetCheckConnectionInfoError(const GoogleServiceAuthError& error) {
-  if (++helper_->fetcher_retries_ < kMaxFetcherRetries &&
-      error.IsTransientError()) {
-    helper_->fetcher_backoff_.InformOfRequest(false);
-    gaia_auth_fetcher_timer_.Start(
-        FROM_HERE, helper_->fetcher_backoff_.GetTimeUntilRelease(),
-        this, &GaiaCookieManagerService::ExternalCcResultFetcher::Start);
-    return;
-  }
+  VLOG(1) << "GaiaCookieManagerService::ExternalCcResultFetcher::"
+          << "OnGetCheckConnectionInfoError " << error.ToString();
 
+  // Chrome does not have any retry logic for fetching ExternalCcResult. The
+  // ExternalCcResult is only used to inform Gaia that Chrome has already
+  // checked the connection to other sites.
+  //
+  // In case fetching the ExternalCcResult fails:
+  // * The result of merging accounts to Gaia cookies will not be affected.
+  // * Gaia will need make its own call about whether to check them itself,
+  //   of make some other assumptions.
   CleanupTransientState();
   GetCheckConnectionInfoCompleted(false);
 }
 
 std::unique_ptr<net::URLFetcher>
 GaiaCookieManagerService::ExternalCcResultFetcher::CreateFetcher(
     const GURL& url) {
   std::unique_ptr<net::URLFetcher> fetcher =
       net::URLFetcher::Create(0, url, net::URLFetcher::GET, this);
   fetcher->SetRequestContext(helper_->request_context());
@@ skipping 32 matching lines @@
     // If all expected responses have been received, cancel the timer and
     // report the result.
     if (fetchers_.empty()) {
       CleanupTransientState();
       GetCheckConnectionInfoCompleted(true);
     }
   }
 }
 
 void GaiaCookieManagerService::ExternalCcResultFetcher::Timeout() {
+  VLOG(1) << " GaiaCookieManagerService::ExternalCcResultFetcher::Timeout";
   CleanupTransientState();
   GetCheckConnectionInfoCompleted(false);
 }
 
 void GaiaCookieManagerService::ExternalCcResultFetcher::
     CleanupTransientState() {
   timer_.Stop();
   helper_->gaia_auth_fetcher_.reset();
 
   for (URLToTokenAndFetcher::const_iterator it = fetchers_.begin();
@@ skipping 525 matching lines @@
         break;
       case GaiaCookieRequestType::LIST_ACCOUNTS:
         uber_token_fetcher_.reset();
         signin_client_->DelayNetworkCall(
             base::Bind(&GaiaCookieManagerService::StartFetchingListAccounts,
                        base::Unretained(this)));
         break;
     }
   }
 }