Use GoogleAuthUtil's getToken instead of AccountManager

sync/android/java/src/org/chromium/sync/signin/AccountManagerHelper.java

 // Copyright 2011 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.sync.signin;
 
 
 import android.Manifest;
 import android.accounts.Account;
-import android.accounts.AccountManager;
-import android.accounts.AccountManagerFuture;
 import android.accounts.AuthenticatorDescription;
-import android.accounts.AuthenticatorException;
-import android.accounts.OperationCanceledException;
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.os.AsyncTask;
 import android.os.Build;
-import android.os.Bundle;
 import android.os.Process;
-import android.util.Log;
 
 import org.chromium.base.Callback;
-import org.chromium.base.ThreadUtils;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.net.NetworkChangeNotifier;
 
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.regex.Pattern;
 
 /**
  * AccountManagerHelper wraps our access of AccountManager in Android.
  *
@@ skipping 309 matching lines @@
         return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
                 || mApplicationContext.checkPermission("android.permission.USE_CREDENTIALS",
                 Process.myPid(), Process.myUid()) == PackageManager.PERMISSION_GRANTED;
     }
 
     public boolean hasGetAccountsPermission() {
         return mApplicationContext.checkPermission(Manifest.permission.GET_ACCOUNTS,
                 Process.myPid(), Process.myUid()) == PackageManager.PERMISSION_GRANTED;
     }
 
-    // Gets the auth token synchronously
-    private String getAuthTokenInner(AccountManagerFuture<Bundle> future,
-            AtomicBoolean isTransientError) {
-        try {
-            Bundle result = future.getResult();
-            if (result != null) {
-                return result.getString(AccountManager.KEY_AUTHTOKEN);
-            } else {
-                Log.w(TAG, "Auth token - getAuthToken returned null");
-            }
-        } catch (OperationCanceledException e) {
-            Log.w(TAG, "Auth token - operation cancelled", e);
-        } catch (AuthenticatorException e) {
-            Log.w(TAG, "Auth token - authenticator exception", e);
-        } catch (IOException e) {
-            Log.w(TAG, "Auth token - IO exception", e);
-            isTransientError.set(true);
-        }
-        return null;
-    }
-
     private void getAuthTokenAsynchronously(final Account account, final String authTokenType,
             final GetAuthTokenCallback callback, final AtomicInteger numTries,
             final AtomicBoolean isTransientError, final ConnectionRetry retry) {
-        // Return null token for no USE_CREDENTIALS permission.
-        if (!hasUseCredentialsPermission()) {
-            ThreadUtils.runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    callback.tokenUnavailable(false);
-                }
-            });
-            return;
-        }
-        final AccountManagerFuture<Bundle> future = mAccountManager.getAuthToken(
-                account, authTokenType, true, null, null);
         isTransientError.set(false);
-
         new AsyncTask<Void, Void, String>() {
             @Override
             public String doInBackground(Void... params) {
-                return getAuthTokenInner(future, isTransientError);
+                try {
+                    return mAccountManager.getAuthToken(account, authTokenType);
+                } catch (AuthException ex) {
+                    isTransientError.set(ex.isTransientError());

[Bernhard Bauer, 2015/11/19 15:23:33]

Can you add a TODO here to handle the recovery intent?

[knn, 2015/11/19 16:09:25]

Done.

+                }
+                return null;
             }
             @Override
             public void onPostExecute(String authToken) {
                 onGotAuthTokenResult(account, authTokenType, authToken, callback, numTries,
                         isTransientError, retry);
             }
         }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
     }
 
     private void onGotAuthTokenResult(Account account, String authTokenType, String authToken,
@@ skipping 42 matching lines @@
         if (authToken != null && !authToken.isEmpty()) {
             mAccountManager.invalidateAuthToken(GOOGLE_ACCOUNT_TYPE, authToken);
         }
     }
 
     public void checkChildAccount(Account account, Callback<Boolean> callback) {
         String[] features = {FEATURE_IS_CHILD_ACCOUNT_KEY};
         mAccountManager.hasFeatures(account, features, callback);
     }
 }