Port FSTListenerRegistration to C++ (#2619)

* Replace FSTQueryListener with C++ QueryListener

* objc::unordered_map

* Add a lint check for Objective-C banned words

Author: wilhuff

Firestore/Source/API/FIRDocumentReference.mm

@@ -212,8 +212,9 @@ - (void)getDocumentWithSource:(FIRFirestoreSource)source
 - (id<FIRListenerRegistration>)addSnapshotListenerInternalWithOptions:(ListenOptions)internalOptions
                                                              listener:(FIRDocumentSnapshotBlock)
                                                                           listener {
-  return _documentReference.AddSnapshotListener([self wrapDocumentSnapshotBlock:listener],
-                                                std::move(internalOptions));
+  ListenerRegistration result = _documentReference.AddSnapshotListener(
+      [self wrapDocumentSnapshotBlock:listener], std::move(internalOptions));
+  return [[FSTListenerRegistration alloc] initWithRegistration:std::move(result)];
 }
 
 - (StatusOrCallback<DocumentSnapshot>)wrapDocumentSnapshotBlock:(FIRDocumentSnapshotBlock)block {

Firestore/Source/API/FIRListenerRegistration+Internal.h

@@ -16,23 +16,16 @@
 
 #import "FIRListenerRegistration.h"
 
-#include <memory>
-
-#include "Firestore/core/src/firebase/firestore/core/query_listener.h"
-
-@class FSTAsyncQueryListener;
-@class FSTFirestoreClient;
+#include "Firestore/core/src/firebase/firestore/api/listener_registration.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
-using firebase::firestore::core::QueryListener;
+using firebase::firestore::api::ListenerRegistration;
 
 /** Private implementation of the FIRListenerRegistration protocol. */
 @interface FSTListenerRegistration : NSObject <FIRListenerRegistration>
 
-- (instancetype)initWithClient:(FSTFirestoreClient *)client
-                 asyncListener:(FSTAsyncQueryListener *)asyncListener
-              internalListener:(std::shared_ptr<QueryListener>)internalListener;
+- (instancetype)initWithRegistration:(ListenerRegistration &&)registration;
 
 @end
 

Firestore/Source/API/FIRListenerRegistration.mm

@@ -18,43 +18,25 @@
 
 #import "Firestore/Source/API/FIRListenerRegistration+Internal.h"
 
-#import "Firestore/Source/Core/FSTFirestoreClient.h"
-#import "Firestore/Source/Util/FSTAsyncQueryListener.h"
+#include "Firestore/core/src/firebase/firestore/util/delayed_constructor.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
-@implementation FSTListenerRegistration {
-  /** The client that was used to register this listen. */
-  FSTFirestoreClient *_client;
-
-  /** The async listener that is used to mute events synchronously. */
-  FSTAsyncQueryListener *_asyncListener;
+using firebase::firestore::util::DelayedConstructor;
 
-  /** The internal QueryListener that can be used to unlisten the query. */
-  std::weak_ptr<QueryListener> _internalListener;
+@implementation FSTListenerRegistration {
+  DelayedConstructor<ListenerRegistration> _registration;
 }
 
-- (instancetype)initWithClient:(FSTFirestoreClient *)client
-                 asyncListener:(FSTAsyncQueryListener *)asyncListener
-              internalListener:(std::shared_ptr<QueryListener>)internalListener {
+- (instancetype)initWithRegistration:(ListenerRegistration &&)registration {
   if (self = [super init]) {
-    _client = client;
-    _asyncListener = asyncListener;
-    _internalListener = internalListener;
+    _registration.Init(std::move(registration));
   }
   return self;
 }
 
 - (void)remove {
-  [_asyncListener mute];
-
-  std::shared_ptr<QueryListener> listener = _internalListener.lock();
-  if (listener) {
-    [_client removeListener:listener];
-    listener.reset();
-    _internalListener.reset();
-  }
-  _asyncListener = nil;
+  _registration->Remove();
 }
 
 @end

Firestore/Source/API/FIRQuery.mm

@@ -199,9 +199,10 @@ ListenOptions listenOptions(
       [firestore->client() listenToQuery:query
                                  options:internalOptions
                      viewSnapshotHandler:[asyncListener asyncSnapshotHandler]];
-  return [[FSTListenerRegistration alloc] initWithClient:self.firestore.client
-                                           asyncListener:asyncListener
-                                        internalListener:internalListener];
+
+  return [[FSTListenerRegistration alloc]
+      initWithRegistration:ListenerRegistration(firestore->client(), asyncListener,
+                                                std::move(internalListener))];
 }
 
 - (FIRQuery *)queryWhereField:(NSString *)field isEqualTo:(id)value {

Firestore/core/src/firebase/firestore/api/document_reference.h

@@ -29,9 +29,9 @@
 
 #import "FIRDocumentReference.h"
 #import "FIRFirestoreSource.h"
-#import "FIRListenerRegistration.h"
 
 #include "Firestore/core/src/firebase/firestore/api/document_snapshot.h"
+#include "Firestore/core/src/firebase/firestore/api/listener_registration.h"
 #include "Firestore/core/src/firebase/firestore/core/listen_options.h"
 #include "Firestore/core/src/firebase/firestore/model/document_key.h"
 #include "Firestore/core/src/firebase/firestore/model/resource_path.h"
@@ -89,7 +89,7 @@ class DocumentReference {
   void GetDocument(FIRFirestoreSource source,
                    util::StatusOrCallback<DocumentSnapshot>&& completion);
 
-  id<FIRListenerRegistration> AddSnapshotListener(
+  ListenerRegistration AddSnapshotListener(
       util::StatusOrCallback<DocumentSnapshot>&& listener,
       core::ListenOptions options);
 

Firestore/core/src/firebase/firestore/api/document_reference.mm

@@ -127,12 +127,16 @@ ListenOptions options(
       /*include_document_metadata_changes=*/true,
       /*wait_for_sync_when_online=*/true);
 
+  // Create an empty ListenerRegistration captured in the closure below and
+  // then, once the listen has started, assign to it and signal the listener
+  // that we succeeded.
+  //
   // TODO(varconst): replace with a synchronization primitive that doesn't
   // require libdispatch. See
   // https://github.com/firebase/firebase-ios-sdk/blob/3ccbdcdc65c93c4621c045c3c6d15de9dcefa23f/Firestore/Source/Core/FSTFirestoreClient.mm#L161
   // for an example.
   dispatch_semaphore_t registered = dispatch_semaphore_create(0);
-  auto listener_registration = std::make_shared<id<FIRListenerRegistration>>();
+  auto listener_registration = std::make_shared<ListenerRegistration>();
   StatusOrCallback<DocumentSnapshot> listener =
       [listener_registration, registered, completion,
        source](StatusOr<DocumentSnapshot> maybe_snapshot) {
@@ -146,7 +150,7 @@ ListenOptions options(
         // Remove query first before passing event to user to avoid user actions
         // affecting the now stale query.
         dispatch_semaphore_wait(registered, DISPATCH_TIME_FOREVER);
-        [*listener_registration remove];
+        listener_registration->Remove();
 
         if (!snapshot.exists() && snapshot.metadata().from_cache()) {
           // TODO(dimond): Reconsider how to raise missing documents when
@@ -178,7 +182,7 @@ ListenOptions options(
   dispatch_semaphore_signal(registered);
 }
 
-id<FIRListenerRegistration> DocumentReference::AddSnapshotListener(
+ListenerRegistration DocumentReference::AddSnapshotListener(
     StatusOrCallback<DocumentSnapshot>&& listener, ListenOptions options) {
   Firestore* firestore = firestore_;
   FSTQuery* query = [FSTQuery queryWithPath:key_.path()];
@@ -215,9 +219,8 @@ ListenOptions options(
             listenToQuery:query
                   options:options
       viewSnapshotHandler:[async_listener asyncSnapshotHandler]];
-  return [[FSTListenerRegistration alloc] initWithClient:firestore_->client()
-                                           asyncListener:async_listener
-                                        internalListener:internal_listener];
+  return ListenerRegistration(firestore_->client(), async_listener,
+                              internal_listener);
 }
 
 bool operator==(const DocumentReference& lhs, const DocumentReference& rhs) {

Firestore/core/src/firebase/firestore/api/listener_registration.h

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2019 Google
+ *
+ * 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.
+ */
+
+#ifndef FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_API_LISTENER_REGISTRATION_H_
+#define FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_API_LISTENER_REGISTRATION_H_
+
+#if !defined(__OBJC__)
+#error "This header only supports Objective-C++"
+#endif  // !defined(__OBJC__)
+
+#import <Foundation/Foundation.h>
+
+#include <memory>
+#include <utility>
+
+#include "Firestore/core/src/firebase/firestore/core/query_listener.h"
+
+@class FSTAsyncQueryListener;
+@class FSTFirestoreClient;
+
+NS_ASSUME_NONNULL_BEGIN
+
+namespace firebase {
+namespace firestore {
+namespace api {
+
+/**
+ * An internal handle that encapsulates a user's ability to request that we
+ * stop listening to a query. When a user calls Remove(), ListenerRegistration
+ * will synchronously mute the listener and then send a request to the
+ * FirestoreClient to actually unlisten.
+ *
+ * ListenerRegistration will not automaticlaly stop listening if it is
+ * destroyed. We allow users to fire and forget listens if they never want to
+ * stop them.
+ *
+ * Getting shutdown code right is tricky so ListenerRegistration is very
+ * forgiving. It will tolerate:
+ *
+ *   * Multiple calls to Remove(),
+ *   * calls to Remove() after we send an error,
+ *   * calls to Remove() even after deleting the App in which the listener was
+ *     started.
+ *
+ * ListenerRegistration is default constructible to facilitate the pattern in
+ * DocumentReference::GetDocument, where the closure that implements a listener
+ * needs to be able to use the ListenerRegistration thats returned from
+ * starting the listener. The default ListenerRegistration acts as a shared
+ * placeholder that's filled in later once the listener is started.
+ */
+class ListenerRegistration {
+ public:
+  ListenerRegistration() = default;
+
+  ListenerRegistration(FSTFirestoreClient* client,
+                       FSTAsyncQueryListener* async_listener,
+                       std::shared_ptr<core::QueryListener> internal_listener)
+      : client_(client),
+        async_listener_(async_listener),
+        internal_listener_(std::move(internal_listener)) {
+  }
+
+  /**
+   * Removes the listener being tracked by this FIRListenerRegistration. After
+   * the initial call, subsequent calls have no effect.
+   */
+  void Remove();
+
+ private:
+  /** The client that was used to register this listen. */
+  FSTFirestoreClient* client_ = nil;
+
+  /** The async listener that is used to mute events synchronously. */
+  FSTAsyncQueryListener* async_listener_ = nil;
+
+  /** The internal QueryListener that can be used to unlisten the query. */
+  std::weak_ptr<core::QueryListener> internal_listener_;
+};
+
+}  // namespace api
+}  // namespace firestore
+}  // namespace firebase
+
+NS_ASSUME_NONNULL_END
+
+#endif  // FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_API_LISTENER_REGISTRATION_H_

Firestore/core/src/firebase/firestore/api/listener_registration.mm

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2019 Google
+ *
+ * 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.
+ */
+
+#include "Firestore/core/src/firebase/firestore/api/listener_registration.h"
+
+#import "Firestore/Source/Core/FSTFirestoreClient.h"
+#import "Firestore/Source/Util/FSTAsyncQueryListener.h"
+
+namespace firebase {
+namespace firestore {
+namespace api {
+
+void ListenerRegistration::Remove() {
+  [async_listener_ mute];
+  async_listener_ = nil;
+
+  std::shared_ptr<QueryListener> listener = internal_listener_.lock();
+  if (listener) {
+    [client_ removeListener:listener];
+    listener.reset();
+    internal_listener_.reset();
+    client_ = nil;
+  }
+}
+
+}  // namespace api
+}  // namespace firestore
+}  // namespace firebase