Android: Remove GetApplicationContext part 2

chrome/android/javatests/src/org/chromium/chrome/browser/signin/OAuth2TokenServiceIntegrationTest.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.content.Context;
 import android.support.test.InstrumentationRegistry;
 import android.support.test.filters.MediumTest;
@@ skipping 57 matching lines @@
         mActivityTestRule.loadNativeLibraryAndInitBrowserProcess();
 
         // Set up AccountManager.
         mContext = new AdvancedMockContext(
                 InstrumentationRegistry.getInstrumentation().getTargetContext());
         mAccountManager = new MockAccountManager(
                 mContext, InstrumentationRegistry.getInstrumentation().getContext());
         AccountManagerHelper.overrideAccountManagerHelperForTests(mContext, mAccountManager);
 
         // Make sure there is no account signed in yet.
-        mChromeSigninController = ChromeSigninController.get(mContext);
+        mChromeSigninController = ChromeSigninController.get();
         mChromeSigninController.setSignedInAccountName(null);
 
         // Seed test accounts to AccountTrackerService.
         seedAccountTrackerService(mContext);
 
         // Get a reference to the service.
         mOAuth2TokenService = getOAuth2TokenServiceOnUiThread();
 
         // Set up observer.
         mObserver = new TestObserver();
         addObserver(mObserver);
     }
 
     @After
     public void tearDown() throws Exception {
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
                 mChromeSigninController.setSignedInAccountName(null);
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
             }
         });
     }
 
     private void mapAccountNamesToIds() {
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
                 AccountIdProvider.setInstanceForTest(new AccountIdProvider() {
                     @Override
-                    public String getAccountId(Context ctx, String accountName) {
+                    public String getAccountId(String accountName) {
                         return "gaia-id-" + accountName;
                     }
 
                     @Override
-                    public boolean canBeUsed(Context ctx) {
+                    public boolean canBeUsed() {
                         return true;
                     }
                 });
             }
         });
     }
 
     private void seedAccountTrackerService(final Context context) {
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
                 AccountIdProvider provider = AccountIdProvider.getInstance();
                 String[] accountNames = {TEST_ACCOUNT1.name, TEST_ACCOUNT2.name};
-                String[] accountIds = {provider.getAccountId(context, accountNames[0]),
-                        provider.getAccountId(context, accountNames[1])};
-                AccountTrackerService.get(context).syncForceRefreshForTest(
-                        accountIds, accountNames);
+                String[] accountIds = {provider.getAccountId(accountNames[0]),
+                        provider.getAccountId(accountNames[1])};
+                AccountTrackerService.get().syncForceRefreshForTest(accountIds, accountNames);
             }
         });
     }
 
     /**
      * The {@link OAuth2TokenService} and the {@link Profile} can only be accessed from the UI
      * thread, so this helper method is a convenience method to retrieve it.
      *
      * @return the OAuth2TokenService.
      */
@@ skipping 95 matching lines @@
         });
     }
 
     @Test
     @MediumTest
     public void testValidateAccountsNoAccountsRegisteredAndNoSignedInUser() throws Throwable {
         mUiThreadTestRule.runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 // Run test.
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
 
                 // Ensure no calls have been made to the observer.
                 Assert.assertEquals(0, mObserver.getAvailableCallCount());
                 Assert.assertEquals(0, mObserver.getRevokedCallCount());
                 Assert.assertEquals(0, mObserver.getLoadedCallCount());
             }
         });
     }
 
     @Test
     @MediumTest
     public void testValidateAccountsOneAccountsRegisteredAndNoSignedInUser() throws Throwable {
         mUiThreadTestRule.runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 // Add account.
                 mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
 
                 // Run test.
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
 
                 // Ensure no calls have been made to the observer.
                 Assert.assertEquals(0, mObserver.getAvailableCallCount());
                 Assert.assertEquals(0, mObserver.getRevokedCallCount());
                 Assert.assertEquals(0, mObserver.getLoadedCallCount());
             }
         });
     }
 
     @Test
     @MediumTest
     public void testValidateAccountsOneAccountsRegisteredSignedIn() throws Throwable {
         mUiThreadTestRule.runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 // Add account.
                 mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
 
                 // Mark user as signed in.
                 mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 
                 // Run test.
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
 
                 // Ensure one call for the signed in account.
                 Assert.assertEquals(1, mObserver.getAvailableCallCount());
                 Assert.assertEquals(0, mObserver.getRevokedCallCount());
                 Assert.assertEquals(0, mObserver.getLoadedCallCount());
 
                 // Validate again and make sure no new calls are made.
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
                 Assert.assertEquals(1, mObserver.getAvailableCallCount());
                 Assert.assertEquals(0, mObserver.getRevokedCallCount());
                 Assert.assertEquals(0, mObserver.getLoadedCallCount());
 
                 // Validate again with force notifications and make sure one new calls is made.
-                mOAuth2TokenService.validateAccounts(mContext, true);
+                mOAuth2TokenService.validateAccounts(true);
                 Assert.assertEquals(2, mObserver.getAvailableCallCount());
                 Assert.assertEquals(0, mObserver.getRevokedCallCount());
                 Assert.assertEquals(0, mObserver.getLoadedCallCount());
             }
         });
     }
 
     @Test
     @MediumTest
     public void testValidateAccountsSingleAccountWithoutChanges() throws Throwable {
         mUiThreadTestRule.runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 // Add account.
                 mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
 
                 // Mark user as signed in.
                 mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 
                 // Run one validation.
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
                 Assert.assertEquals(1, mObserver.getAvailableCallCount());
                 Assert.assertEquals(0, mObserver.getRevokedCallCount());
                 Assert.assertEquals(0, mObserver.getLoadedCallCount());
 
                 // Re-run validation.
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
                 Assert.assertEquals(1, mObserver.getAvailableCallCount());
                 Assert.assertEquals(0, mObserver.getRevokedCallCount());
                 Assert.assertEquals(0, mObserver.getLoadedCallCount());
             }
         });
     }
 
     @Test
     @MediumTest
     public void testValidateAccountsSingleAccountThenAddOne() throws Throwable {
         mUiThreadTestRule.runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 // Add account.
                 mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
 
                 // Mark user as signed in.
                 mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 
                 // Run one validation.
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
                 Assert.assertEquals(1, mObserver.getAvailableCallCount());
                 Assert.assertEquals(0, mObserver.getRevokedCallCount());
                 Assert.assertEquals(0, mObserver.getLoadedCallCount());
 
                 // Add another account.
                 mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_2);
 
                 // Seed AccountTrackerService again since accounts changed after last validation.
                 seedAccountTrackerService(mContext);
 
                 // Re-run validation.
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
                 Assert.assertEquals(2, mObserver.getAvailableCallCount());
                 Assert.assertEquals(0, mObserver.getRevokedCallCount());
                 Assert.assertEquals(0, mObserver.getLoadedCallCount());
             }
         });
     }
 
     @Test
     @MediumTest
     public void testValidateAccountsTwoAccountsThenRemoveOne() throws Throwable {
         mUiThreadTestRule.runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 // Add accounts.
                 mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
                 mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_2);
 
                 // Mark user as signed in.
                 mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 
                 // Run one validation.
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
                 Assert.assertEquals(2, mObserver.getAvailableCallCount());
 
                 mAccountManager.removeAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_2);
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
 
                 Assert.assertEquals(2, mObserver.getAvailableCallCount());
                 Assert.assertEquals(1, mObserver.getRevokedCallCount());
                 Assert.assertEquals(0, mObserver.getLoadedCallCount());
             }
         });
     }
 
     @Test
     @MediumTest
     public void testValidateAccountsTwoAccountsThenRemoveAll() throws Throwable {
         mUiThreadTestRule.runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 // Add accounts.
                 mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
                 mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_2);
 
                 // Mark user as signed in.
                 mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
                 Assert.assertEquals(2, mObserver.getAvailableCallCount());
 
                 // Remove all.
                 mAccountManager.removeAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
                 mAccountManager.removeAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_2);
 
                 // Re-validate and run checks.
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
                 Assert.assertEquals(2, mObserver.getRevokedCallCount());
                 Assert.assertEquals(0, mObserver.getLoadedCallCount());
             }
         });
     }
 
     @Test
     @MediumTest
     @RetryOnFailure
     public void testValidateAccountsTwoAccountsThenRemoveAllSignOut() throws Throwable {
         mUiThreadTestRule.runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 // Add accounts.
                 mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
                 mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_2);
 
                 // Mark user as signed in.
                 mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
                 Assert.assertEquals(2, mObserver.getAvailableCallCount());
 
                 // Remove all.
                 mChromeSigninController.setSignedInAccountName(null);
                 mAccountManager.removeAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
                 mAccountManager.removeAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_2);
 
                 // Re-validate and run checks.
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
                 Assert.assertEquals(2, mObserver.getRevokedCallCount());
                 Assert.assertEquals(0, mObserver.getLoadedCallCount());
             }
         });
     }
 
     @Test
     @MediumTest
     public void testValidateAccountsTwoAccountsRegisteredAndOneSignedIn() throws Throwable {
         mUiThreadTestRule.runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 // Add accounts.
                 mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_1);
                 mAccountManager.addAccountHolderExplicitly(TEST_ACCOUNT_HOLDER_2);
 
                 // Mark user as signed in.
                 mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 
                 // Run test.
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
 
                 // All accounts will be notified. It is up to the observer
                 // to design if any action is needed.
                 Assert.assertEquals(2, mObserver.getAvailableCallCount());
                 Assert.assertEquals(0, mObserver.getRevokedCallCount());
                 Assert.assertEquals(0, mObserver.getLoadedCallCount());
             }
         });
     }
 
     @Test
     @MediumTest
     public void testValidateAccountsNoAccountsRegisteredButSignedIn() throws Throwable {
         mUiThreadTestRule.runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 // Mark user as signed in without setting up the account.
                 mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
 
                 // Run test.
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
 
                 // Ensure no calls have been made to the observer.
                 Assert.assertEquals(0, mObserver.getAvailableCallCount());
                 Assert.assertEquals(0, mObserver.getRevokedCallCount());
                 Assert.assertEquals(0, mObserver.getLoadedCallCount());
             }
         });
     }
 
     @Test
     @MediumTest
     public void testValidateAccountsFiresEventAtTheEnd() throws Throwable {
         mUiThreadTestRule.runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 // Mark user as signed in without setting up the account.
                 mChromeSigninController.setSignedInAccountName(TEST_ACCOUNT1.name);
                 TestObserver ob = new TestObserver() {
                     @Override
                     public void onRefreshTokenAvailable(Account account) {
                         super.onRefreshTokenAvailable(account);
-                        Assert.assertEquals(1, OAuth2TokenService.getAccounts(mContext).length);
+                        Assert.assertEquals(1, OAuth2TokenService.getAccounts().length);
                     }
                 };
 
                 addObserver(ob);
-                mOAuth2TokenService.validateAccounts(mContext, false);
+                mOAuth2TokenService.validateAccounts(false);
             }
         });
     }
 
     private static class TestObserver implements OAuth2TokenService.OAuth2TokenServiceObserver {
         private int mAvailableCallCount;
         private int mRevokedCallCount;
         private int mLoadedCallCount;
         private Account mLastAccount;
 
@@ skipping 24 matching lines @@
 
         public int getLoadedCallCount() {
             return mLoadedCallCount;
         }
 
         public Account getLastAccount() {
             return mLastAccount;
         }
     }
 }