Reuse existing code for finding least recent index offset.

Author: ehsannas

firebase-firestore/src/main/java/com/google/firebase/firestore/local/IndexBackfiller.java

@@ -21,11 +21,9 @@
 import com.google.firebase.database.collection.ImmutableSortedMap;
 import com.google.firebase.firestore.model.Document;
 import com.google.firebase.firestore.model.DocumentKey;
-import com.google.firebase.firestore.model.FieldIndex;
 import com.google.firebase.firestore.model.FieldIndex.IndexOffset;
 import com.google.firebase.firestore.util.AsyncQueue;
 import com.google.firebase.firestore.util.Logger;
-import java.util.Collection;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Map;
@@ -137,7 +135,8 @@ private int writeEntriesForCollectionGroup(
     // TODO(indexing): Support mutation batch Ids when sorting and writing indexes.
 
     // Use the earliest offset of all field indexes to query the local cache.
-    IndexOffset existingOffset = getExistingOffset(indexManager.getFieldIndexes(collectionGroup));
+    IndexOffset existingOffset =
+        indexManager.getLeastRecentIndexOffset(indexManager.getFieldIndexes(collectionGroup));
     ImmutableSortedMap<DocumentKey, Document> documents =
         localDocumentsView.getDocuments(collectionGroup, existingOffset, entriesRemainingUnderCap);
     indexManager.updateIndexEntries(documents);
@@ -148,18 +147,6 @@ private int writeEntriesForCollectionGroup(
     return documents.size();
   }
 
-  /** Returns the lowest offset for the provided index group. */
-  private IndexOffset getExistingOffset(Collection<FieldIndex> fieldIndexes) {
-    IndexOffset lowestOffset = null;
-    for (FieldIndex fieldIndex : fieldIndexes) {
-      if (lowestOffset == null
-          || fieldIndex.getIndexState().getOffset().compareTo(lowestOffset) < 0) {
-        lowestOffset = fieldIndex.getIndexState().getOffset();
-      }
-    }
-    return lowestOffset == null ? IndexOffset.NONE : lowestOffset;
-  }
-
   /** Returns the offset for the index based on the newly indexed documents. */
   private IndexOffset getNewOffset(
       ImmutableSortedMap<DocumentKey, Document> documents, IndexOffset currentOffset) {

firebase-firestore/src/main/java/com/google/firebase/firestore/local/IndexManager.java

@@ -79,10 +79,14 @@ public interface IndexManager {
 
   /**
    * Iterates over all field indexes that are used to serve the given target, and returns the least
-   * recent offset of them all.
+   * recent offset of them all. Returns {@code FieldIndex.IndexOffset.NONE} if the target cannot be
+   * served from the index.
    */
   FieldIndex.IndexOffset getLeastRecentIndexOffset(Target target);
 
+  /** Returns the lowest offset for the provided index group. */
+  FieldIndex.IndexOffset getLeastRecentIndexOffset(Collection<FieldIndex> fieldIndexes);
+
   /**
    * Returns an index that can be used to serve the provided target. Returns {@code null} if no
    * index is configured.

firebase-firestore/src/main/java/com/google/firebase/firestore/local/SQLiteIndexManager.java

@@ -296,22 +296,30 @@ public boolean canServeFromIndex(Target target) {
     return true;
   }
 
-  // TODO(orquery): This looks awfully like `getExistingOffset` in IndexBackfillter. Refactor.
+  @Override
+  public FieldIndex.IndexOffset getLeastRecentIndexOffset(Collection<FieldIndex> fieldIndexes) {
+    FieldIndex.IndexOffset lowestOffset = null;
+    for (FieldIndex fieldIndex : fieldIndexes) {
+      if (lowestOffset == null
+          || fieldIndex.getIndexState().getOffset().compareTo(lowestOffset) < 0) {
+        lowestOffset = fieldIndex.getIndexState().getOffset();
+      }
+    }
+    return lowestOffset == null ? FieldIndex.IndexOffset.NONE : lowestOffset;
+  }
+
   @Override
   public FieldIndex.IndexOffset getLeastRecentIndexOffset(Target target) {
-    FieldIndex.IndexOffset min = null;
+    List<FieldIndex> fieldIndexes = new ArrayList<>();
     for (Target subTarget : getSubTargets(target)) {
       FieldIndex index = getFieldIndex(subTarget);
       if (index == null) {
         // If any of this target's sub-queries does not have a field index, return NONE.
         return FieldIndex.IndexOffset.NONE;
       }
-      FieldIndex.IndexOffset candidate = index.getIndexState().getOffset();
-      if (min == null || candidate.compareTo(min) < 0) {
-        min = candidate;
-      }
+      fieldIndexes.add(index);
     }
-    return min == null ? FieldIndex.IndexOffset.NONE : min;
+    return getLeastRecentIndexOffset(fieldIndexes);
   }
 
   private List<Target> getSubTargets(Target target) {