Calls FireRefreshTokenRevoked if an account is removed.

chrome/android/java/src/org/chromium/chrome/browser/signin/OAuth2TokenService.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.chrome.browser.signin;
 
 import android.accounts.Account;
 import android.app.Activity;
 import android.content.Context;
+import android.preference.PreferenceManager;
 import android.util.Log;
 
+import com.google.common.annotations.VisibleForTesting;
+
 import org.chromium.base.CalledByNative;
 import org.chromium.base.ObserverList;
 import org.chromium.base.ThreadUtils;
 import org.chromium.chrome.browser.profiles.Profile;
 import org.chromium.sync.signin.AccountManagerHelper;
 import org.chromium.sync.signin.ChromeSigninController;
 
+import java.util.Arrays;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.HashSet;
+import java.util.Set;
 
 import javax.annotation.Nullable;
 
 /**
  * Java instance for the native OAuth2TokenService.
  * <p/>
  * This class forwards calls to request or invalidate access tokens made by native code to
  * AccountManagerHelper and forwards callbacks to native code.
  * <p/>
  */
 public final class OAuth2TokenService {
 
     private static final String TAG = "OAuth2TokenService";
 
+    @VisibleForTesting
+    public static final String STORED_ACCOUNTS_KEY = "google.services.stored_accounts";
+
     public interface OAuth2TokenServiceObserver {
         void onRefreshTokenAvailable(Account account);
         void onRefreshTokenRevoked(Account account);
         void onRefreshTokensLoaded();
     }
 
     private static final String OAUTH2_SCOPE_PREFIX = "oauth2:";
 
     private final long mNativeProfileOAuth2TokenService;
     private final ObserverList<OAuth2TokenServiceObserver> mObservers;
@@ skipping 33 matching lines @@
         AccountManagerHelper accountManagerHelper = AccountManagerHelper.get(context);
         Account account = accountManagerHelper.getAccountFromName(username);
         if (account == null) {
             Log.e(TAG, "Account not found for provided username.");
             return null;
         }
         return account;
     }
 
     /**
-     * Called by native to list the accounts with OAuth2 refresh tokens.
+     * Called by native to list the activite accounts in the OS.
      */
+    @VisibleForTesting
     @CalledByNative
-    public static String[] getAccounts(Context context) {
+    public static String[] getSystemAccounts(Context context) {
         AccountManagerHelper accountManagerHelper = AccountManagerHelper.get(context);
         java.util.List<String> accountNames = accountManagerHelper.getGoogleAccountNames();
         return accountNames.toArray(new String[accountNames.size()]);
     }
 
     /**
+     * Called by native to list the accounts with OAuth2 refresh tokens.
+     * This can differ from getSystemAccounts as the user add/remove accounts
+     * from the OS. validateAccounts should be called to keep these two
+     * in sync.
+     */
+    @CalledByNative
+    public static String[] getAccounts(Context context) {
+        return getStoredAccounts(context);
+    }
+
+    /**
      * Called by native to retrieve OAuth2 tokens.
      *
      * @param username The native username (full address).
      * @param scope The scope to get an auth token for (without Android-style 'oauth2:' prefix).
      * @param nativeCallback The pointer to the native callback that should be run upon completion.
      */
     @CalledByNative
     public static void getOAuth2AuthToken(
             Context context, String username, String scope, final long nativeCallback) {
         Account account = getAccountOrNullFromUsername(context, username);
@@ skipping 86 matching lines @@
     public static void invalidateOAuth2AuthToken(Context context, String accessToken) {
         if (accessToken != null) {
             AccountManagerHelper.get(context).invalidateAuthToken(accessToken);
         }
     }
 
     public void validateAccounts(Context context) {
         ThreadUtils.assertOnUiThread();
         String currentlySignedInAccount =
                 ChromeSigninController.get(context).getSignedInAccountName();
-        String[] accounts = getAccounts(context);
-        nativeValidateAccounts(
-                mNativeProfileOAuth2TokenService, accounts, currentlySignedInAccount);
+        nativeValidateAccounts(mNativeProfileOAuth2TokenService, currentlySignedInAccount);
     }
 
     /**
      * Triggers a notification to all observers of the native and Java instance of the
      * OAuth2TokenService that a refresh token is now available. This may cause observers to retry
      * operations that require authentication.
      */
     public void fireRefreshTokenAvailable(Account account) {
         ThreadUtils.assertOnUiThread();
         assert account != null;
@@ skipping 37 matching lines @@
         nativeFireRefreshTokensLoadedFromJava(mNativeProfileOAuth2TokenService);
     }
 
     @CalledByNative
     public void notifyRefreshTokensLoaded() {
         for (OAuth2TokenServiceObserver observer : mObservers) {
             observer.onRefreshTokensLoaded();
         }
     }
 
+    private static String[] getStoredAccounts(Context context) {
+        Set<String> accounts =
+                PreferenceManager.getDefaultSharedPreferences(context)
+                        .getStringSet(STORED_ACCOUNTS_KEY, null);
+        return accounts == null ? new String[]{} : accounts.toArray(new String[accounts.size()]);
+    }
+
+    @CalledByNative
+    private static void saveStoredAccounts(Context context, String[] accounts) {
+        Set<String> set = new HashSet<String>(Arrays.asList(accounts));
+        PreferenceManager.getDefaultSharedPreferences(context).edit().
+                putStringSet(STORED_ACCOUNTS_KEY, set).apply();
+    }
+
     private static native Object nativeGetForProfile(Profile profile);
     private static native void nativeOAuth2TokenFetched(
             String authToken, boolean result, long nativeCallback);
     private native void nativeValidateAccounts(
             long nativeAndroidProfileOAuth2TokenService,
-            String[] accounts, String currentlySignedInAccount);
+            String currentlySignedInAccount);
     private native void nativeFireRefreshTokenAvailableFromJava(
             long nativeAndroidProfileOAuth2TokenService, String accountName);
     private native void nativeFireRefreshTokenRevokedFromJava(
             long nativeAndroidProfileOAuth2TokenService, String accountName);
     private native void nativeFireRefreshTokensLoadedFromJava(
             long nativeAndroidProfileOAuth2TokenService);
 }