[Sync] Make it impossible to get a reference to AndroidSyncSettings.

sync/android/java/src/org/chromium/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.sync;
 
 import android.accounts.Account;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.SyncStatusObserver;
 import android.os.StrictMode;
 
 import org.chromium.base.ObserverList;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.sync.signin.AccountManagerHelper;
 
 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.
  *
- * To retrieve an instance of this class, call AndroidSyncSettings.get(someContext).
+ * 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.
  *
  * This class must be initialized via updateAccount() on startup if the user is signed in.
  */
 @ThreadSafe
 public class AndroidSyncSettings {
 
     public static final String TAG = "AndroidSyncSettings";
 
     /**
      * Lock for ensuring singleton instantiation across threads.
      */
     private static final Object CLASS_LOCK = new Object();
 
-    private static AndroidSyncSettings sAndroidSyncSettings;
+    private static AndroidSyncSettings sInstance;
 
     private final Object mLock = new Object();
 
     private final String mContractAuthority;
 
     private final Context mApplicationContext;
 
     private final SyncContentResolverDelegate mSyncContentResolverDelegate;
 
     private Account mAccount = null;
 
     private boolean mIsSyncable = false;
 
     private boolean mChromeSyncEnabled = false;
 
     private boolean mMasterSyncEnabled = false;
 
     private final ObserverList<AndroidSyncSettingsObserver> mObservers =
             new ObserverList<AndroidSyncSettingsObserver>();
 
     /**
      * Provides notifications when Android sync settings have changed.
      */
     public interface AndroidSyncSettingsObserver {
         public void androidSyncSettingsChanged();
     }
 
-    /**
-     * A factory method for the AndroidSyncSettings.
-     *
-     * It is possible to override the {@link SyncContentResolverDelegate} to use in tests for the
-     * instance of the AndroidSyncSettings by calling overrideForTests(...) with
-     * your {@link SyncContentResolverDelegate}.
-     *
-     * @param context the ApplicationContext is retrieved from the context used as an argument.
-     * @return a singleton instance of the AndroidSyncSettings
-     */
-    public static AndroidSyncSettings get(Context context) {
+    private static void ensureInitialized(Context context) {
         synchronized (CLASS_LOCK) {
-            if (sAndroidSyncSettings == null) {
+            if (sInstance == null) {
                 SyncContentResolverDelegate contentResolver =
                         new SystemSyncContentResolverDelegate();
-                sAndroidSyncSettings = new AndroidSyncSettings(context, contentResolver);
+                sInstance = new AndroidSyncSettings(context, contentResolver);
             }
         }
-        return sAndroidSyncSettings;
     }
 
     @VisibleForTesting
     public static void overrideForTests(Context context,
             SyncContentResolverDelegate contentResolver) {
         synchronized (CLASS_LOCK) {
-            sAndroidSyncSettings = new AndroidSyncSettings(context, contentResolver);
+            sInstance = new AndroidSyncSettings(context, contentResolver);
         }
     }
 
     /**
-     * @param context the context
+     * @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();
 
         updateCachedSettings();
 
         mSyncContentResolverDelegate.addStatusChangeListener(
                 ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS,
                 new AndroidSyncSettingsChangedObserver());
     }
 
     /**
      * Checks whether sync is currently enabled from Chrome for the currently signed in account.
      *
      * It checks both the master sync for the device, and Chrome sync setting for the given account.
      * If no user is currently signed in it returns false.
      *
      * @return true if sync is on, false otherwise
      */
-    public boolean isSyncEnabled() {
-        return mMasterSyncEnabled && mChromeSyncEnabled;
+    public static boolean isSyncEnabled(Context context) {
+        ensureInitialized(context);
+        return sInstance.mMasterSyncEnabled && sInstance.mChromeSyncEnabled;
     }
 
     /**
      * Checks whether sync is currently enabled from Chrome for a given account.
      *
      * It checks only Chrome sync setting for the given account,
      * and ignores the master sync setting.
      *
      * @return true if sync is on, false otherwise
      */
-    public boolean isChromeSyncEnabled() {
-        return mChromeSyncEnabled;
+    public static boolean isChromeSyncEnabled(Context context) {
+        ensureInitialized(context);
+        return sInstance.mChromeSyncEnabled;
     }
 
     /**
      * Checks whether the master sync flag for Android is currently enabled.
      */
-    public boolean isMasterSyncEnabled() {
-        return mMasterSyncEnabled;
+    public static boolean isMasterSyncEnabled(Context context) {
+        ensureInitialized(context);
+        return sInstance.mMasterSyncEnabled;
     }
 
     /**
      * Make sure Chrome is syncable, and enable sync.
      */
-    public void enableChromeSync() {
-        setChromeSyncEnabled(true);
+    public static void enableChromeSync(Context context) {
+        ensureInitialized(context);
+        sInstance.setChromeSyncEnabled(true);
     }
 
     /**
      * Disables Android Chrome sync
      */
-    public void disableChromeSync() {
-        setChromeSyncEnabled(false);
+    public static void disableChromeSync(Context context) {
+        ensureInitialized(context);
+        sInstance.setChromeSyncEnabled(false);
     }
 
     /**
      * Must be called when a new account is signed in.
      */
-    public void updateAccount(Account account) {
-        synchronized (mLock) {
-            mAccount = account;
-            updateSyncability();
+    public static void updateAccount(Context context, Account account) {
+        ensureInitialized(context);
+        synchronized (sInstance.mLock) {
+            sInstance.mAccount = account;
+            sInstance.updateSyncability();
         }
-        if (updateCachedSettings()) {
-            notifyObservers();
+        if (sInstance.updateCachedSettings()) {
+            sInstance.notifyObservers();
         }
     }
 
     /**
      * Returns the contract authority to use when requesting sync.
      */
-    public String getContractAuthority() {
-        return mApplicationContext.getPackageName();
+    public static String getContractAuthority(Context context) {
+        ensureInitialized(context);
+        return sInstance.getContractAuthority();
     }
 
     /**
      * Add a new AndroidSyncSettingsObserver.
      */
-    public void registerObserver(AndroidSyncSettingsObserver observer) {
-        synchronized (mLock) {
-            mObservers.addObserver(observer);
+    public static void registerObserver(Context context, AndroidSyncSettingsObserver observer) {
+        ensureInitialized(context);
+        synchronized (sInstance.mLock) {
+            sInstance.mObservers.addObserver(observer);
         }
     }
 
     /**
      * Remove an AndroidSyncSettingsObserver that was previously added.
      */
-    public void unregisterObserver(AndroidSyncSettingsObserver observer) {
-        synchronized (mLock) {
-            mObservers.removeObserver(observer);
+    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();
             if (value == mChromeSyncEnabled || mAccount == null) return;
             mChromeSyncEnabled = value;
 
             StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
@@ skipping 81 matching lines @@
             return oldChromeSyncEnabled != mChromeSyncEnabled
                 || oldMasterSyncEnabled != mMasterSyncEnabled;
         }
     }
 
     private void notifyObservers() {
         for (AndroidSyncSettingsObserver observer : mObservers) {
             observer.androidSyncSettingsChanged();
         }
     }
+
+    // TODO(maxbogue): make private once downstream uses are removed.
+    @Deprecated
+    public String getContractAuthority() {
+        return mApplicationContext.getPackageName();
+    }
+
+    // Deprecated section; to be removed once downstream no longer uses them.
+
+    @Deprecated
+    public static AndroidSyncSettings get(Context context) {
+        ensureInitialized(context);
+        return sInstance;
+    }
+
+    @Deprecated
+    public boolean isSyncEnabled() {
+        return mMasterSyncEnabled && mChromeSyncEnabled;
+    }
+
+    @Deprecated
+    public boolean isChromeSyncEnabled() {
+        return mChromeSyncEnabled;
+    }
+
+    @Deprecated
+    public boolean isMasterSyncEnabled() {
+        return mMasterSyncEnabled;
+    }
+
+    @Deprecated
+    public void enableChromeSync() {
+        setChromeSyncEnabled(true);
+    }
+
+    @Deprecated
+    public void disableChromeSync() {
+        setChromeSyncEnabled(false);
+    }
+
+    @Deprecated
+    public void updateAccount(Account account) {
+        synchronized (mLock) {
+            mAccount = account;
+            updateSyncability();
+        }
+        if (updateCachedSettings()) {
+            notifyObservers();
+        }
+    }
+
+    @Deprecated
+    public void registerObserver(AndroidSyncSettingsObserver observer) {
+        synchronized (mLock) {
+            mObservers.addObserver(observer);
+        }
+    }
+
+    @Deprecated
+    public void unregisterObserver(AndroidSyncSettingsObserver observer) {
+        synchronized (mLock) {
+            mObservers.removeObserver(observer);
+        }
+    }
 }