Remove Chrome from Android's list of auto-sync apps

After this CL, when DecoupleSyncFromAndroidMasterSync is enabled, Chrome
will no longer be in the list of auto-sync apps. In particular this toggle
will disappear [1]. Users who previously disabled that toggle will remain
with Chrome Sync disabled until they enable it again on Chrome settings.
[1] https://screenshot.googleplex.com/9uR0qxTzVzK

Context: the Android APIs setIsSyncable(..., int) and
setSyncAutomatically(..., bool) control 2 *independent* settings per
(account, app) pair, "syncable"[2] and "enabled"[3], persisted to an XML
file. The first one controls whether the toggle in the screenshot will
exist. A value >0 means yes, =0 means no and <0 means an unknown state
(where the toggle isn't shown either)[4]. What the CL does is basically
set "syncable" to 0 for any Chrome account. "enabled" can continue to be
set safely and will still mirror the sync.requested pref [5], as happens
today.
[2] https://cs.android.com/android/platform/superproject/+/eed78aea1f49cba01c737220a6f834bca7feeef7:frameworks/base/services/core/java/com/android/server/content/SyncStorageEngine.java;l=283
[3] https://cs.android.com/android/platform/superproject/+/eed78aea1f49cba01c737220a6f834bca7feeef7:frameworks/base/services/core/java/com/android/server/content/SyncStorageEngine.java;l=282
[4] https://developer.android.com/reference/android/content/ContentResolver#setIsSyncable(android.accounts.Account,%20java.lang.String,%20int)
[5] https://source.chromium.org/chromium/chromium/src/+/master:components/sync/base/sync_prefs.h;l=90

The CL also:
a) Replaces code that checked specifically whether "syncable" valued 1,
0 or -1 with more generic checks for >0, =0 or <0. 1, 0 and -1 do have
special meanings in SyncStorageEngine, but that's an implementation
detail of a lower layer. The layer where the APIs live (ContentResolver)
never ensures those values.
b) Modifies the implementation of MockSyncContentResolverDelegate to be
more consistent with the real Android behavior. E.g. one should be
allowed to set "enabled" before "syncable".

In next CLs the DecoupleSyncFromAndroidMasterSync feature toggle will be
renamed to mention auto-sync rather than master sync.

Bug: 1105795
Change-Id: I091981506ff64c33a6c259862eee07d28825527f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2366895
Commit-Queue: Victor Vianna <victorvianna@google.com>
Reviewed-by: Marc Treib <treib@chromium.org>
Cr-Commit-Position: refs/heads/master@{#800273}

chrome/android/java/src/org/chromium/chrome/browser/sync/AndroidSyncSettings.java

@@ -109,8 +109,8 @@ public class AndroidSyncSettings {
         mSyncContentResolverDelegate = syncContentResolverDelegate;
 
         mAccount = account;
-        updateSyncability(callback);
         updateCachedSettings();
+        updateSyncability(callback);
 
         mSyncContentResolverDelegate.addStatusChangeListener(
                 ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS,
@@ -234,7 +234,9 @@ public class AndroidSyncSettings {
      * This function must be called within a synchronized block.
      */
     private void updateSyncability(@Nullable final Callback<Boolean> callback) {
-        boolean shouldBeSyncable = mAccount != null;
+        boolean shouldBeSyncable = mAccount != null
+                && !ChromeFeatureList.isEnabled(
+                        ChromeFeatureList.DECOUPLE_SYNC_FROM_ANDROID_MASTER_SYNC);
         if (mIsSyncable == shouldBeSyncable) {
             if (callback != null) callback.onResult(false);
             return;
@@ -249,6 +251,8 @@ public class AndroidSyncSettings {
                 // This reduces unnecessary resource usage. See http://crbug.com/480688 for details.
                 mSyncContentResolverDelegate.removePeriodicSync(
                         mAccount, mContractAuthority, Bundle.EMPTY);
+            } else if (mAccount != null) {
+                mSyncContentResolverDelegate.setIsSyncable(mAccount, mContractAuthority, 0);
             }
         }
 
@@ -307,7 +311,7 @@ public class AndroidSyncSettings {
             if (mAccount != null) {
                 mIsSyncable =
                         mSyncContentResolverDelegate.getIsSyncable(mAccount, mContractAuthority)
-                        == 1;
+                        > 0;
                 mChromeSyncEnabled = mSyncContentResolverDelegate.getSyncAutomatically(
                         mAccount, mContractAuthority);
             } else {

chrome/android/javatests/src/org/chromium/chrome/browser/sync/AndroidSyncSettingsTest.java

@@ -137,7 +137,12 @@ public class AndroidSyncSettingsTest {
         mCallbackHelper.waitForCallback(0, mNumberOfCallsToWait);
 
         mAuthority = mAndroidSyncSettings.getContractAuthority();
-        Assert.assertEquals(1, mSyncContentResolverDelegate.getIsSyncable(mAccount, mAuthority));
+        if (ChromeFeatureList.isEnabled(ChromeFeatureList.DECOUPLE_SYNC_FROM_ANDROID_MASTER_SYNC)) {
+            Assert.assertTrue(
+                    mSyncContentResolverDelegate.getIsSyncable(mAccount, mAuthority) <= 0);
+        } else {
+            Assert.assertTrue(mSyncContentResolverDelegate.getIsSyncable(mAccount, mAuthority) > 0);
+        }
 
         mSyncSettingsObserver = new MockSyncSettingsObserver();
         mAndroidSyncSettings.registerObserver(mSyncSettingsObserver);
@@ -429,8 +434,9 @@ public class AndroidSyncSettingsTest {
     @Test
     @SmallTest
     @Feature({"Sync"})
+    @Features.DisableFeatures(ChromeFeatureList.DECOUPLE_SYNC_FROM_ANDROID_MASTER_SYNC)
     public void testIsSyncableOnSigninAndNotOnSignout() throws TimeoutException {
-        Assert.assertEquals(1, mSyncContentResolverDelegate.getIsSyncable(mAccount, mAuthority));
+        Assert.assertTrue(mSyncContentResolverDelegate.getIsSyncable(mAccount, mAuthority) > 0);
 
         updateAccountWithCallback(null, (Boolean result) -> {
             Assert.assertTrue(result);
@@ -440,7 +446,7 @@ public class AndroidSyncSettingsTest {
 
         Assert.assertEquals(0, mSyncContentResolverDelegate.getIsSyncable(mAccount, mAuthority));
         updateAccount(mAccount);
-        Assert.assertEquals(1, mSyncContentResolverDelegate.getIsSyncable(mAccount, mAuthority));
+        Assert.assertTrue(mSyncContentResolverDelegate.getIsSyncable(mAccount, mAuthority) > 0);
     }
 
     /**
@@ -449,6 +455,7 @@ public class AndroidSyncSettingsTest {
     @Test
     @SmallTest
     @Feature({"Sync"})
+    @Features.DisableFeatures(ChromeFeatureList.DECOUPLE_SYNC_FROM_ANDROID_MASTER_SYNC)
     public void testSyncableIsAlwaysSetWhenEnablingSync() throws InterruptedException {
         // Setup bad state.
         mSyncContentResolverDelegate.setMasterSyncAutomatically(true);
@@ -459,12 +466,12 @@ public class AndroidSyncSettingsTest {
         mSyncContentResolverDelegate.waitForLastNotificationCompleted();
         mSyncContentResolverDelegate.setIsSyncable(mAccount, mAuthority, 0);
         mSyncContentResolverDelegate.waitForLastNotificationCompleted();
-        Assert.assertTrue(mSyncContentResolverDelegate.getIsSyncable(mAccount, mAuthority) == 0);
+        Assert.assertEquals(0, mSyncContentResolverDelegate.getIsSyncable(mAccount, mAuthority));
         Assert.assertTrue(mSyncContentResolverDelegate.getSyncAutomatically(mAccount, mAuthority));
 
         // Ensure bug is fixed.
         enableChromeSyncOnUiThread();
-        Assert.assertEquals(1, mSyncContentResolverDelegate.getIsSyncable(mAccount, mAuthority));
+        Assert.assertTrue(mSyncContentResolverDelegate.getIsSyncable(mAccount, mAuthority) > 0);
         // Should still be enabled.
         Assert.assertTrue(mSyncContentResolverDelegate.getSyncAutomatically(mAccount, mAuthority));
     }

components/sync/test/android/javatests/src/org/chromium/components/sync/test/util/MockSyncContentResolverDelegate.java

@@ -25,10 +25,12 @@ import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
 
 /**
- * Mock implementation of the {@link SyncContentResolverDelegate}.
+ * Fake implementation of the {@link SyncContentResolverDelegate}.
  *
  * This implementation only supports status change listeners for the type
- * SYNC_OBSERVER_TYPE_SETTINGS.
+ * SYNC_OBSERVER_TYPE_SETTINGS. Differently from the real implementation, it
+ * doesn't allow calling the auto-sync methods (e.g. getIsSyncable()) with a null
+ * account.
  */
 public class MockSyncContentResolverDelegate implements SyncContentResolverDelegate {
     private final Set<String> mSyncAutomaticallySet;
@@ -84,21 +86,15 @@ public class MockSyncContentResolverDelegate implements SyncContentResolverDeleg
 
     @Override
     public boolean getSyncAutomatically(Account account, String authority) {
-        String key = createKey(account, authority);
         synchronized (mSyncableMapLock) {
-            return mSyncAutomaticallySet.contains(key);
+            return mSyncAutomaticallySet.contains(createKey(account, authority));
         }
     }
 
     @Override
     public void setSyncAutomatically(Account account, String authority, boolean sync) {
-        String key = createKey(account, authority);
         synchronized (mSyncableMapLock) {
-            if (!mIsSyncableMap.containsKey(key) || !mIsSyncableMap.get(key)) {
-                throw new IllegalArgumentException("Account " + account
-                        + " is not syncable for authority " + authority
-                        + ". Can not set sync state to " + sync);
-            }
+            String key = createKey(account, authority);
             if (sync) {
                 mSyncAutomaticallySet.add(key);
             } else if (mSyncAutomaticallySet.contains(key)) {
@@ -110,24 +106,14 @@ public class MockSyncContentResolverDelegate implements SyncContentResolverDeleg
 
     @Override
     public void setIsSyncable(Account account, String authority, int syncable) {
-        String key = createKey(account, authority);
-
         synchronized (mSyncableMapLock) {
-            switch (syncable) {
-                case 0:
-                    mIsSyncableMap.put(key, false);
-                    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);
+            String key = createKey(account, authority);
+            if (syncable > 0) {
+                mIsSyncableMap.put(key, true);
+            } else if (syncable == 0) {
+                mIsSyncableMap.put(key, false);
+            } else if (mIsSyncableMap.containsKey(key)) {
+                mIsSyncableMap.remove(key);
             }
         }
         notifyObservers();
@@ -135,13 +121,12 @@ public class MockSyncContentResolverDelegate implements SyncContentResolverDeleg
 
     @Override
     public int getIsSyncable(Account account, String authority) {
-        String key = createKey(account, authority);
         synchronized (mSyncableMapLock) {
+            String key = createKey(account, authority);
             if (mIsSyncableMap.containsKey(key)) {
                 return mIsSyncableMap.get(key) ? 1 : 0;
-            } else {
-                return -1;
             }
+            return -1;
         }
     }