Reduce diff

Author: schmidt-sebastian

packages/firestore/exp/src/api/database.ts

@@ -32,8 +32,7 @@ import {
   MemoryOfflineComponentProvider,
   OfflineComponentProvider,
   IndexedDbOfflineComponentProvider,
-  MultiTabOfflineComponentProvider,
-  MultiTabOnlineComponentProvider
+  MultiTabOfflineComponentProvider
 } from '../../../src/core/component_provider';
 
 import {
@@ -250,9 +249,13 @@ export function enableMultiTabIndexedDbPersistence(
   firestore: firestore.FirebaseFirestore
 ): Promise<void> {
   const firestoreImpl = cast(firestore, Firestore);
+  const onlineComponentProvider = new OnlineComponentProvider();
+  const offlineComponentProvider = new MultiTabOfflineComponentProvider(
+    onlineComponentProvider
+  );
   return firestoreImpl._enablePersistence(
-    new MultiTabOfflineComponentProvider(),
-    new MultiTabOnlineComponentProvider(),
+    offlineComponentProvider,
+    onlineComponentProvider,
     /*synchronizeTabs=*/ false
   );
 }

packages/firestore/index.node.ts

@@ -19,7 +19,7 @@ import { FirebaseNamespace } from '@firebase/app-types';
 
 import { Firestore } from './src/api/database';
 import {
-  MultiTabOfflineComponentProvider, MultiTabOnlineComponentProvider
+  MultiTabOfflineComponentProvider,OnlineComponentProvider
 } from './src/core/component_provider';
 import { configureForFirebase } from './src/config';
 
@@ -32,14 +32,18 @@ import { name, version } from './package.json';
  * Persistence can be enabled via `firebase.firestore().enablePersistence()`.
  */
 export function registerFirestore(instance: FirebaseNamespace): void {
+  const onlineComponentProvider =
+    new OnlineComponentProvider();
+  const offlineComponentProvider =
+    new MultiTabOfflineComponentProvider(onlineComponentProvider);
   configureForFirebase(
     instance,
     (app, auth) =>
       new Firestore(
         app,
         auth,
-        new MultiTabOfflineComponentProvider(),
-        new MultiTabOnlineComponentProvider()
+        offlineComponentProvider,
+        onlineComponentProvider
       )
   );
   instance.registerVersion(name, version, 'node');

packages/firestore/index.rn.ts

@@ -20,7 +20,7 @@ import { FirebaseNamespace } from '@firebase/app-types';
 import { Firestore } from './src/api/database';
 import {
   MultiTabOfflineComponentProvider,
-  MultiTabOnlineComponentProvider
+  OnlineComponentProvider
 } from './src/core/component_provider';
 import { configureForFirebase } from './src/config';
 
@@ -32,14 +32,19 @@ import { name, version } from './package.json';
  * Persistence can be enabled via `firebase.firestore().enablePersistence()`.
  */
 export function registerFirestore(instance: FirebaseNamespace): void {
+
+  const onlineComponentProvider =
+    new OnlineComponentProvider();
+  const offlineComponentProvider =
+    new MultiTabOfflineComponentProvider(onlineComponentProvider);
   configureForFirebase(
     instance,
     (app, auth) =>
       new Firestore(
         app,
         auth,
-        new MultiTabOfflineComponentProvider(),
-        new MultiTabOnlineComponentProvider()
+        offlineComponentProvider,
+        onlineComponentProvider
       )
   );
   instance.registerVersion(name, version, 'rn');

packages/firestore/index.ts

@@ -20,7 +20,7 @@ import { FirebaseNamespace } from '@firebase/app-types';
 
 import { Firestore } from './src/api/database';
 import {
-  MultiTabOfflineComponentProvider, MultiTabOnlineComponentProvider
+  MultiTabOfflineComponentProvider, OnlineComponentProvider
 } from './src/core/component_provider';
 import { configureForFirebase } from './src/config';
 import { name, version } from './package.json';
@@ -32,14 +32,18 @@ import './register-module';
  * Persistence can be enabled via `firebase.firestore().enablePersistence()`.
  */
 export function registerFirestore(instance: FirebaseNamespace): void {
+  const onlineComponentProvider =
+    new OnlineComponentProvider();
+  const offlineComponentProvider =
+    new MultiTabOfflineComponentProvider(onlineComponentProvider);
   configureForFirebase(
     instance,
     (app, auth) =>
       new Firestore(
         app,
         auth,
-        new MultiTabOfflineComponentProvider(),
-        new MultiTabOnlineComponentProvider()
+        offlineComponentProvider,
+      onlineComponentProvider
       )
   );
   instance.registerVersion(name, version);

packages/firestore/src/core/component_provider.ts

@@ -62,6 +62,7 @@ import { newSerializer } from '../platform/serializer';
 import { getDocument, getWindow } from '../platform/dom';
 import { CredentialsProvider } from '../api/credentials';
 import { Connection } from '../remote/connection';
+import { SharedClientStateSyncer } from '../local/shared_client_state_syncer';
 
 const MEMORY_ONLY_PERSISTENCE_ERROR_MESSAGE =
   'You are using the memory-only build of Firestore. Persistence support is ' +
@@ -229,6 +230,49 @@ export class IndexedDbOfflineComponentProvider extends MemoryOfflineComponentPro
  * `synchronizeTabs` will be enabled.
  */
 export class MultiTabOfflineComponentProvider extends IndexedDbOfflineComponentProvider {
+  constructor(
+    private readonly onlineComponentProvider: OnlineComponentProvider
+  ) {
+    super();
+  }
+
+  async initialize(cfg: ComponentConfiguration): Promise<void> {
+    await super.initialize(cfg);
+
+    await this.onlineComponentProvider.initialize(this, cfg);
+    const syncEngine = this.onlineComponentProvider.syncEngine;
+
+    if (this.sharedClientState instanceof WebStorageSharedClientState) {
+      this.sharedClientState.syncEngine = {
+        applyBatchState: applyBatchState.bind(null, syncEngine),
+        applyTargetState: applyTargetState.bind(null, syncEngine),
+        applyActiveTargetsChange: applyActiveTargetsChange.bind(
+          null,
+          syncEngine
+        ),
+        getActiveClients: getActiveClients.bind(null, syncEngine)
+      };
+
+      await this.sharedClientState.start();
+    }
+
+    // NOTE: This will immediately call the listener, so we make sure to
+    // set it after localStore / remoteStore are started.
+    await this.persistence.setPrimaryStateListener(async isPrimary => {
+      await applyPrimaryState(
+        this.onlineComponentProvider.syncEngine,
+        isPrimary
+      );
+      if (this.gcScheduler) {
+        if (isPrimary && !this.gcScheduler.started) {
+          this.gcScheduler.start(this.localStore);
+        } else if (!isPrimary) {
+          this.gcScheduler.stop();
+        }
+      }
+    });
+  }
+
   createSharedClientState(cfg: ComponentConfiguration): SharedClientState {
     if (
       cfg.persistenceSettings.durable &&
@@ -273,6 +317,11 @@ export class OnlineComponentProvider {
     offlineComponentProvider: OfflineComponentProvider,
     cfg: ComponentConfiguration
   ): Promise<void> {
+    if (this.datastore) {
+      // OnlineComponentProvider may get initialized multiple times if MultiTabPersistence is used.
+      return;
+    }
+
     this.localStore = offlineComponentProvider.localStore;
     this.sharedClientState = offlineComponentProvider.sharedClientState;
     this.datastore = this.createDatastore(cfg);
@@ -288,6 +337,7 @@ export class OnlineComponentProvider {
         onlineState,
         OnlineStateSource.SharedClientState
       );
+
     this.remoteStore.syncEngine = this.syncEngine;
 
     await this.remoteStore.start();
@@ -334,60 +384,3 @@ export class OnlineComponentProvider {
     );
   }
 }
-
-/**
- * Initializes and wires the components that are needed to interface with the
- * network and registers callbacks needed for multi-tab persistence.
- */
-export class MultiTabOnlineComponentProvider extends OnlineComponentProvider {
-  async initialize(
-    offlineComponentProvider: OfflineComponentProvider,
-    cfg: ComponentConfiguration
-  ): Promise<void> {
-    await super.initialize(offlineComponentProvider, cfg);
-    if (
-      cfg.persistenceSettings.durable &&
-      cfg.persistenceSettings.synchronizeTabs
-    ) {
-      const sharedClientState = debugCast(
-        offlineComponentProvider.sharedClientState,
-        WebStorageSharedClientState
-      );
-      const persistence = debugCast(
-        offlineComponentProvider.persistence,
-        IndexedDbPersistence
-      );
-      const syncEngine = this.syncEngine;
-
-      sharedClientState.syncEngine = {
-        applyBatchState: applyBatchState.bind(null, syncEngine),
-        applyTargetState: applyTargetState.bind(null, syncEngine),
-        applyActiveTargetsChange: applyActiveTargetsChange.bind(
-          null,
-          syncEngine
-        ),
-        getActiveClients: getActiveClients.bind(null, syncEngine)
-      };
-
-      // TODO(firestorexp): Should we support offline-only Multi-Tab? This would
-      // likely mean that most methods from in the SharedClientState callback can
-      // no longer rely on sync engine,
-      await sharedClientState.start();
-
-      // NOTE: This will immediately call the listener, so we make sure to
-      // set it after localStore / remoteStore are started.
-      await persistence.setPrimaryStateListener(async isPrimary => {
-        await applyPrimaryState(syncEngine, isPrimary);
-        if (offlineComponentProvider.gcScheduler) {
-          if (isPrimary && !offlineComponentProvider.gcScheduler.started) {
-            offlineComponentProvider.gcScheduler.start(
-              offlineComponentProvider.localStore
-            );
-          } else if (!isPrimary) {
-            offlineComponentProvider.gcScheduler.stop();
-          }
-        }
-      });
-    }
-  }
-}

packages/firestore/test/unit/specs/spec_test_components.ts

@@ -19,8 +19,7 @@ import {
   ComponentConfiguration,
   MemoryOfflineComponentProvider,
   OnlineComponentProvider,
-  MultiTabOfflineComponentProvider,
-  MultiTabOnlineComponentProvider
+  MultiTabOfflineComponentProvider
 } from '../../../src/core/component_provider';
 import {
   GarbageCollectionScheduler,
@@ -138,31 +137,15 @@ export class MockOnlineComponentProvider extends OnlineComponentProvider {
   }
 }
 
-export class MockMultiTabOnlineComponentProvider extends MultiTabOnlineComponentProvider {
-  connection!: MockConnection;
-
-  async loadConnection(cfg: ComponentConfiguration): Promise<Connection> {
-    this.connection = new MockConnection(cfg.asyncQueue);
-    return this.connection;
-  }
-
-  createDatastore(cfg: ComponentConfiguration): Datastore {
-    const serializer = new JsonProtoSerializer(
-      cfg.databaseInfo.databaseId,
-      /* useProto3Json= */ true
-    );
-    return newDatastore(cfg.credentials, serializer);
-  }
-}
-
 export class MockMultiTabOfflineComponentProvider extends MultiTabOfflineComponentProvider {
   persistence!: MockIndexedDbPersistence;
 
   constructor(
     private readonly window: WindowLike,
-    private readonly document: FakeDocument
+    private readonly document: FakeDocument,
+    onlineComponentProvider: OnlineComponentProvider
   ) {
-    super();
+    super(onlineComponentProvider);
   }
 
   createGarbageCollectionScheduler(