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

components/sync/test/android/javatests/src/org/chromium/components/sync/test/util/MockSyncContentResolverDelegate.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.sync.test.util;
-
+package org.chromium.components.sync.test.util;
 
 import android.accounts.Account;
 import android.content.ContentResolver;
 import android.content.SyncStatusObserver;
 import android.os.AsyncTask;
 import android.os.Bundle;
 
 import junit.framework.Assert;
 
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.VisibleForTesting;
-import org.chromium.sync.SyncContentResolverDelegate;
+import org.chromium.components.sync.SyncContentResolverDelegate;
 
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
 
-
 /**
  * Mock implementation of the {@link SyncContentResolverDelegate}.
  *
  * This implementation only supports status change listeners for the type
  * SYNC_OBSERVER_TYPE_SETTINGS.
  */
 public class MockSyncContentResolverDelegate implements SyncContentResolverDelegate {
-
     private final Set<String> mSyncAutomaticallySet;
     private final Map<String, Boolean> mIsSyncableMap;
     private final Object mSyncableMapLock = new Object();
 
     private final Set<AsyncSyncStatusObserver> mObservers;
 
     private boolean mMasterSyncAutomatically;
     private boolean mDisableObserverNotifications;
 
     private Semaphore mPendingObserverCount;
@@ skipping 75 matching lines @@
                     break;
                 case 1:
                     mIsSyncableMap.put(key, true);
                     break;
                 case -1:
                     if (mIsSyncableMap.containsKey(key)) {
                         mIsSyncableMap.remove(key);
                     }
                     break;
                 default:
-                    throw new IllegalArgumentException("Unable to understand syncable argument: "
-                            + syncable);
+                    throw new IllegalArgumentException(
+                            "Unable to understand syncable argument: " + syncable);
             }
         }
         notifyObservers();
     }
 
     @Override
     public int getIsSyncable(Account account, String authority) {
         String key = createKey(account, authority);
         synchronized (mSyncableMapLock) {
             if (mIsSyncableMap.containsKey(key)) {
                 return mIsSyncableMap.get(key) ? 1 : 0;
             } else {
                 return -1;
             }
         }
     }
 
     @Override
-    public void removePeriodicSync(Account account, String authority, Bundle extras) {
-    }
+    public void removePeriodicSync(Account account, String authority, Bundle extras) {}
 
     private static String createKey(Account account, String authority) {
         return account.name + "@@@" + account.type + "@@@" + authority;
     }
 
     private void notifyObservers() {
         if (mDisableObserverNotifications) return;
         synchronized (mObservers) {
             mPendingObserverCount = new Semaphore(1 - mObservers.size());
             for (AsyncSyncStatusObserver observer : mObservers) {
@@ skipping 12 matching lines @@
     @VisibleForTesting
     public void waitForLastNotificationCompleted() throws InterruptedException {
         Assert.assertTrue("Timed out waiting for notifications to complete.",
                 mPendingObserverCount.tryAcquire(5, TimeUnit.SECONDS));
     }
 
     public void disableObserverNotifications() {
         mDisableObserverNotifications = true;
     }
 
-   /**
-     * Simulate an account rename, which copies settings to the new account.
-     */
+    /**
+      * Simulate an account rename, which copies settings to the new account.
+      */
     public void renameAccounts(Account oldAccount, Account newAccount, String authority) {
         int oldIsSyncable = getIsSyncable(oldAccount, authority);
         setIsSyncable(newAccount, authority, oldIsSyncable);
         if (oldIsSyncable == 1) {
             setSyncAutomatically(
                     newAccount, authority, getSyncAutomatically(oldAccount, authority));
         }
     }
 
     private static class AsyncSyncStatusObserver {
-
         private final SyncStatusObserver mSyncStatusObserver;
 
         private AsyncSyncStatusObserver(SyncStatusObserver syncStatusObserver) {
             mSyncStatusObserver = syncStatusObserver;
         }
 
         private void notifyObserverAsync(final Semaphore pendingObserverCount) {
             if (ThreadUtils.runningOnUiThread()) {
                 new AsyncTask<Void, Void, Void>() {
                     @Override
                     protected Void doInBackground(Void... params) {
                         mSyncStatusObserver.onStatusChanged(
                                 ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS);
                         return null;
                     }
 
                     @Override
                     protected void onPostExecute(Void result) {
                         pendingObserverCount.release();
                     }
                 }.execute();
             } else {
-                mSyncStatusObserver.onStatusChanged(
-                        ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS);
+                mSyncStatusObserver.onStatusChanged(ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS);
                 pendingObserverCount.release();
             }
         }
     }
 }