Enable invalidations for arbitrary objects on Android.

sync/android/javatests/src/org/chromium/sync/notifier/InvalidationServiceTest.java

 // Copyright (c) 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.notifier;
 
 import android.accounts.Account;
 import android.content.ComponentName;
 import android.content.Intent;
 import android.os.Bundle;
@@ skipping 123 matching lines @@
     public void testReady() {
        /**
         * Test plan: call ready. Verify that the service sets the client id correctly and reissues
         * pending registrations.
         */
 
         // Persist some registrations.
         InvalidationPreferences invPrefs = new InvalidationPreferences(getContext());
         EditContext editContext = invPrefs.edit();
         invPrefs.setSyncTypes(editContext, CollectionUtil.newArrayList("BOOKMARK", "SESSION"));
+        ObjectId objectId = ObjectId.newInstance(1, "obj".getBytes());
+        invPrefs.setObjectIds(editContext, CollectionUtil.newArrayList(objectId));
         assertTrue(invPrefs.commit(editContext));
 
         // Issue ready.
         getService().ready(CLIENT_ID);
         assertTrue(Arrays.equals(CLIENT_ID, InvalidationService.getClientIdForTest()));
         byte[] otherCid = "otherCid".getBytes();
         getService().ready(otherCid);
         assertTrue(Arrays.equals(otherCid, InvalidationService.getClientIdForTest()));
 
         // Verify registrations issued.
         assertEquals(CollectionUtil.newHashSet(
-                ModelType.BOOKMARK.toObjectId(), ModelType.SESSION.toObjectId()),
+                ModelType.BOOKMARK.toObjectId(), ModelType.SESSION.toObjectId(), objectId),
                 new HashSet<ObjectId>(getService().mRegistrations.get(0)));
     }
 
     @SmallTest
     @Feature({"Sync"})
     public void testReissueRegistrations() {
         /*
          * Test plan: call the reissueRegistrations method of the listener with both empty and
          * non-empty sets of desired registrations stored in preferences. Verify that no register
          * intent is set in the first case and that the appropriate register intent is sent in
          * the second.
          */
 
         // No persisted registrations.
         getService().reissueRegistrations(CLIENT_ID);
         assertTrue(getService().mRegistrations.isEmpty());
 
         // Persist some registrations.
         InvalidationPreferences invPrefs = new InvalidationPreferences(getContext());
         EditContext editContext = invPrefs.edit();
         invPrefs.setSyncTypes(editContext, CollectionUtil.newArrayList("BOOKMARK", "SESSION"));
+        ObjectId objectId = ObjectId.newInstance(1, "obj".getBytes());
+        invPrefs.setObjectIds(editContext, CollectionUtil.newArrayList(objectId));
         assertTrue(invPrefs.commit(editContext));
 
         // Reissue registrations and verify that the appropriate registrations are issued.
         getService().reissueRegistrations(CLIENT_ID);
         assertEquals(1, getService().mRegistrations.size());
         assertEquals(CollectionUtil.newHashSet(
-                ModelType.BOOKMARK.toObjectId(), ModelType.SESSION.toObjectId()),
+                ModelType.BOOKMARK.toObjectId(), ModelType.SESSION.toObjectId(), objectId),
                 new HashSet<ObjectId>(getService().mRegistrations.get(0)));
     }
 
     @SmallTest
     @Feature({"Sync"})
     public void testInformRegistrationStatus() {
         /*
          * Test plan: call inform registration status under a variety of circumstances and verify
          * that the appropriate (un)register calls are issued.
          *
          * 1. Registration of desired object. No calls issued.
          * 2. Unregistration of undesired object. No calls issued.
          * 3. Registration of undesired object. Unregistration issued.
          * 4. Unregistration of desired object. Registration issued.
          */
         // Initial test setup: persist a single registration into preferences.
         InvalidationPreferences invPrefs = new InvalidationPreferences(getContext());
         EditContext editContext = invPrefs.edit();
         invPrefs.setSyncTypes(editContext, CollectionUtil.newArrayList("SESSION"));
+        ObjectId desiredObjectId = ObjectId.newInstance(1, "obj1".getBytes());
+        ObjectId undesiredObjectId = ObjectId.newInstance(1, "obj2".getBytes());
+        invPrefs.setObjectIds(editContext, CollectionUtil.newArrayList(desiredObjectId));
         assertTrue(invPrefs.commit(editContext));
 
         // Cases 1 and 2: calls matching desired state cause no actions.
         getService().informRegistrationStatus(CLIENT_ID, ModelType.SESSION.toObjectId(),
                 RegistrationState.REGISTERED);
+        getService().informRegistrationStatus(CLIENT_ID, desiredObjectId,
+                RegistrationState.REGISTERED);
         getService().informRegistrationStatus(CLIENT_ID, ModelType.BOOKMARK.toObjectId(),
                 RegistrationState.UNREGISTERED);
+        getService().informRegistrationStatus(CLIENT_ID, undesiredObjectId,
+                RegistrationState.UNREGISTERED);
         assertTrue(getService().mRegistrations.isEmpty());
         assertTrue(getService().mUnregistrations.isEmpty());
 
         // Case 3: registration of undesired object triggers an unregistration.
         getService().informRegistrationStatus(CLIENT_ID, ModelType.BOOKMARK.toObjectId(),
                 RegistrationState.REGISTERED);
-        assertEquals(1, getService().mUnregistrations.size());
+        getService().informRegistrationStatus(CLIENT_ID, undesiredObjectId,
+                RegistrationState.REGISTERED);
+        assertEquals(2, getService().mUnregistrations.size());
         assertEquals(0, getService().mRegistrations.size());
         assertEquals(CollectionUtil.newArrayList(ModelType.BOOKMARK.toObjectId()),
                 getService().mUnregistrations.get(0));
+        assertEquals(CollectionUtil.newArrayList(undesiredObjectId),
+                getService().mUnregistrations.get(1));
 
         // Case 4: unregistration of a desired object triggers a registration.
         getService().informRegistrationStatus(CLIENT_ID, ModelType.SESSION.toObjectId(),
                 RegistrationState.UNREGISTERED);
-        assertEquals(1, getService().mUnregistrations.size());
-        assertEquals(1, getService().mRegistrations.size());
+        getService().informRegistrationStatus(CLIENT_ID, desiredObjectId,
+                RegistrationState.UNREGISTERED);
+        assertEquals(2, getService().mUnregistrations.size());
+        assertEquals(2, getService().mRegistrations.size());
         assertEquals(CollectionUtil.newArrayList(ModelType.SESSION.toObjectId()),
                 getService().mRegistrations.get(0));
+        assertEquals(CollectionUtil.newArrayList(desiredObjectId),
+                getService().mRegistrations.get(1));
     }
 
     @SmallTest
     @Feature({"Sync"})
     public void testInformRegistrationFailure() {
         /*
          * Test plan: call inform registration failure under a variety of circumstances and verify
          * that the appropriate (un)register calls are issued.
          *
          * 1. Transient registration failure for an object that should be registered. Register
          *    should be called.
          * 2. Permanent registration failure for an object that should be registered. No calls.
          * 3. Transient registration failure for an object that should not be registered. Unregister
          *    should be called.
          * 4. Permanent registration failure for an object should not be registered. No calls.
          */
 
         // Initial test setup: persist a single registration into preferences.
         InvalidationPreferences invPrefs = new InvalidationPreferences(getContext());
         EditContext editContext = invPrefs.edit();
         invPrefs.setSyncTypes(editContext, CollectionUtil.newArrayList("SESSION"));
+        ObjectId desiredObjectId = ObjectId.newInstance(1, "obj1".getBytes());
+        ObjectId undesiredObjectId = ObjectId.newInstance(1, "obj2".getBytes());
+        invPrefs.setObjectIds(editContext, CollectionUtil.newArrayList(desiredObjectId));
         assertTrue(invPrefs.commit(editContext));
 
         // Cases 2 and 4: permanent registration failures never cause calls to be made.
         getService().informRegistrationFailure(CLIENT_ID, ModelType.SESSION.toObjectId(), false,
                 "");
         getService().informRegistrationFailure(CLIENT_ID, ModelType.BOOKMARK.toObjectId(), false,
                 "");
+        getService().informRegistrationFailure(CLIENT_ID, desiredObjectId, false, "");
+        getService().informRegistrationFailure(CLIENT_ID, undesiredObjectId, false, "");
         assertTrue(getService().mRegistrations.isEmpty());
         assertTrue(getService().mUnregistrations.isEmpty());
 
         // Case 1: transient failure of a desired registration results in re-registration.
         getService().informRegistrationFailure(CLIENT_ID, ModelType.SESSION.toObjectId(), true, "");
-        assertEquals(1, getService().mRegistrations.size());
+        getService().informRegistrationFailure(CLIENT_ID, desiredObjectId, true, "");
+        assertEquals(2, getService().mRegistrations.size());
         assertTrue(getService().mUnregistrations.isEmpty());
         assertEquals(CollectionUtil.newArrayList(ModelType.SESSION.toObjectId()),
                 getService().mRegistrations.get(0));
+        assertEquals(CollectionUtil.newArrayList(desiredObjectId),
+                getService().mRegistrations.get(1));
 
         // Case 3: transient failure of an undesired registration results in unregistration.
         getService().informRegistrationFailure(CLIENT_ID, ModelType.BOOKMARK.toObjectId(), true,
                 "");
-        assertEquals(1, getService().mRegistrations.size());
-        assertEquals(1, getService().mUnregistrations.size());
+        getService().informRegistrationFailure(CLIENT_ID, undesiredObjectId, true, "");
+        assertEquals(2, getService().mRegistrations.size());
+        assertEquals(2, getService().mUnregistrations.size());
         assertEquals(CollectionUtil.newArrayList(ModelType.BOOKMARK.toObjectId()),
                 getService().mUnregistrations.get(0));
+        assertEquals(CollectionUtil.newArrayList(undesiredObjectId),
+                getService().mUnregistrations.get(1));
     }
 
     @SmallTest
     @Feature({"Sync"})
     public void testInformError() {
         /*
          * Test plan: call informError with both permanent and transient errors. Verify that
          * the transient error causes no action to be taken and that the permanent error causes
          * the client to be stopped.
          */
@@ skipping 42 matching lines @@
         doTestInvalidate(false);
     }
 
     private void doTestInvalidate(boolean hasPayload) {
         /*
          * Test plan: call invalidate() with an invalidation that may or may not have a payload.
          * Verify the produced bundle has the correct fields.
          */
         // Call invalidate.
         int version = 4747;
-        ObjectId objectId = ModelType.BOOKMARK.toObjectId();
+        ObjectId objectId = ObjectId.newInstance(55, "BOOKMARK".getBytes());
         final String payload = "testInvalidate-" + hasPayload;
         Invalidation invalidation = hasPayload ?
                 Invalidation.newInstance(objectId, version, payload.getBytes()) :
                 Invalidation.newInstance(objectId, version);
         byte[] ackHandle = ("testInvalidate-" + hasPayload).getBytes();
         getService().invalidate(invalidation, ackHandle);
 
         // Validate bundle.
         assertEquals(1, getService().mRequestedSyncs.size());
         Bundle syncBundle = getService().mRequestedSyncs.get(0);
+        assertEquals(55, syncBundle.getInt("objectSource"));
         assertEquals("BOOKMARK", syncBundle.getString("objectId"));
         assertEquals(version, syncBundle.getLong("version"));
         assertEquals(hasPayload ? payload : "", syncBundle.getString("payload"));
 
         // Ensure acknowledged.
         assertSingleAcknowledgement(ackHandle);
     }
 
     @SmallTest
     @Feature({"Sync"})
     public void testInvalidateUnknownVersion() {
         /*
          * Test plan: call invalidateUnknownVersion(). Verify the produced bundle has the correct
          * fields.
          */
-        ObjectId objectId = ModelType.BOOKMARK.toObjectId();
+        ObjectId objectId = ObjectId.newInstance(55, "BOOKMARK".getBytes());
         byte[] ackHandle = "testInvalidateUV".getBytes();
         getService().invalidateUnknownVersion(objectId, ackHandle);
 
         // Validate bundle.
         assertEquals(1, getService().mRequestedSyncs.size());
         Bundle syncBundle = getService().mRequestedSyncs.get(0);
+        assertEquals(55, syncBundle.getInt("objectSource"));
         assertEquals("BOOKMARK", syncBundle.getString("objectId"));
         assertEquals(0, syncBundle.getLong("version"));
         assertEquals("", syncBundle.getString("payload"));
 
         // Ensure acknowledged.
         assertSingleAcknowledgement(ackHandle);
     }
 
     @SmallTest
     @Feature({"Sync"})
@@ skipping 116 matching lines @@
         Intent registrationIntent = IntentProtocol.createRegisterIntent(account, false,
                 desiredRegistrations);
         getService().onHandleIntent(registrationIntent);
 
         // Verify client started and state written.
         assertTrue(InvalidationService.getIsClientStartedForTest());
         InvalidationPreferences invPrefs = new InvalidationPreferences(getContext());
         assertEquals(account, invPrefs.getSavedSyncedAccount());
         assertEquals(ModelType.modelTypesToSyncTypes(desiredRegistrations),
                 invPrefs.getSavedSyncedTypes());
+        assertNull(invPrefs.getSavedObjectIds());
         assertEquals(1, mStartServiceIntents.size());
         assertTrue(isAndroidListenerStartIntent(mStartServiceIntents.get(0)));
 
         // Send another registration-change intent, this type with all-types set to true, and
         // verify that the on-disk state is updated and that no addition Intents are issued.
         getService().onHandleIntent(IntentProtocol.createRegisterIntent(account, true, null));
         assertEquals(account, invPrefs.getSavedSyncedAccount());
         assertEquals(CollectionUtil.newHashSet(ModelType.ALL_TYPES_TYPE),
                 invPrefs.getSavedSyncedTypes());
         assertEquals(1, mStartServiceIntents.size());
 
         // Finally, send one more registration-change intent, this time with a different account,
         // and verify that it both updates the account, stops thye existing client, and
         // starts a new client.
         Account account2 = AccountManagerHelper.createAccountFromName("test2@example.com");
         getService().onHandleIntent(IntentProtocol.createRegisterIntent(account2, true, null));
         assertEquals(account2, invPrefs.getSavedSyncedAccount());
         assertEquals(3, mStartServiceIntents.size());
         assertTrue(isAndroidListenerStartIntent(mStartServiceIntents.get(0)));
         assertTrue(isAndroidListenerStopIntent(mStartServiceIntents.get(1)));
         assertTrue(isAndroidListenerStartIntent(mStartServiceIntents.get(2)));
     }
 
+    /**
+     * Determines if the correct object ids have been written to preferences and registered with the
+     * invalidation client.
+     *
+     * @param expectedTypes The Sync types expected to be registered.
+     * @param expectedObjectIds The additional object ids expected to be registered.
+     * @param isReady Whether the client is ready to register/unregister.
+     */
+    private boolean expectedObjectIdsRegistered(Set<ModelType> expectedTypes,
+            Set<ObjectId> expectedObjectIds, boolean isReady) {
+        // Get synced types saved to preferences.
+        Set<String> expectedSyncTypes = ModelType.modelTypesToSyncTypes(expectedTypes);
+        InvalidationPreferences invPrefs = new InvalidationPreferences(getContext());
+        Set<String> actualSyncTypes = invPrefs.getSavedSyncedTypes();
+        if (actualSyncTypes == null) {
+            actualSyncTypes = new HashSet<String>();
+        }
+
+        // Get object ids saved to preferences.
+        Set<ObjectId> actualObjectIds = invPrefs.getSavedObjectIds();
+        if (actualObjectIds == null) {
+            actualObjectIds = new HashSet<ObjectId>();
+        }
+
+        // Get expected registered object ids.
+        Set<ObjectId> expectedRegisteredIds = new HashSet<ObjectId>();
+        if (isReady) {
+            expectedRegisteredIds.addAll(ModelType.modelTypesToObjectIds(expectedTypes));
+            expectedRegisteredIds.addAll(expectedObjectIds);
+        }
+
+        return actualSyncTypes.equals(expectedSyncTypes) &&
+                actualObjectIds.equals(expectedObjectIds) &&
+                getService().mCurrentRegistrations.equals(expectedRegisteredIds);
+    }
+
+    @SmallTest
+    @Feature({"Sync"})
+    public void testRegistrationIntentWithTypesAndObjectIds() {
+        /*
+         * Test plan: send a mix of registration-change intents: some for Sync types and some for
+         * object ids. Verify that registering for Sync types does not interfere with object id
+         * registration and vice-versa.
+         */
+        getService().setShouldRunStates(true, true);
+        getService().onCreate();
+
+        Account account = AccountManagerHelper.createAccountFromName("test@example.com");
+        Set<ObjectId> objectIds = new HashSet<ObjectId>();
+        Set<ModelType> types = new HashSet<ModelType>();
+
+        // Register for some object ids.
+        objectIds.add(ObjectId.newInstance(1, "obj1".getBytes()));
+        objectIds.add(ObjectId.newInstance(2, "obj2".getBytes()));
+        Intent registrationIntent = IntentProtocol.createRegisterIntent(account, new int[] {1, 2},
+                new String[] {"obj1", "obj2"});
+        getService().onHandleIntent(registrationIntent);
+        assertTrue(expectedObjectIdsRegistered(types, objectIds, false /* isReady */));
+
+        // Register for some types.
+        types.add(ModelType.BOOKMARK);
+        types.add(ModelType.SESSION);
+        registrationIntent = IntentProtocol.createRegisterIntent(account, false, types);
+        getService().onHandleIntent(registrationIntent);
+        assertTrue(expectedObjectIdsRegistered(types, objectIds, false /* isReady */));
+
+        // Set client to be ready and verify registrations.
+        getService().ready(CLIENT_ID);
+        assertTrue(expectedObjectIdsRegistered(types, objectIds, true /* isReady */));
+
+        // Change object id registration with types registered.
+        objectIds.add(ObjectId.newInstance(3, "obj3".getBytes()));
+        registrationIntent = IntentProtocol.createRegisterIntent(account, new int[] {1, 2, 3},
+                new String[] {"obj1", "obj2", "obj3"});
+        getService().onHandleIntent(registrationIntent);
+        assertTrue(expectedObjectIdsRegistered(types, objectIds, true /* isReady */));
+
+        // Change type registration with object ids registered.
+        types.remove(ModelType.BOOKMARK);
+        registrationIntent = IntentProtocol.createRegisterIntent(account, false, types);
+        getService().onHandleIntent(registrationIntent);
+        assertTrue(expectedObjectIdsRegistered(types, objectIds, true /* isReady */));
+
+        // Unregister all types.
+        types.clear();
+        registrationIntent = IntentProtocol.createRegisterIntent(account, false, types);
+        getService().onHandleIntent(registrationIntent);
+        assertTrue(expectedObjectIdsRegistered(types, objectIds, true /* isReady */));
+
+        // Change object id registration with no types registered.
+        objectIds.remove(ObjectId.newInstance(2, "obj2".getBytes()));
+        registrationIntent = IntentProtocol.createRegisterIntent(account, new int[] {1, 3},
+                new String[] {"obj1", "obj3"});
+        getService().onHandleIntent(registrationIntent);
+        assertTrue(expectedObjectIdsRegistered(types, objectIds, true /* isReady */));
+
+        // Unregister all object ids.
+        objectIds.clear();
+        registrationIntent = IntentProtocol.createRegisterIntent(account, new int[0],
+                new String[0]);
+        getService().onHandleIntent(registrationIntent);
+        assertTrue(expectedObjectIdsRegistered(types, objectIds, true /* isReady */));
+
+        // Change type registration with no object ids registered.
+        types.add(ModelType.BOOKMARK);
+        types.add(ModelType.PASSWORD);
+        registrationIntent = IntentProtocol.createRegisterIntent(account, false, types);
+        getService().onHandleIntent(registrationIntent);
+        assertTrue(expectedObjectIdsRegistered(types, objectIds, true /* isReady */));
+    }
+
     @SmallTest
     @Feature({"Sync"})
     public void testRegistrationIntentNoProxyTabsUsingReady() {
         getService().setShouldRunStates(true, true);
         getService().onCreate();
 
         // Send register Intent.
         Account account = AccountManagerHelper.createAccountFromName("test@example.com");
         Intent registrationIntent = IntentProtocol.createRegisterIntent(account, true, null);
         getService().onHandleIntent(registrationIntent);
@@ skipping 141 matching lines @@
                 InvalidationService.CLIENT_TYPE, "unused".getBytes());
         return intent.getExtras().keySet().equals(startIntent.getExtras().keySet());
     }
 
     /** Returns whether {@code intent} is an {@link AndroidListener} stop intent. */
     private boolean isAndroidListenerStopIntent(Intent intent) {
         Intent stopIntent = AndroidListener.createStopIntent(getContext());
         return intent.getExtras().keySet().equals(stopIntent.getExtras().keySet());
     }
 }