Add robustness against OAuth2 Token requests getting canceled.

components/ntp_snippets/ntp_snippets_fetcher.cc

 // Copyright 2016 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/ntp_snippets/ntp_snippets_fetcher.h"
 
 #include <stdlib.h>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 151 matching lines @@
       parse_json_callback_(parse_json_callback),
       fetch_url_(GetFetchEndpoint()),
       fetch_api_(UsesChromeContentSuggestionsAPI(fetch_url_)
                      ? CHROME_CONTENT_SUGGESTIONS_API
                      : CHROME_READER_API),
       is_stable_channel_(is_stable_channel),
       tick_clock_(new base::DefaultTickClock()),
       request_throttler_(
           pref_service,
           RequestThrottler::RequestType::CONTENT_SUGGESTION_FETCHER),
+      oauth_token_retried_(false),
       weak_ptr_factory_(this) {
   // Parse the variation parameters and set the defaults if missing.
   std::string personalization = variations::GetVariationParamValue(
       ntp_snippets::kStudyName, kPersonalizationName);
   if (personalization == kPersonalizationNonPersonalString) {
     personalization_ = Personalization::kNonPersonal;
   } else if (personalization == kPersonalizationPersonalString) {
     personalization_ = Personalization::kPersonal;
   } else {
     personalization_ = Personalization::kBoth;
@@ skipping 43 matching lines @@
     return;
   }
 
   locale_ = PosixLocaleFromBCP47Language(language_code);
   count_to_fetch_ = count;
 
   bool use_authentication = UsesAuthentication();
 
   if (use_authentication && signin_manager_->IsAuthenticated()) {
     // Signed-in: get OAuth token --> fetch snippets.
+    oauth_token_retried_ = false;
     StartTokenRequest();
   } else if (use_authentication && signin_manager_->AuthInProgress()) {
     // Currently signing in: wait for auth to finish (the refresh token) -->
     //     get OAuth token --> fetch snippets.
     if (!waiting_for_refresh_token_) {
       // Wait until we get a refresh token.
       waiting_for_refresh_token_ = true;
       token_service_->AddObserver(this);
     }
   } else {
@@ skipping 150 matching lines @@
     const std::string& oauth_access_token) {
   RequestParams params;
   params.fetch_api = fetch_api_;
   params.obfuscated_gaia_id = account_id;
   params.only_return_personalized_results =
       personalization_ == Personalization::kPersonal;
   params.user_locale = locale_;
   params.host_restricts =
       UsesHostRestrictions() ? hosts_ : std::set<std::string>();
   params.count_to_fetch = count_to_fetch_;
+  // TODO(jkrcal, treib): Add unit-tests for authenticated fetches.
   FetchSnippetsImpl(fetch_url_,
                     base::StringPrintf(kAuthorizationRequestHeaderFormat,
                                        oauth_access_token.c_str()),
                     params.BuildRequest());
 }
 
 void NTPSnippetsFetcher::StartTokenRequest() {
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(fetch_api_ == CHROME_CONTENT_SUGGESTIONS_API
                     ? kContentSuggestionsApiScope
@@ skipping 14 matching lines @@
   DCHECK_EQ(oauth_request.get(), request)
       << "Got tokens from some previous request";
 
   FetchSnippetsAuthenticated(oauth_request->GetAccountId(), access_token);
 }
 
 void NTPSnippetsFetcher::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   oauth_request_.reset();
-  DLOG(ERROR) << "Unable to get token: " << error.ToString()
-              << " - fetching the snippets without authentication.";
+
+  if (!oauth_token_retried_ &&
+      error.state() == GoogleServiceAuthError::State::REQUEST_CANCELED) {
+    // The request (especially on startup) can get reset by loading the refresh
+    // token - do it one more time.
+    oauth_token_retried_ = true;
+    StartTokenRequest();
+    return;
+  }
+
+  DLOG(ERROR) << "Unable to get token: " << error.ToString();
   FetchFinished(
       OptionalSnippets(), FetchResult::OAUTH_TOKEN_ERROR,
       /*extra_message=*/base::StringPrintf(" (%s)", error.ToString().c_str()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // OAuth2TokenService::Observer overrides
 void NTPSnippetsFetcher::OnRefreshTokenAvailable(
     const std::string& account_id) {
   // Only react on tokens for the account the user has signed in with.
   if (account_id != signin_manager_->GetAuthenticatedAccountId())
     return;
 
   token_service_->RemoveObserver(this);
   waiting_for_refresh_token_ = false;
+  oauth_token_retried_ = false;
   StartTokenRequest();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // URLFetcherDelegate overrides
 void NTPSnippetsFetcher::OnURLFetchComplete(const URLFetcher* source) {
   DCHECK_EQ(url_fetcher_.get(), source);
 
   const URLRequestStatus& status = source->GetStatus();
 
@@ skipping 103 matching lines @@
   }
   UMA_HISTOGRAM_ENUMERATION("NewTabPage.Snippets.FetchResult",
                             static_cast<int>(result),
                             static_cast<int>(FetchResult::RESULT_MAX));
 
   if (!snippets_available_callback_.is_null())
     snippets_available_callback_.Run(std::move(snippets));
 }
 
 }  // namespace ntp_snippets