[Sync] Move //sync to //components/sync.

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.sync;
+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.sync.signin.AccountManagerHelper;
+import org.chromium.components.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.
  *
  * 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 sInstance;
 
     private final Object mLock = new Object();
@@ skipping 11 matching lines @@
     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();
-    }
+    public interface AndroidSyncSettingsObserver { public void androidSyncSettingsChanged(); }
 
     private static void ensureInitialized(Context context) {
         synchronized (CLASS_LOCK) {
             if (sInstance == null) {
                 SyncContentResolverDelegate contentResolver =
                         new SystemSyncContentResolverDelegate();
                 sInstance = new AndroidSyncSettings(context, contentResolver);
             }
         }
     }
 
     @VisibleForTesting
-    public static void overrideForTests(Context context,
-            SyncContentResolverDelegate contentResolver) {
+    public static void overrideForTests(
+            Context context, SyncContentResolverDelegate contentResolver) {
         synchronized (CLASS_LOCK) {
             sInstance = new AndroidSyncSettings(context, contentResolver);
         }
     }
 
     /**
      * @param context the context the ApplicationContext will be retrieved from.
      * @param syncContentResolverDelegate an implementation of {@link SyncContentResolverDelegate}.
      */
-    private AndroidSyncSettings(Context context,
-            SyncContentResolverDelegate syncContentResolverDelegate) {
+    private AndroidSyncSettings(
+            Context context, SyncContentResolverDelegate syncContentResolverDelegate) {
         mApplicationContext = context.getApplicationContext();
         mSyncContentResolverDelegate = syncContentResolverDelegate;
         mContractAuthority = getContractAuthority();
 
         updateCachedSettings();
 
         mSyncContentResolverDelegate.addStatusChangeListener(
                 ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS,
                 new AndroidSyncSettingsChangedObserver());
     }
@@ skipping 125 matching lines @@
                     mAccount, mContractAuthority, Bundle.EMPTY);
         }
         StrictMode.setThreadPolicy(oldPolicy);
 
         // Disable the syncability of Chrome for all other accounts.
         AccountManagerHelper.get(mApplicationContext).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) {
+                    if (!account.equals(mAccount)
+                            && mSyncContentResolverDelegate.getIsSyncable(
+                                       account, mContractAuthority)
+                                    > 0) {
                         mSyncContentResolverDelegate.setIsSyncable(account, mContractAuthority, 0);
                     }
                 }
                 StrictMode.setThreadPolicy(oldPolicy);
             }
         });
     }
 
     /**
      * Helper class to be used by observers whenever sync settings change.
@@ skipping 18 matching lines @@
      *
      * @return Whether either chromeSyncEnabled or masterSyncEnabled changed.
      */
     private boolean updateCachedSettings() {
         synchronized (mLock) {
             boolean oldChromeSyncEnabled = mChromeSyncEnabled;
             boolean oldMasterSyncEnabled = mMasterSyncEnabled;
 
             StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskWrites();
             if (mAccount != null) {
-                mIsSyncable = mSyncContentResolverDelegate.getIsSyncable(
-                        mAccount, mContractAuthority) == 1;
+                mIsSyncable =
+                        mSyncContentResolverDelegate.getIsSyncable(mAccount, mContractAuthority)
+                        == 1;
                 mChromeSyncEnabled = mSyncContentResolverDelegate.getSyncAutomatically(
                         mAccount, mContractAuthority);
             } else {
                 mIsSyncable = false;
                 mChromeSyncEnabled = false;
             }
             mMasterSyncEnabled = mSyncContentResolverDelegate.getMasterSyncAutomatically();
             StrictMode.setThreadPolicy(oldPolicy);
 
             return oldChromeSyncEnabled != mChromeSyncEnabled
-                || oldMasterSyncEnabled != mMasterSyncEnabled;
+                    || oldMasterSyncEnabled != mMasterSyncEnabled;
         }
     }
 
     private void notifyObservers() {
         for (AndroidSyncSettingsObserver observer : mObservers) {
             observer.androidSyncSettingsChanged();
         }
     }
 
     private String getContractAuthority() {
         return mApplicationContext.getPackageName();
     }
 }