arc: Implement retry logic for transient errors

chrome/browser/chromeos/arc/arc_auth_context.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 "chrome/browser/chromeos/arc/arc_auth_context.h"
 
 #include "base/callback_helpers.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chromeos/arc/arc_support_host.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/signin/signin_ui_util.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/common/url_constants.h"
 #include "google_apis/gaia/gaia_auth_fetcher.h"
 #include "google_apis/gaia/gaia_constants.h"
 
 namespace arc {
 
 namespace {
 
+constexpr int kRetryCnt = 3;

[Luis Héctor Chávez, 2017/05/17 21:29:24]

nit: kMaxRetryAttempts

[khmel, 2017/05/17 21:37:20]

Done.

+
 constexpr base::TimeDelta kRefreshTokenTimeout =
     base::TimeDelta::FromSeconds(10);
 
+constexpr base::TimeDelta kRetryTimeout = base::TimeDelta::FromSeconds(10);

[Luis Héctor Chávez, 2017/05/17 21:29:24]

Do you actually need this? It's the same as kRefreshTokenTimeout.

[khmel, 2017/05/17 21:37:20]

Let keep it separately. It is for different things.

+
 }  // namespace
 
 ArcAuthContext::ArcAuthContext(Profile* profile) {
   // Reuse storage used in ARC OptIn platform app.
   const std::string site_url =
       base::StringPrintf("%s://%s/persist?%s", content::kGuestScheme,
                          kPlayStoreAppId, ArcSupportHost::kStorageId);
   storage_partition_ = content::BrowserContext::GetStoragePartitionForSite(
       profile, GURL(site_url));
   CHECK(storage_partition_);
@@ skipping 15 matching lines @@
 
 void ArcAuthContext::Prepare(const PrepareCallback& callback) {
   if (context_prepared_) {
     callback.Run(storage_partition_->GetURLRequestContext());
     return;
   }
 
   callback_ = callback;
   token_service_->RemoveObserver(this);
   refresh_token_timeout_.Stop();
+  ResetFetchers();
 
   if (!token_service_->RefreshTokenIsAvailable(account_id_)) {
     token_service_->AddObserver(this);
     refresh_token_timeout_.Start(FROM_HERE, kRefreshTokenTimeout, this,
                                  &ArcAuthContext::OnRefreshTokenTimeout);
     return;
   }
 
+  retry_attempt_count_ = 0;
   StartFetchers();
 }
 
 void ArcAuthContext::OnRefreshTokenAvailable(const std::string& account_id) {
   if (account_id != account_id_)
     return;
   OnRefreshTokensLoaded();
 }
 
 void ArcAuthContext::OnRefreshTokensLoaded() {
@@ skipping 10 matching lines @@
 
 void ArcAuthContext::StartFetchers() {
   DCHECK(!refresh_token_timeout_.IsRunning());
   ResetFetchers();
   ubertoken_fetcher_.reset(
       new UbertokenFetcher(token_service_, this, GaiaConstants::kChromeOSSource,
                            storage_partition_->GetURLRequestContext()));
   ubertoken_fetcher_->StartFetchingToken(account_id_);
 }
 
+void ArcAuthContext::ResetFetchers() {
+  merger_fetcher_.reset();
+  ubertoken_fetcher_.reset();
+  retry_timeout_.Stop();
+}
+
+void ArcAuthContext::OnFetchersError(const GoogleServiceAuthError& error) {
+  ResetFetchers();
+  DCHECK(error.state() != GoogleServiceAuthError::NONE);
+  if (error.IsTransientError()) {
+    if (retry_attempt_count_ < kRetryCnt) {
+      ++retry_attempt_count_;
+      LOG(WARNING) << "Found transient error. Retry attempt "
+                   << retry_attempt_count_;
+      refresh_token_timeout_.Start(FROM_HERE, kRetryTimeout, this,
+                                   &ArcAuthContext::StartFetchers);
+      return;
+    }
+    LOG(WARNING) << "Too many transient errors. Stop retrying.";
+  }
+  base::ResetAndReturn(&callback_).Run(nullptr);
+}
+
 void ArcAuthContext::OnUbertokenSuccess(const std::string& token) {
   ResetFetchers();
   merger_fetcher_.reset(
       new GaiaAuthFetcher(this, GaiaConstants::kChromeOSSource,
                           storage_partition_->GetURLRequestContext()));
   merger_fetcher_->StartMergeSession(token, std::string());
 }
 
 void ArcAuthContext::OnUbertokenFailure(const GoogleServiceAuthError& error) {
   LOG(WARNING) << "Failed to get ubertoken " << error.ToString() << ".";
-  ResetFetchers();
-  base::ResetAndReturn(&callback_).Run(nullptr);
+  OnFetchersError(error);
 }
 
 void ArcAuthContext::OnMergeSessionSuccess(const std::string& data) {
+  if (retry_attempt_count_)
+    VLOG(1) << "Auth context was successfully prepared after retry.";
   context_prepared_ = true;
   ResetFetchers();
   base::ResetAndReturn(&callback_)
       .Run(storage_partition_->GetURLRequestContext());
 }
 
 void ArcAuthContext::OnMergeSessionFailure(
     const GoogleServiceAuthError& error) {
   LOG(WARNING) << "Failed to merge gaia session " << error.ToString() << ".";
-  ResetFetchers();
-  base::ResetAndReturn(&callback_).Run(nullptr);
-}
-
-void ArcAuthContext::ResetFetchers() {
-  merger_fetcher_.reset();
-  ubertoken_fetcher_.reset();
+  OnFetchersError(error);
 }
 
 }  // namespace arc