Add callback to AndroidSyncSettings.updateAccount and fix related test

components/sync/android/java/src/org/chromium/components/sync/AndroidSyncSettings.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.components.sync;
 
 import android.accounts.Account;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.SyncStatusObserver;
 import android.os.Bundle;
 import android.os.StrictMode;
 
 import org.chromium.base.Callback;
 import org.chromium.base.ObserverList;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.components.signin.AccountManagerHelper;
 import org.chromium.components.signin.ChromeSigninController;
 
+import javax.annotation.Nullable;
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
  * A helper class to handle the current status of sync for Chrome in Android settings.
  *
  * It also provides an observer to be used whenever Android sync settings change.
  *
  * This class is a collection of static methods so that no references to its object can be
  * stored. This is important because tests need to be able to overwrite the object with a
  * mock content resolver and know that no references to the old one are cached.
@@ skipping 57 matching lines @@
      * @param context the context the ApplicationContext will be retrieved from.
      * @param syncContentResolverDelegate an implementation of {@link SyncContentResolverDelegate}.
      */
     private AndroidSyncSettings(
             Context context, SyncContentResolverDelegate syncContentResolverDelegate) {
         mApplicationContext = context.getApplicationContext();
         mSyncContentResolverDelegate = syncContentResolverDelegate;
         mContractAuthority = getContractAuthority();
 
         mAccount = ChromeSigninController.get().getSignedInUser();
-        updateSyncability();
+        updateSyncability(null);
         updateCachedSettings();
 
         mSyncContentResolverDelegate.addStatusChangeListener(
                 ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS,
                 new AndroidSyncSettingsChangedObserver());
     }
 
     /**
      * Checks whether sync is currently enabled from Chrome for the currently signed in account.
      *
@@ skipping 42 matching lines @@
      */
     public static void disableChromeSync(Context context) {
         ensureInitialized(context);
         sInstance.setChromeSyncEnabled(false);
     }
 
     /**
      * Must be called when a new account is signed in.
      */
     public static void updateAccount(Context context, Account account) {
+        updateAccount(context, account, null);
+    }
+
+    /**
+     * Must be called when a new account is signed in.
+     * @param callback Callback that will be called after updating account is finished. Boolean
+     *                 passed to the callback indicates whether syncability was changed.
+     */
+    @VisibleForTesting
+    public static void updateAccount(
+            Context context, Account account, @Nullable Callback<Boolean> callback) {
         ensureInitialized(context);
         synchronized (sInstance.mLock) {
             sInstance.mAccount = account;
-            sInstance.updateSyncability();
+            sInstance.updateSyncability(callback);
         }
         if (sInstance.updateCachedSettings()) {
             sInstance.notifyObservers();
         }
     }
 
     /**
      * Returns the contract authority to use when requesting sync.
      */
     public static String getContractAuthority(Context context) {
@@ skipping 16 matching lines @@
      */
     public static void unregisterObserver(Context context, AndroidSyncSettingsObserver observer) {
         ensureInitialized(context);
         synchronized (sInstance.mLock) {
             sInstance.mObservers.removeObserver(observer);
         }
     }
 
     private void setChromeSyncEnabled(boolean value) {
         synchronized (mLock) {
-            updateSyncability();
+            updateSyncability(null);
             if (value == mChromeSyncEnabled || mAccount == null) return;
             mChromeSyncEnabled = value;
 
             StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
             mSyncContentResolverDelegate.setSyncAutomatically(mAccount, mContractAuthority, value);
             StrictMode.setThreadPolicy(oldPolicy);
         }
         notifyObservers();
     }
 
     /**
      * Ensure Chrome is registered with the Android Sync Manager iff signed in.
      *
      * This is what causes the "Chrome" option to appear in Settings -> Accounts -> Sync .
      * This function must be called within a synchronized block.
      */
-    private void updateSyncability() {
+    private void updateSyncability(@Nullable final Callback<Boolean> callback) {
         boolean shouldBeSyncable = mAccount != null;
-        if (mIsSyncable == shouldBeSyncable) return;
+        if (mIsSyncable == shouldBeSyncable) {
+            if (callback != null) callback.onResult(false);
+            return;
+        }
 
         mIsSyncable = shouldBeSyncable;
 
         StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
         // Make account syncable if there is one.
         if (shouldBeSyncable) {
             mSyncContentResolverDelegate.setIsSyncable(mAccount, mContractAuthority, 1);
             // This reduces unnecessary resource usage. See http://crbug.com/480688 for details.
             mSyncContentResolverDelegate.removePeriodicSync(
                     mAccount, mContractAuthority, Bundle.EMPTY);
         }
         StrictMode.setThreadPolicy(oldPolicy);
 
         // Disable the syncability of Chrome for all other accounts.
         AccountManagerHelper.get().getGoogleAccounts(new Callback<Account[]>() {
             @Override
             public void onResult(Account[] accounts) {
                 StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
                 for (Account account : accounts) {
                     if (!account.equals(mAccount)
                             && mSyncContentResolverDelegate.getIsSyncable(
                                        account, mContractAuthority)
                                     > 0) {
                         mSyncContentResolverDelegate.setIsSyncable(account, mContractAuthority, 0);
                     }
                 }
                 StrictMode.setThreadPolicy(oldPolicy);
+
+                if (callback != null) callback.onResult(true);
             }
         });
     }
 
     /**
      * Helper class to be used by observers whenever sync settings change.
      *
      * To register the observer, call AndroidSyncSettings.registerObserver(...).
      */
     private class AndroidSyncSettingsChangedObserver implements SyncStatusObserver {
@@ skipping 41 matching lines @@
     private void notifyObservers() {
         for (AndroidSyncSettingsObserver observer : mObservers) {
             observer.androidSyncSettingsChanged();
         }
     }
 
     private String getContractAuthority() {
         return mApplicationContext.getPackageName();
     }
 }