Refactor: WatchChangeAggregatorTestingHooks -> TestingHooks and WatchChangeAggregatorTestingHooksAccessor -> ExistenceFilterMismatchListener

Author: dconeybe

firebase-firestore/src/androidTest/java/com/google/firebase/firestore/QueryTest.java

@@ -37,7 +37,7 @@
 import com.google.android.gms.tasks.Task;
 import com.google.common.collect.Lists;
 import com.google.firebase.firestore.Query.Direction;
-import com.google.firebase.firestore.remote.WatchChangeAggregatorTestingHooksAccessor;
+import com.google.firebase.firestore.remote.ExistenceFilterMismatchListener;
 import com.google.firebase.firestore.testutil.EventAccumulator;
 import com.google.firebase.firestore.testutil.IntegrationTestUtil;
 import java.util.ArrayList;
@@ -1079,26 +1079,23 @@ public void resumingAQueryShouldUseExistenceFilterToDetectDeletes() throws Excep
 
     // Resume the query and save the resulting snapshot for verification. Use some internal testing
     // hooks to "capture" the existence filter mismatches to verify them.
+    ExistenceFilterMismatchListener existenceFilterMismatchListener =
+        new ExistenceFilterMismatchListener();
     QuerySnapshot snapshot2;
-    WatchChangeAggregatorTestingHooksAccessor.ExistenceFilterMismatchInfo
-        existenceFilterMismatchInfo;
-    WatchChangeAggregatorTestingHooksAccessor.ExistenceFilterMismatchAccumulator
-        existenceFilterMismatchAccumulator =
-            new WatchChangeAggregatorTestingHooksAccessor.ExistenceFilterMismatchAccumulator();
-    existenceFilterMismatchAccumulator.register();
+    ExistenceFilterMismatchListener.ExistenceFilterMismatchInfo existenceFilterMismatchInfo;
     try {
+      existenceFilterMismatchListener.startListening();
       snapshot2 = waitFor(collection.get());
       // TODO(b/270731363): Remove the "if" condition below once the Firestore Emulator is fixed
       //  to send an existence filter.
       if (isRunningAgainstEmulator()) {
         existenceFilterMismatchInfo = null;
       } else {
         existenceFilterMismatchInfo =
-            existenceFilterMismatchAccumulator.waitForExistenceFilterMismatch(
-                /*timeoutMillis=*/ 5000);
+            existenceFilterMismatchListener.waitForExistenceFilterMismatch(/*timeoutMillis=*/ 5000);
       }
     } finally {
-      existenceFilterMismatchAccumulator.unregister();
+      existenceFilterMismatchListener.stopListening();
     }
 
     // Verify that the snapshot from the resumed query contains the expected documents; that is,

firebase-firestore/src/androidTest/java/com/google/firebase/firestore/remote/ExistenceFilterMismatchListener.java

@@ -0,0 +1,143 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.firebase.firestore.remote;
+
+import android.os.SystemClock;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.firebase.firestore.ListenerRegistration;
+import java.util.ArrayList;
+
+/**
+ * Provides a mechanism for tests to listen for existence filter mismatches in the Watch "listen"
+ * stream.
+ */
+public final class ExistenceFilterMismatchListener {
+
+  private TestingHooksExistenceFilterMismatchListenerImpl listener;
+  private ListenerRegistration listenerRegistration;
+
+  /**
+   * Starts listening for existence filter mismatches.
+   *
+   * @throws IllegalStateException if this object is already started.
+   * @see #stopListening
+   */
+  public synchronized void startListening() {
+    if (listener != null) {
+      throw new IllegalStateException("already registered");
+    }
+    listener = new TestingHooksExistenceFilterMismatchListenerImpl();
+    listenerRegistration = TestingHooks.getInstance().addExistenceFilterMismatchListener(listener);
+  }
+
+  /**
+   * Stops listening for existence filter mismatches.
+   *
+   * <p>If listening has not been started then this method does nothing.
+   *
+   * @see #startListening
+   */
+  public synchronized void stopListening() {
+    if (listenerRegistration != null) {
+      listenerRegistration.remove();
+    }
+    listenerRegistration = null;
+    listener = null;
+  }
+
+  /**
+   * Waits for an existence filter mismatch.
+   *
+   * @param timeoutMillis the amount of time, in milliseconds, to wait for an existence filter
+   *     mismatch.
+   * @return information about the existence filter mismatch that occurred.
+   * @throws InterruptedException if waiting is interrupted.
+   * @throws IllegalStateException if this object has not been started by {@link #startListening}.
+   * @throws IllegalArgumentException if the given timeout is less than or equal to zero.
+   */
+  @Nullable
+  public ExistenceFilterMismatchInfo waitForExistenceFilterMismatch(long timeoutMillis)
+      throws InterruptedException {
+    if (timeoutMillis <= 0) {
+      throw new IllegalArgumentException("invalid timeout: " + timeoutMillis);
+    }
+
+    TestingHooksExistenceFilterMismatchListenerImpl registeredListener;
+    synchronized (this) {
+      registeredListener = listener;
+    }
+
+    if (registeredListener == null) {
+      throw new IllegalStateException(
+          "must be registered before waiting for an existence filter mismatch");
+    }
+
+    return registeredListener.waitForExistenceFilterMismatch(timeoutMillis);
+  }
+
+  private static final class TestingHooksExistenceFilterMismatchListenerImpl
+      implements TestingHooks.ExistenceFilterMismatchListener {
+
+    private final ArrayList<ExistenceFilterMismatchInfo> existenceFilterMismatches =
+        new ArrayList<>();
+
+    @Override
+    public synchronized void onExistenceFilterMismatch(
+        @NonNull TestingHooks.ExistenceFilterMismatchInfo info) {
+      existenceFilterMismatches.add(new ExistenceFilterMismatchInfo(info));
+      notifyAll();
+    }
+
+    @Nullable
+    synchronized ExistenceFilterMismatchInfo waitForExistenceFilterMismatch(long timeoutMillis)
+        throws InterruptedException {
+      if (timeoutMillis <= 0) {
+        throw new IllegalArgumentException("invalid timeout: " + timeoutMillis);
+      }
+
+      long endTimeMillis = SystemClock.uptimeMillis() + timeoutMillis;
+      while (true) {
+        if (existenceFilterMismatches.size() > 0) {
+          return existenceFilterMismatches.remove(0);
+        }
+        long currentWaitMillis = endTimeMillis - SystemClock.uptimeMillis();
+        if (currentWaitMillis <= 0) {
+          return null;
+        }
+
+        wait(currentWaitMillis);
+      }
+    }
+  }
+
+  /** @see TestingHooks.ExistenceFilterMismatchInfo */
+  public static final class ExistenceFilterMismatchInfo {
+
+    private final TestingHooks.ExistenceFilterMismatchInfo info;
+
+    ExistenceFilterMismatchInfo(@NonNull TestingHooks.ExistenceFilterMismatchInfo info) {
+      this.info = info;
+    }
+
+    public int localCacheCount() {
+      return info.localCacheCount();
+    }
+
+    public int existenceFilterCount() {
+      return info.existenceFilterCount();
+    }
+  }
+}