Retry fetching OAuth1 request token on failure

chrome/browser/chromeos/login/login_utils.cc

 // Copyright (c) 2012 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/login/login_utils.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/ash_switches.h"
@@ skipping 76 matching lines @@
 #include "ui/compositor/compositor_switches.h"
 #include "ui/gl/gl_switches.h"
 #include "webkit/plugins/plugin_switches.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
 
 namespace {
 
-// OAuth token verification retry count.
+// OAuth token verification max retry count.
 const int kMaxOAuthTokenVerificationAttemptCount = 5;
-// OAuth token verification retry delay.
-const int kOAuthVerificationRestartDelay = 10000;  // ms
+// OAuth token verification retry delay in milliseconds.
+const int kOAuthVerificationRestartDelay = 10000;
+
+// OAuth token request max retry count.
+const int kMaxOAuthTokenRequestAttemptCount = 5;
+// OAuth token request retry delay in milliseconds.
+const int kOAuthTokenRequestRestartDelay = 3000;
 
 // Affixes for Auth token received from ClientLogin request.
 const char kAuthPrefix[] = "Auth=";
 const char kAuthSuffix[] = "\n";
 
 // Increase logging level for Guest mode to avoid LOG(INFO) messages in logs.
 const char kGuestModeLoggingLevel[] = "1";
 
 // Format of command line switch.
 const char kSwitchFormatString[] = " --%s=\"%s\"";
@@ skipping 216 matching lines @@
 
   virtual void OnOAuthLoginFailure(
       const GoogleServiceAuthError& error) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     LOG(WARNING) << "Failed to verify OAuth1 access tokens,"
                  << " error.state=" << error.state();
     if (!RetryOnError(error))
       delegate_->OnOAuthVerificationFailed(username_);
   }
 
-  void OnCookueFetchFailed(const GoogleServiceAuthError& error) {
+  void OnCookieFetchFailed(const GoogleServiceAuthError& error) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!RetryOnError(error))
       delegate_->OnUserCookiesFetchFailed(username_);
   }
 
   // GaiaAuthConsumer overrides.
   virtual void OnIssueAuthTokenSuccess(const std::string& service,
                                        const std::string& auth_token) OVERRIDE {
     gaia_fetcher_.StartMergeSession(auth_token);
   }
 
   virtual void OnIssueAuthTokenFailure(const std::string& service,
       const GoogleServiceAuthError& error) OVERRIDE {
     DVLOG(1) << "Failed IssueAuthToken request,"
              << " error.state=" << error.state();
-    OnCookueFetchFailed(error);
+    OnCookieFetchFailed(error);
   }
 
   virtual void OnMergeSessionSuccess(const std::string& data) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DVLOG(1) << "MergeSession successful.";
     step_ = VERIFICATION_STEP_COOKIES_FETCHED;
     delegate_->OnUserCookiesFetchSucceeded(username_);
   }
 
   virtual void OnMergeSessionFailure(
       const GoogleServiceAuthError& error) OVERRIDE {
     DVLOG(1) << "Failed MergeSession request,"
              << " error.state=" << error.state();
-    OnCookueFetchFailed(error);
+    OnCookieFetchFailed(error);
   }
 
   OAuthLoginVerifier::Delegate* delegate_;
   GaiaOAuthFetcher oauth_fetcher_;
   GaiaAuthFetcher gaia_fetcher_;
   std::string oauth1_token_;
   std::string oauth1_secret_;
   std::string sid_;
   std::string lsid_;
   std::string username_;
@@ skipping 163 matching lines @@
       public OAuthLoginVerifier::Delegate,
       public net::NetworkChangeNotifier::ConnectionTypeObserver,
       public base::SupportsWeakPtr<LoginUtilsImpl> {
  public:
   LoginUtilsImpl()
       : pending_requests_(false),
         using_oauth_(false),
         has_cookies_(false),
         delegate_(NULL),
         job_restart_request_(NULL),
-        should_restore_auth_session_(false) {
+        should_restore_auth_session_(false),
+        token_request_count_(0) {
     net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
   }
 
   virtual ~LoginUtilsImpl() {
     net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
   }
 
   // LoginUtils implementation:
   virtual void DoBrowserLaunch(Profile* profile,
                                LoginDisplayHost* login_host) OVERRIDE;
@@ skipping 107 matching lines @@
   // Delegate to be fired when the profile will be prepared.
   LoginUtils::Delegate* delegate_;
 
   // Used to restart Chrome to switch to the guest mode.
   JobRestartRequest* job_restart_request_;
 
   // True if should restore authentication session when notified about
   // online state change.
   bool should_restore_auth_session_;
 
+  // Number of retries we have requested for OAuth1 access token.
+  int token_request_count_;
+
   DISALLOW_COPY_AND_ASSIGN(LoginUtilsImpl);
 };
 
 class LoginUtilsWrapper {
  public:
   static LoginUtilsWrapper* GetInstance() {
     return Singleton<LoginUtilsWrapper>::get();
   }
 
   LoginUtils* get() {
@@ skipping 194 matching lines @@
       // TODO(xiyuan): Change back to use authenticator to verify token when
       // we support Gaia in lock screen.
       VerifyOAuth1AccessToken(user_profile, oauth1_token, oauth1_secret);
     } else {
       // If we don't have it, fetch OAuth1 access token.
       // Use off-the-record profile that was used for this step. It should
       // already contain all needed cookies that will let us skip GAIA's user
       // authentication UI.
       //
       // TODO(rickcam) We should use an isolated App here.
-      FetchOAuth1AccessToken(authenticator_->authentication_profile());
+      NetworkLibrary* network_library = CrosLibrary::Get()->GetNetworkLibrary();
+      if (network_library && network_library->Connected()) {
+        FetchOAuth1AccessToken(authenticator_->authentication_profile());
+      } else {
+        VLOG(1) << "Network is unreacheable; deferring token request.";
+        BrowserThread::PostDelayedTask(
+            BrowserThread::UI, FROM_HERE,
+            base::Bind(&LoginUtilsImpl::FetchOAuth1AccessToken,
+                       base::Unretained(this),
+                       authenticator_->authentication_profile()),
+            base::TimeDelta::FromMilliseconds(kOAuthTokenRequestRestartDelay));
+      }
     }
   }
 
   // Own TPM device if, for any reason, it has not been done in EULA
   // wizard screen.
   CryptohomeLibrary* cryptohome = CrosLibrary::Get()->GetCryptohomeLibrary();
   btl->AddLoginTimeMarker("TPMOwn-Start", false);
   if (cryptohome->TpmIsEnabled() && !cryptohome->TpmIsBeingOwned()) {
     if (cryptohome->TpmIsOwned()) {
       cryptohome->TpmClearStoredPassword();
@@ skipping 362 matching lines @@
 }
 
 void LoginUtilsImpl::StopBackgroundFetchers() {
   oauth_fetcher_.reset();
   policy_oauth_fetcher_.reset();
   oauth_login_verifier_.reset();
 }
 
 void LoginUtilsImpl::OnGetOAuthTokenSuccess(const std::string& oauth_token) {
   VLOG(1) << "Got OAuth request token!";
+  token_request_count_ = 0;
 }
 
 void LoginUtilsImpl::OnGetOAuthTokenFailure(
     const GoogleServiceAuthError& error) {
-  // TODO(zelidrag): Pop up sync setup UI here?
   LOG(WARNING) << "Failed fetching OAuth request token, error: "
                << error.state();
+  // If the request failed due to network flakiness, try again.

[zel, 2012/05/25 15:19:36]

Since this process is no longer super simple, let's get OAuth1 token fetching
login out of LoginUtilsImpl class - just as we did with its verification. 

[kochi, 2012/05/28 08:46:12]

Done.

+  if (error.state() == GoogleServiceAuthError::SERVICE_UNAVAILABLE &&

[Nikita (slow), 2012/05/25 18:12:08]

error.state() == GoogleServiceAuthError::CONNECTION_FAILED ||
error.state() == GoogleServiceAuthError::SERVICE_UNAVAILABLE ||
error.state() == GoogleServiceAuthError::REQUEST_CANCELED)

See RetryOnError()

[kochi, 2012/05/28 08:46:12]

Done.

+      token_request_count_++ < kMaxOAuthTokenRequestAttemptCount) {
+    BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE,
+        base::Bind(&LoginUtilsImpl::FetchOAuth1AccessToken,
+                   base::Unretained(this),
+                   authenticator_->authentication_profile()),
+        base::TimeDelta::FromMilliseconds(kOAuthTokenRequestRestartDelay));
+    return;
+  }
+  LOG(WARNING) << "Unrecoverable error or retry count max reached, giving up.";
 }
 
 void LoginUtilsImpl::OnOAuthGetAccessTokenSuccess(const std::string& token,
                                                   const std::string& secret) {
   VLOG(1) << "Got OAuth v1 token!";
   Profile* user_profile = ProfileManager::GetDefaultProfile();
   StoreOAuth1AccessToken(user_profile, token, secret);
 
   // Verify OAuth1 token by doing OAuthLogin and fetching credentials.
   VerifyOAuth1AccessToken(user_profile, token, secret);
@@ skipping 123 matching lines @@
 void LoginUtilsImpl::OnOAuthVerificationSucceeded(
     const std::string& user_name, const std::string& sid,
     const std::string& lsid, const std::string& auth) {
   // Kick off sync engine.
   GaiaAuthConsumer::ClientLoginResult credentials(sid, lsid, auth,
                                                   std::string());
   StartSignedInServices(ProfileManager::GetDefaultProfile(), credentials);
 }
 
 
 void LoginUtilsImpl::OnConnectionTypeChanged(

[zel, 2012/05/25 15:19:36]

when we detect nw changes, you should be able to restart OAuth1 token fetching
(not just verification) if it hasn't been completed already

[kochi, 2012/05/28 08:46:12]

This is done in the new class.

On 2012/05/25 15:19:36, zel wrote:

     net::NetworkChangeNotifier::ConnectionType type) {
   if (type != net::NetworkChangeNotifier::CONNECTION_NONE &&
       UserManager::Get()->IsUserLoggedIn()) {
     if (oauth_login_verifier_.get() &&
         !oauth_login_verifier_->is_done()) {
       // If we come online for the first time after successful offline login,
       // we need to kick of OAuth token verification process again.
       oauth_login_verifier_->ContinueVerification();
     } else if (should_restore_auth_session_) {
       should_restore_auth_session_ = false;
@@ skipping 17 matching lines @@
 bool LoginUtils::IsWhitelisted(const std::string& username) {
   CrosSettings* cros_settings = CrosSettings::Get();
   bool allow_new_user = false;
   cros_settings->GetBoolean(kAccountsPrefAllowNewUser, &allow_new_user);
   if (allow_new_user)
     return true;
   return cros_settings->FindEmailInList(kAccountsPrefUsers, username);
 }
 
 }  // namespace chromeos