Reland "Android: Remove GetApplicationContext part 2"

chrome/android/java/src/org/chromium/chrome/browser/signin/AccountTrackerService.java

 // Copyright 2015 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.content.Context;
 import android.os.AsyncTask;
 
 import org.chromium.base.Callback;
 import org.chromium.base.Log;
 import org.chromium.base.ObserverList;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.components.signin.AccountManagerHelper;
 
 /**
 * Android wrapper of AccountTrackerService which provides access from the java layer.
 * It offers the capability of fetching and seeding system accounts into AccountTrackerService in C++
 * layer, and notifies observers when it is complete.
 */
 @JNINamespace("signin::android")
 public class AccountTrackerService {
     private static final String TAG = "AccountService";
     private static AccountTrackerService sAccountTrackerService;
 
     private SystemAccountsSeedingStatus mSystemAccountsSeedingStatus;
     private boolean mSystemAccountsChanged;
     private boolean mSyncForceRefreshedForTest;
 
-    private final Context mContext;
-
     private enum SystemAccountsSeedingStatus {
         SEEDING_NOT_STARTED,
         SEEDING_IN_PROGRESS,
         SEEDING_DONE,
         SEEDING_VALIDATING
     }
 
     /**
     * Classes that want to listen for system accounts fetching and seeding should implement
     * this interface and register with {@link #addSystemAccountsSeededListener}.
     */
     public interface OnSystemAccountsSeededListener {
         // Called at the end of seedSystemAccounts().
         void onSystemAccountsSeedingComplete();
         // Called in invalidateAccountSeedStatus() indicating that accounts have changed.
         void onSystemAccountsChanged();
     }
 
     private final ObserverList<OnSystemAccountsSeededListener> mSystemAccountsSeedingObservers =
             new ObserverList<>();
 
-    public static AccountTrackerService get(Context context) {
+    public static AccountTrackerService get() {
         ThreadUtils.assertOnUiThread();
         if (sAccountTrackerService == null) {
-            sAccountTrackerService = new AccountTrackerService(context);
+            sAccountTrackerService = new AccountTrackerService();
         }
         return sAccountTrackerService;
     }
 
-    private AccountTrackerService(Context context) {
-        mContext = context;
+    private AccountTrackerService() {
         mSystemAccountsSeedingStatus = SystemAccountsSeedingStatus.SEEDING_NOT_STARTED;
         mSystemAccountsChanged = false;
     }
 
     /**
     * Checks whether the account id <-> email mapping has been seeded into C++ layer.
     * If not, it automatically starts fetching the mapping and seeds it.
     * @return Whether the accounts have been seeded already.
     */
     public boolean checkAndSeedSystemAccounts() {
@@ skipping 28 matching lines @@
     public void removeSystemAccountsSeededListener(OnSystemAccountsSeededListener observer) {
         ThreadUtils.assertOnUiThread();
         mSystemAccountsSeedingObservers.removeObserver(observer);
     }
 
     private void seedSystemAccounts() {
         ThreadUtils.assertOnUiThread();
         mSystemAccountsChanged = false;
         mSyncForceRefreshedForTest = false;
         final AccountIdProvider accountIdProvider = AccountIdProvider.getInstance();
-        if (accountIdProvider.canBeUsed(mContext)) {
+        if (accountIdProvider.canBeUsed()) {
             mSystemAccountsSeedingStatus = SystemAccountsSeedingStatus.SEEDING_IN_PROGRESS;
         } else {
             mSystemAccountsSeedingStatus = SystemAccountsSeedingStatus.SEEDING_NOT_STARTED;
             return;
         }
-        AccountManagerHelper.get(mContext).getGoogleAccounts(new Callback<Account[]>() {
+        AccountManagerHelper.get().getGoogleAccounts(new Callback<Account[]>() {
             @Override
             public void onResult(final Account[] accounts) {
                 new AsyncTask<Void, Void, String[][]>() {
                     @Override
                     public String[][] doInBackground(Void... params) {
                         Log.d(TAG, "Getting id/email mapping");
                         String[][] accountIdNameMap = new String[2][accounts.length];
                         for (int i = 0; i < accounts.length; ++i) {
                             accountIdNameMap[0][i] =
-                                    accountIdProvider.getAccountId(mContext, accounts[i].name);
+                                    accountIdProvider.getAccountId(accounts[i].name);
                             accountIdNameMap[1][i] = accounts[i].name;
                         }
                         return accountIdNameMap;
                     }
                     @Override
                     public void onPostExecute(String[][] accountIdNameMap) {
                         if (mSyncForceRefreshedForTest) return;
                         if (mSystemAccountsChanged) {
                             seedSystemAccounts();
                             return;
@@ skipping 55 matching lines @@
      * created because accounts changed notification from Android to Chrome has latency.
      */
     public void validateSystemAccounts() {
         ThreadUtils.assertOnUiThread();
         if (!checkAndSeedSystemAccounts()) {
             // Do nothing if seeding is not done.
             return;
         }
 
         mSystemAccountsSeedingStatus = SystemAccountsSeedingStatus.SEEDING_VALIDATING;
-        AccountManagerHelper.get(mContext).getGoogleAccounts(new Callback<Account[]>() {
+        AccountManagerHelper.get().getGoogleAccounts(new Callback<Account[]>() {
             @Override
             public void onResult(final Account[] accounts) {
                 if (mSystemAccountsChanged
                         || mSystemAccountsSeedingStatus
                                 != SystemAccountsSeedingStatus.SEEDING_VALIDATING) {
                     return;
                 }
 
                 String[] accountNames = new String[accounts.length];
                 for (int i = 0; i < accounts.length; ++i) {
                     accountNames[i] = accounts[i].name;
                 }
                 if (nativeAreAccountsSeeded(accountNames)) {
                     mSystemAccountsSeedingStatus = SystemAccountsSeedingStatus.SEEDING_DONE;
                     notifyObserversOnSeedingComplete();
                 }
             }
         });
     }
 
     private void notifyObserversOnAccountsChange() {
         for (OnSystemAccountsSeededListener observer : mSystemAccountsSeedingObservers) {
             observer.onSystemAccountsChanged();
         }
     }
 
     private static native void nativeSeedAccountsInfo(String[] gaiaIds, String[] accountNames);
     private static native boolean nativeAreAccountsSeeded(String[] accountNames);
 }