[Android] Only invalidate objects that were received from Tango on resume.

chrome/android/javatests_shell/src/org/chromium/chrome/browser/sync/DelayedSyncControllerTest.java

Index: chrome/android/javatests_shell/src/org/chromium/chrome/browser/sync/DelayedSyncControllerTest.java
diff --git a/chrome/android/javatests_shell/src/org/chromium/chrome/browser/sync/DelayedSyncControllerTest.java b/chrome/android/javatests_shell/src/org/chromium/chrome/browser/sync/DelayedSyncControllerTest.java
index d08621a29cfb1f41c233fd3b369ae924c17e1ce3..aaa4b13fd8bef296e33b2cbff75fe38ecc8d95e4 100644
--- a/chrome/android/javatests_shell/src/org/chromium/chrome/browser/sync/DelayedSyncControllerTest.java
+++ b/chrome/android/javatests_shell/src/org/chromium/chrome/browser/sync/DelayedSyncControllerTest.java
@@ -18,32 +18,54 @@ import org.chromium.base.ApplicationStatus;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.test.util.Feature;
 import org.chromium.chrome.shell.ChromeShellTestBase;
+import org.chromium.components.invalidation.PendingInvalidation;
 import org.chromium.content.browser.test.util.Criteria;
 import org.chromium.content.browser.test.util.CriteriaHelper;
-import org.chromium.sync.signin.AccountManagerHelper;
 
+import java.util.List;
+
+/**
+ * Tests for DelayedSyncController.
+ */
 public class DelayedSyncControllerTest extends ChromeShellTestBase {
-    private static final Account TEST_ACCOUNT =
-            AccountManagerHelper.createAccountFromName("something@gmail.com");
+    private static final String TEST_ACCOUNT = "something@gmail.com";
     private static final long WAIT_FOR_LAUNCHER_MS = scaleTimeout(10 * 1000);
     private static final long POLL_INTERVAL_MS = 100;
-    private TestDelayedSyncController mController;
 
-    private static class TestDelayedSyncController extends DelayedSyncController {
-        private boolean mSyncRequested;
+    private static final String OBJECT_ID = "object_id";
+    private static final int OBJECT_SRC = 4;
+    private static final long VERSION = 1L;
+    private static final String PAYLOAD = "payload";
+
+    private static final String OBJECT_ID_2 = "object_id_2";
+    private static final int OBJECT_SRC_2 = 5;
+    private static final long VERSION_2 = 2L;
+    private static final String PAYLOAD_2 = "payload_2";
+
+    private MockDelayedSyncController mController;
+
+    /**
+     * Mocks {@link DelayedSyncController} for testing.
+     * It intercepts access to the Android Sync Adapter.
+     */
+    private static class MockDelayedSyncController extends DelayedSyncController {
+        private boolean mInvalidated = false;
+        private List<Bundle> mBundles = null;
 
-        private TestDelayedSyncController() {}
+        private MockDelayedSyncController() {}
 
         @Override
-        void requestSyncOnBackgroundThread(Context context, Account account) {
-            mSyncRequested = true;
+        void notifyInvalidationsOnBackgroundThread(
+                Context context, Account account, List<Bundle> bundles) {
+            mInvalidated = true;
+            mBundles = bundles;
         }
     }
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
-        mController = new TestDelayedSyncController();
+        mController = new MockDelayedSyncController();
         launchChromeShellWithBlankPage();
     }
 
@@ -54,20 +76,19 @@ public class DelayedSyncControllerTest extends ChromeShellTestBase {
         assertTrue(isActivityResumed());
         Bundle extras = new Bundle();
         extras.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
-        assertTrue(mController.shouldPerformSync(getActivity(), extras, TEST_ACCOUNT));
+        assertTrue(mController.shouldNotifyInvalidation(extras));
 
         // Sync should trigger for manual requests when Chrome is in the background.
         sendChromeToBackground(getActivity());
         extras.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
-        assertTrue(mController.shouldPerformSync(getActivity(), extras, TEST_ACCOUNT));
+        assertTrue(mController.shouldNotifyInvalidation(extras));
     }
 
     @SmallTest
     @Feature({"Sync"})
     public void testSyncRequestsShouldTriggerSyncWhenChromeIsInForeground() {
         assertTrue(isActivityResumed());
-        Bundle extras = new Bundle();
-        assertTrue(mController.shouldPerformSync(getActivity(), extras, TEST_ACCOUNT));
+        assertTrue(mController.shouldNotifyInvalidation(new Bundle()));
     }
 
     @SmallTest
@@ -75,26 +96,73 @@ public class DelayedSyncControllerTest extends ChromeShellTestBase {
     public void testSyncRequestsWhenChromeIsInBackgroundShouldBeDelayed()
             throws InterruptedException {
         sendChromeToBackground(getActivity());
-        Bundle extras = new Bundle();
-        assertFalse(mController.shouldPerformSync(getActivity(), extras, TEST_ACCOUNT));
+        assertFalse(mController.shouldNotifyInvalidation(new Bundle()));
     }
 
     @SmallTest
     @Feature({"Sync"})
-    public void testDelayedSyncRequestsShouldBeTriggeredOnResume() throws InterruptedException {
-        // First make sure there are no delayed syncs.
-        mController.clearDelayedSyncs(getActivity());
-        assertFalse(mController.resumeDelayedSyncs(getActivity()));
-        assertFalse(mController.mSyncRequested);
+    public void testOnlySpecificInvalidationsTriggeredOnResume() throws InterruptedException {
+        // First make sure there are no pending invalidations.
+        mController.clearPendingInvalidations(getActivity());
+        assertFalse(mController.notifyPendingInvalidations(getActivity()));
+        assertFalse(mController.mInvalidated);
+
+        // Create some invalidations.
+        PendingInvalidation firstInv =
+                new PendingInvalidation(OBJECT_ID, OBJECT_SRC, VERSION, PAYLOAD);
+        PendingInvalidation secondInv =
+                new PendingInvalidation(OBJECT_ID_2, OBJECT_SRC_2, VERSION_2, PAYLOAD_2);
+
+        // Can't invalidate while Chrome is in the background.
+        sendChromeToBackground(getActivity());
+        assertFalse(mController.shouldNotifyInvalidation(new Bundle()));
+
+        // Add multiple pending invalidations.
+        mController.addPendingInvalidation(getActivity(), TEST_ACCOUNT, firstInv);
+        mController.addPendingInvalidation(getActivity(), TEST_ACCOUNT, secondInv);
 
-        // Trying to perform sync when Chrome is in the background should create a delayed sync.
+        // Make sure there are pending invalidations.
+        assertTrue(mController.notifyPendingInvalidations(getActivity()));
+        assertTrue(mController.mInvalidated);
+
+        // Ensure only specific invalidations are being notified.
+        assertEquals(2, mController.mBundles.size());
+        assertEquals(firstInv, new PendingInvalidation(mController.mBundles.get(0)));
+        assertEquals(secondInv, new PendingInvalidation(mController.mBundles.get(1)));
+    }
+
+    @SmallTest
+    @Feature({"Sync"})
+    public void testAllInvalidationsTriggeredOnResume() throws InterruptedException {
+        // First make sure there are no pending invalidations.
+        mController.clearPendingInvalidations(getActivity());
+        assertFalse(mController.notifyPendingInvalidations(getActivity()));
+        assertFalse(mController.mInvalidated);
+
+        // Create some invalidations.
+        PendingInvalidation firstInv =
+                new PendingInvalidation(OBJECT_ID, OBJECT_SRC, VERSION, PAYLOAD);
+        PendingInvalidation secondInv =
+                new PendingInvalidation(OBJECT_ID_2, OBJECT_SRC_2, VERSION_2, PAYLOAD_2);
+        PendingInvalidation allInvalidations = new PendingInvalidation(new Bundle());
+        assertEquals(allInvalidations.mObjectSource, 0);
+
+        // Can't invalidate while Chrome is in the background.
         sendChromeToBackground(getActivity());
-        Bundle extras = new Bundle();
-        assertFalse(mController.shouldPerformSync(getActivity(), extras, TEST_ACCOUNT));
+        assertFalse(mController.shouldNotifyInvalidation(new Bundle()));
+
+        // Add multiple pending invalidations.
+        mController.addPendingInvalidation(getActivity(), TEST_ACCOUNT, firstInv);
+        mController.addPendingInvalidation(getActivity(), TEST_ACCOUNT, allInvalidations);
+        mController.addPendingInvalidation(getActivity(), TEST_ACCOUNT, secondInv);
+
+        // Make sure there are pending invalidations.
+        assertTrue(mController.notifyPendingInvalidations(getActivity()));
+        assertTrue(mController.mInvalidated);
 
-        // Make sure the delayed sync can be resumed.
-        assertTrue(mController.resumeDelayedSyncs(getActivity()));
-        assertTrue(mController.mSyncRequested);
+        // As Invalidation for all ids has been received, it will supersede all other invalidations.
+        assertEquals(1, mController.mBundles.size());
+        assertEquals(allInvalidations, new PendingInvalidation(mController.mBundles.get(0)));
     }
 
     @VisibleForTesting