minor refactor

Author: dconeybe

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

@@ -32,8 +32,6 @@
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 
-import android.os.SystemClock;
-import androidx.annotation.Nullable;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 import com.google.android.gms.tasks.Task;
 import com.google.common.collect.Lists;
@@ -1089,8 +1087,9 @@ public void resumingAQueryShouldUseBloomFilterToAvoidFullRequery() throws Except
       QuerySnapshot snapshot2;
       WatchChangeAggregatorTestingHooksAccessor.ExistenceFilterMismatchInfo
           existenceFilterMismatchInfo;
-      ExistenceFilterMismatchAccumulator existenceFilterMismatchAccumulator =
-          new ExistenceFilterMismatchAccumulator();
+      WatchChangeAggregatorTestingHooksAccessor.ExistenceFilterMismatchAccumulator
+          existenceFilterMismatchAccumulator =
+              new WatchChangeAggregatorTestingHooksAccessor.ExistenceFilterMismatchAccumulator();
       existenceFilterMismatchAccumulator.register();
       try {
         snapshot2 = waitFor(collection.get());
@@ -1183,76 +1182,6 @@ public void resumingAQueryShouldUseBloomFilterToAvoidFullRequery() throws Except
     }
   }
 
-  private static final class ExistenceFilterMismatchAccumulator {
-
-    private final ExistenceFilterMismatchListenerImpl listener =
-        new ExistenceFilterMismatchListenerImpl();
-    private ListenerRegistration listenerRegistration = null;
-
-    void register() {
-      if (listenerRegistration != null) {
-        throw new IllegalStateException("already registered");
-      }
-      listenerRegistration =
-          WatchChangeAggregatorTestingHooksAccessor.addExistenceFilterMismatchListener(listener);
-    }
-
-    void unregister() {
-      if (listenerRegistration == null) {
-        return;
-      }
-      listenerRegistration.remove();
-      listenerRegistration = null;
-    }
-
-    @Nullable
-    WatchChangeAggregatorTestingHooksAccessor.ExistenceFilterMismatchInfo
-        waitForExistenceFilterMismatch(long timeoutMillis) throws InterruptedException {
-      if (listenerRegistration == null) {
-        throw new IllegalStateException(
-            "must be registered before waiting for an existence filter mismatch");
-      }
-      return listener.waitForExistenceFilterMismatch(timeoutMillis);
-    }
-
-    private final class ExistenceFilterMismatchListenerImpl
-        implements WatchChangeAggregatorTestingHooksAccessor.ExistenceFilterMismatchListener {
-
-      private final ArrayList<WatchChangeAggregatorTestingHooksAccessor.ExistenceFilterMismatchInfo>
-          existenceFilterMismatches = new ArrayList<>();
-
-      @Override
-      public void onExistenceFilterMismatch(
-          WatchChangeAggregatorTestingHooksAccessor.ExistenceFilterMismatchInfo info) {
-        synchronized (existenceFilterMismatches) {
-          existenceFilterMismatches.add(info);
-          existenceFilterMismatches.notifyAll();
-        }
-      }
-
-      @Nullable
-      WatchChangeAggregatorTestingHooksAccessor.ExistenceFilterMismatchInfo
-          waitForExistenceFilterMismatch(long timeoutMillis) throws InterruptedException {
-        if (timeoutMillis <= 0) {
-          throw new IllegalArgumentException("invalid timeout: " + timeoutMillis);
-        }
-        synchronized (existenceFilterMismatches) {
-          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;
-            }
-            existenceFilterMismatches.wait(currentWaitMillis);
-          }
-        }
-      }
-    }
-  }
-
   // TODO(orquery): Enable this test when prod supports OR queries.
   @Ignore
   @Test

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

@@ -16,10 +16,12 @@
 
 import static com.google.firebase.firestore.util.Preconditions.checkNotNull;
 
+import android.os.SystemClock;
 import androidx.annotation.AnyThread;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import com.google.firebase.firestore.ListenerRegistration;
+import java.util.ArrayList;
 
 /**
  * Provides access to the {@link WatchChangeAggregatorTestingHooks} class and its methods.
@@ -146,4 +148,81 @@ public void onExistenceFilterMismatch(
       this.wrappedListener.onExistenceFilterMismatch(new ExistenceFilterMismatchInfoImpl(info));
     }
   }
+
+  public static final class ExistenceFilterMismatchAccumulator {
+
+    private ExistenceFilterMismatchListenerImpl listener;
+    private ListenerRegistration listenerRegistration = null;
+
+    /** Registers the accumulator to begin listening for existence filter mismatches. */
+    public synchronized void register() {
+      if (listener != null) {
+        throw new IllegalStateException("already registered");
+      }
+      listener = new ExistenceFilterMismatchListenerImpl();
+      listenerRegistration =
+          WatchChangeAggregatorTestingHooksAccessor.addExistenceFilterMismatchListener(listener);
+    }
+
+    /** Unregisters the accumulator from listening for existence filter mismatches. */
+    public synchronized void unregister() {
+      if (listener == null) {
+        return;
+      }
+      listenerRegistration.remove();
+      listenerRegistration = null;
+      listener = null;
+    }
+
+    @Nullable
+    public WatchChangeAggregatorTestingHooksAccessor.ExistenceFilterMismatchInfo
+        waitForExistenceFilterMismatch(long timeoutMillis) throws InterruptedException {
+      ExistenceFilterMismatchListenerImpl capturedListener;
+      synchronized (this) {
+        capturedListener = listener;
+      }
+      if (capturedListener == null) {
+        throw new IllegalStateException(
+            "must be registered before waiting for an existence filter mismatch");
+      }
+      return capturedListener.waitForExistenceFilterMismatch(timeoutMillis);
+    }
+
+    private static final class ExistenceFilterMismatchListenerImpl
+        implements WatchChangeAggregatorTestingHooksAccessor.ExistenceFilterMismatchListener {
+
+      private final ArrayList<ExistenceFilterMismatchInfo> existenceFilterMismatches =
+          new ArrayList<>();
+
+      @Override
+      public void onExistenceFilterMismatch(
+          WatchChangeAggregatorTestingHooksAccessor.ExistenceFilterMismatchInfo info) {
+        synchronized (existenceFilterMismatches) {
+          existenceFilterMismatches.add(info);
+          existenceFilterMismatches.notifyAll();
+        }
+      }
+
+      @Nullable
+      WatchChangeAggregatorTestingHooksAccessor.ExistenceFilterMismatchInfo
+          waitForExistenceFilterMismatch(long timeoutMillis) throws InterruptedException {
+        if (timeoutMillis <= 0) {
+          throw new IllegalArgumentException("invalid timeout: " + timeoutMillis);
+        }
+        synchronized (existenceFilterMismatches) {
+          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;
+            }
+            existenceFilterMismatches.wait(currentWaitMillis);
+          }
+        }
+      }
+    }
+  }
 }