Android Chromoting: Don't fetch auth token if there's a fetch pending.

remoting/android/java/src/org/chromium/chromoting/Chromoting.java

 // Copyright 2013 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.
 
 package org.chromium.chromoting;
 
 import android.accounts.Account;
 import android.accounts.AccountManager;
 import android.accounts.AccountManagerCallback;
 import android.accounts.AccountManagerFuture;
@@ skipping 78 matching lines @@
     /** Object for fetching OAuth2 access tokens from third party authorization servers. */
     private ThirdPartyTokenFetcher mTokenFetcher;
 
     /**
      * This is set when receiving an authentication error from the HostListLoader. If that occurs,
      * this flag is set and a fresh authentication token is fetched from the AccountsService, and
      * used to request the host list a second time.
      */
     boolean mTriedNewAuthToken;
 
+    /**
+     * Flag to track whether a call to AccountManager.getAuthToken() is currently pending.
+     * This avoids infinitely-nested calls in case onStart() gets triggered a second time
+     * while a token is being fetched.
+     */
+    private boolean mWaitingForAuthToken = false;
+
     /** Shows a warning explaining that a Google account is required, then closes the activity. */
     private void showNoAccountsDialog() {
         AlertDialog.Builder builder = new AlertDialog.Builder(this);
         builder.setMessage(R.string.noaccounts_message);
         builder.setPositiveButton(R.string.noaccounts_add_account,
                 new DialogInterface.OnClickListener() {
                     @SuppressLint("InlinedApi")
                     @Override
                     public void onClick(DialogInterface dialog, int id) {
                         Intent intent = new Intent(Settings.ACTION_ADD_ACCOUNT);
@@ skipping 176 matching lines @@
                       mTokenFetcher = null;
                   }
               });
         SessionConnector connector = new SessionConnector(this, this, mHostListLoader);
         assert mTokenFetcher == null;
         mTokenFetcher = createTokenFetcher(host);
         connector.connectToHost(mAccount.name, mToken, host);
     }
 
     private void refreshHostList() {
+        if (mWaitingForAuthToken) {
+            return;
+        }
+
         mTriedNewAuthToken = false;
         setHostListProgressVisible(true);
 
         // The refresh button simply makes use of the currently-chosen account.
+        requestAuthToken();
+    }
+
+    private void requestAuthToken() {
         AccountManager.get(this).getAuthToken(mAccount, TOKEN_SCOPE, null, this, this, null);
+        mWaitingForAuthToken = true;
     }
 
     @Override
     public void run(AccountManagerFuture<Bundle> future) {
         Log.i("auth", "User finished with auth dialogs");
+        mWaitingForAuthToken = false;
+
         Bundle result = null;
         String explanation = null;
         try {
             // Here comes our auth token from the Android system.
             result = future.getResult();
         } catch (OperationCanceledException ex) {
             // User canceled authentication. No need to report an error.
         } catch (AuthenticatorException ex) {
             explanation = getString(R.string.error_unexpected);
         } catch (IOException ex) {
             explanation = getString(R.string.error_network_error);
         }
 
         if (result == null) {
+            setHostListProgressVisible(false);
             if (explanation != null) {
                 Toast.makeText(this, explanation, Toast.LENGTH_LONG).show();
             }
             return;
         }
 
         mToken = result.getString(AccountManager.KEY_AUTHTOKEN);
         Log.i("auth", "Received an auth token from system");
 
         mHostListLoader.retrieveHostList(mToken, this);
@@ skipping 51 matching lines @@
 
         if (!mTriedNewAuthToken) {
             // This was our first connection attempt.
 
             AccountManager authenticator = AccountManager.get(this);
             mTriedNewAuthToken = true;
 
             Log.w("auth", "Requesting renewal of rejected auth token");
             authenticator.invalidateAuthToken(mAccount.type, mToken);
             mToken = null;
-            authenticator.getAuthToken(mAccount, TOKEN_SCOPE, null, this, this, null);
+            requestAuthToken();

[Jamie, 2014/09/26 21:31:17]

Does this not also need to be guarded against reentry?

[Lambros, 2014/09/26 22:36:34]

No, because we've got the token at this point, so there's no longer a pending
token. Note that mWaitingForAuthToken is set to false at the top of this method.

 
             // We're not in an error state *yet*.
             return;
         } else {
             // Authentication truly failed.
             Log.e("auth", "Fresh auth token was also rejected");
             explanation = getString(R.string.error_authentication_failed);
             Toast.makeText(this, explanation, Toast.LENGTH_LONG).show();
             setHostListProgressVisible(false);
         }
@@ skipping 71 matching lines @@
             }
         };
         return new ThirdPartyTokenFetcher(this, host.getTokenUrlPatterns(), callback);
     }
 
     public void fetchThirdPartyToken(String tokenUrl, String clientId, String scope) {
         assert mTokenFetcher != null;
         mTokenFetcher.fetchToken(tokenUrl, clientId, scope);
     }
 }