[Sync] Store only latest versions of invalidations in DelayedInvalidationsController

chrome/android/java/src/org/chromium/chrome/browser/invalidation/DelayedInvalidationsController.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.chrome.browser.invalidation;
 
 import android.accounts.Account;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.os.AsyncTask;
 import android.os.Bundle;
 
+import org.chromium.base.ApiCompatibilityUtils;
 import org.chromium.base.ApplicationStatus;
 import org.chromium.base.ContextUtils;
 import org.chromium.base.Log;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.components.invalidation.PendingInvalidation;
 import org.chromium.components.signin.AccountManagerHelper;
 import org.chromium.components.sync.AndroidSyncSettings;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 
 /**
  * A class for controlling whether an invalidation should be notified immediately, or should be
  * delayed until Chrome comes to the foreground again.
  */
 public class DelayedInvalidationsController {
     private static final String TAG = "invalidation";
     private static final String DELAYED_ACCOUNT_NAME = "delayed_account";
@@ skipping 51 matching lines @@
 
     /**
      * Stores preferences to indicate that an invalidation has arrived, but dropped on the floor.
      */
     @VisibleForTesting
     void addPendingInvalidation(Context context, String account, PendingInvalidation invalidation) {
         SharedPreferences prefs = ContextUtils.getAppSharedPreferences();
         String oldAccount = prefs.getString(DELAYED_ACCOUNT_NAME, null);
         // Make sure to construct a new set so it can be modified safely. See crbug.com/568369.
         Set<String> invals = new HashSet<String>(
-                prefs.getStringSet(DELAYED_INVALIDATIONS, new HashSet<String>(1)));
+                prefs.getStringSet(DELAYED_INVALIDATIONS, Collections.<String>emptySet()));
         assert invals.isEmpty() || oldAccount != null;
-        if (oldAccount != null && !oldAccount.equals(account)) {
-            invals.clear();
+        boolean invalidateAllTypes = false;
+        // We invalidate all types if:
+        // - the account has changed
+        // - we were in "invalidate all types" mode already
+        // - new invalidation indicates to invalidate all types by setting source to 0
+        // - adding invalidation to the current set failed
+        if (oldAccount != null && !oldAccount.equals(account)) invalidateAllTypes = true;
+        if (oldAccount != null && invals.isEmpty()) invalidateAllTypes = true;
+        if (invalidation.mObjectSource == 0) invalidateAllTypes = true;
+        if (!invalidateAllTypes && !addInvalidationToSet(invalidation, invals)) {
+            invalidateAllTypes = true;
         }
+
         SharedPreferences.Editor editor = prefs.edit();
         editor.putString(DELAYED_ACCOUNT_NAME, account);
-        if (invalidation.mObjectSource == 0 || (oldAccount != null && invals.isEmpty())) {
-            editor.putStringSet(DELAYED_INVALIDATIONS, null);
+        if (invalidateAllTypes) {
+            editor.remove(DELAYED_INVALIDATIONS);
         } else {
-            invals.add(invalidation.encodeToString());
             editor.putStringSet(DELAYED_INVALIDATIONS, invals);
         }
         editor.apply();
     }
 
+    /**
+     * Adds newInvalidation into set of encoded invalidations. Invalidations with the same id/source
+     * and lower version are removed from the set. If invalidation with same or higher version is
+     * is present, then new invalidation is discarded.
+     * @return true if update is successful, false when decoding invalidation from string fails.
+     */
+    private boolean addInvalidationToSet(
+            PendingInvalidation newInvalidation, Set<String> invalidations) {
+        for (Iterator<String> iter = invalidations.iterator(); iter.hasNext();) {
+            String encodedInvalidation = iter.next();
+            PendingInvalidation invalidation =
+                    PendingInvalidation.decodeToPendingInvalidation(encodedInvalidation);
+            if (invalidation == null) return false;
+            if (ApiCompatibilityUtils.objectEquals(
+                        invalidation.mObjectId, newInvalidation.mObjectId)
+                    && invalidation.mObjectSource == newInvalidation.mObjectSource) {
+                if (invalidation.mVersion >= newInvalidation.mVersion) return true;
+                iter.remove();
+            }
+        }
+        invalidations.add(newInvalidation.encodeToString());
+        return true;
+    }
+
     private List<Bundle> popPendingInvalidations(final Context context) {
         SharedPreferences prefs = ContextUtils.getAppSharedPreferences();
         assert prefs.contains(DELAYED_ACCOUNT_NAME);
         Set<String> savedInvalidations = prefs.getStringSet(DELAYED_INVALIDATIONS, null);
         clearPendingInvalidations(context);
         // Absence of specific invalidations indicates invalidate all types.
         if (savedInvalidations == null) return Arrays.asList(new Bundle());
 
         List<Bundle> bundles = new ArrayList<Bundle>(savedInvalidations.size());
         for (String invalidation : savedInvalidations) {
@@ skipping 25 matching lines @@
     }
 
     private static boolean isManualRequest(Bundle extras) {
         if (extras.getBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, false)) {
             Log.d(TAG, "Manual sync requested.");
             return true;
         }
         return false;
     }
 }