Eliminate Objective-C BOOL in Firestore/core (#2574)

* Add objc::EqualTo and objc::Hash

These make it possible to use std::unordered_map with Objective-C object
keys.

* Use std::unordered_map in MemoryQueryCache

* Fix objective-C library detection

This ensures that .mm files are compiled with -fobjc-arc (among other
things).

* Remove BOOL in FSTDocument to eliminate static_cast<bool>

Author: wilhuff

Firestore/Example/Tests/Local/FSTLRUGarbageCollectorTests.mm

@@ -398,7 +398,7 @@ - (void)testRemoveQueriesUpThroughSequenceNumber {
   XCTAssertEqual(10, removed);
   // Make sure we removed the even targets with targetID <= 20.
   _persistence.run("verify remaining targets are > 20 or odd", [&]() {
-    _queryCache->EnumerateTargets(^(FSTQueryData *queryData, BOOL *stop) {
+    _queryCache->EnumerateTargets([&](FSTQueryData *queryData) {
       XCTAssertTrue(queryData.targetID > 20 || queryData.targetID % 2 == 1);
     });
   });

Firestore/Source/Core/FSTFirestoreClient.mm

@@ -336,10 +336,9 @@ - (void)getDocumentFromLocalCache:(const DocumentReference &)doc
 
     if ([maybeDoc isKindOfClass:[FSTDocument class]]) {
       FSTDocument *document = (FSTDocument *)maybeDoc;
-      maybe_snapshot =
-          DocumentSnapshot{doc.firestore(), doc.key(), document,
-                           /*from_cache=*/true,
-                           /*has_pending_writes=*/static_cast<bool>(document.hasLocalMutations)};
+      maybe_snapshot = DocumentSnapshot{doc.firestore(), doc.key(), document,
+                                        /*from_cache=*/true,
+                                        /*has_pending_writes=*/document.hasLocalMutations};
     } else if ([maybeDoc isKindOfClass:[FSTDeletedDocument class]]) {
       maybe_snapshot = DocumentSnapshot{doc.firestore(), doc.key(), nil,
                                         /*from_cache=*/true,

Firestore/Source/Local/FSTLRUGarbageCollector.h

@@ -21,6 +21,8 @@
 
 #import "FIRFirestoreSettings.h"
 #import "Firestore/Source/Local/FSTQueryData.h"
+
+#include "Firestore/core/src/firebase/firestore/local/query_cache.h"
 #include "Firestore/core/src/firebase/firestore/model/document_key.h"
 #include "Firestore/core/src/firebase/firestore/model/types.h"
 
@@ -79,15 +81,13 @@ struct LruResults {
  * Enumerates all the targets that the delegate is aware of. This is typically all of the targets in
  * an FSTQueryCache.
  */
-- (void)enumerateTargetsUsingBlock:(void (^)(FSTQueryData *queryData, BOOL *stop))block;
+- (void)enumerateTargetsUsingCallback:(const firebase::firestore::local::TargetCallback &)callback;
 
 /**
  * Enumerates all of the outstanding mutations.
  */
-- (void)enumerateMutationsUsingBlock:
-    (void (^)(const firebase::firestore::model::DocumentKey &key,
-              firebase::firestore::model::ListenSequenceNumber sequenceNumber,
-              BOOL *stop))block;
+- (void)enumerateMutationsUsingCallback:
+    (const firebase::firestore::local::OrphanedDocumentCallback &)callback;
 
 /**
  * Removes all unreferenced documents from the cache that have a sequence number less than or equal

Firestore/Source/Local/FSTLRUGarbageCollector.mm

@@ -159,14 +159,13 @@ - (ListenSequenceNumber)sequenceNumberForQueryCount:(NSUInteger)queryCount {
     return kFSTListenSequenceNumberInvalid;
   }
   RollingSequenceNumberBuffer buffer(queryCount);
-  // Pointer is necessary to access stack-allocated buffer from a block.
-  RollingSequenceNumberBuffer *ptr_to_buffer = &buffer;
-  [_delegate enumerateTargetsUsingBlock:^(FSTQueryData *queryData, BOOL *stop) {
-    ptr_to_buffer->AddElement(queryData.sequenceNumber);
+
+  [_delegate enumerateTargetsUsingCallback:[&buffer](FSTQueryData *queryData) {
+    buffer.AddElement(queryData.sequenceNumber);
   }];
-  [_delegate enumerateMutationsUsingBlock:^(const DocumentKey &docKey,
-                                            ListenSequenceNumber sequenceNumber, BOOL *stop) {
-    ptr_to_buffer->AddElement(sequenceNumber);
+  [_delegate enumerateMutationsUsingCallback:[&buffer](const DocumentKey &docKey,
+                                                       ListenSequenceNumber sequenceNumber) {
+    buffer.AddElement(sequenceNumber);
   }];
   return buffer.max_value();
 }

Firestore/Source/Local/FSTLevelDB.mm

@@ -73,8 +73,10 @@
 using firebase::firestore::local::LevelDbTransaction;
 using firebase::firestore::local::ListenSequence;
 using firebase::firestore::local::LruParams;
+using firebase::firestore::local::OrphanedDocumentCallback;
 using firebase::firestore::local::ReferenceSet;
 using firebase::firestore::local::RemoteDocumentCache;
+using firebase::firestore::local::TargetCallback;
 using firebase::firestore::model::DatabaseId;
 using firebase::firestore::model::DocumentKey;
 using firebase::firestore::model::ListenSequenceNumber;
@@ -210,19 +212,18 @@ - (BOOL)isPinned:(const DocumentKey &)docKey {
   return NO;
 }
 
-- (void)enumerateTargetsUsingBlock:(void (^)(FSTQueryData *queryData, BOOL *stop))block {
-  _db.queryCache->EnumerateTargets(block);
+- (void)enumerateTargetsUsingCallback:(const TargetCallback &)callback {
+  _db.queryCache->EnumerateTargets(callback);
 }
 
-- (void)enumerateMutationsUsingBlock:
-    (void (^)(const DocumentKey &key, ListenSequenceNumber sequenceNumber, BOOL *stop))block {
-  _db.queryCache->EnumerateOrphanedDocuments(block);
+- (void)enumerateMutationsUsingCallback:(const OrphanedDocumentCallback &)callback {
+  _db.queryCache->EnumerateOrphanedDocuments(callback);
 }
 
 - (int)removeOrphanedDocumentsThroughSequenceNumber:(ListenSequenceNumber)upperBound {
-  __block int count = 0;
+  int count = 0;
   _db.queryCache->EnumerateOrphanedDocuments(
-      ^(const DocumentKey &docKey, ListenSequenceNumber sequenceNumber, BOOL *stop) {
+      [&count, self, upperBound](const DocumentKey &docKey, ListenSequenceNumber sequenceNumber) {
         if (sequenceNumber <= upperBound) {
           if (![self isPinned:docKey]) {
             count++;
@@ -245,9 +246,9 @@ - (int)removeTargetsThroughSequenceNumber:(ListenSequenceNumber)sequenceNumber
 }
 
 - (size_t)sequenceNumberCount {
-  __block size_t totalCount = _db.queryCache->size();
-  [self enumerateMutationsUsingBlock:^(const DocumentKey &key, ListenSequenceNumber sequenceNumber,
-                                       BOOL *stop) {
+  size_t totalCount = _db.queryCache->size();
+  [self enumerateMutationsUsingCallback:[&totalCount](const DocumentKey &key,
+                                                      ListenSequenceNumber sequenceNumber) {
     totalCount++;
   }];
   return totalCount;

Firestore/Source/Local/FSTMemoryPersistence.mm

@@ -42,6 +42,7 @@
 using firebase::firestore::local::MemoryQueryCache;
 using firebase::firestore::local::MemoryRemoteDocumentCache;
 using firebase::firestore::local::ReferenceSet;
+using firebase::firestore::local::TargetCallback;
 using firebase::firestore::model::DocumentKey;
 using firebase::firestore::model::DocumentKeyHash;
 using firebase::firestore::model::ListenSequenceNumber;
@@ -234,20 +235,19 @@ - (void)commitTransaction {
   _currentSequenceNumber = kFSTListenSequenceNumberInvalid;
 }
 
-- (void)enumerateTargetsUsingBlock:(void (^)(FSTQueryData *queryData, BOOL *stop))block {
-  return _persistence.queryCache->EnumerateTargets(block);
+- (void)enumerateTargetsUsingCallback:(const TargetCallback &)callback {
+  return _persistence.queryCache->EnumerateTargets(callback);
 }
 
-- (void)enumerateMutationsUsingBlock:
-    (void (^)(const DocumentKey &key, ListenSequenceNumber sequenceNumber, BOOL *stop))block {
-  BOOL stop = NO;
+- (void)enumerateMutationsUsingCallback:
+    (const firebase::firestore::local::OrphanedDocumentCallback &)callback {
   for (const auto &entry : _sequenceNumbers) {
     ListenSequenceNumber sequenceNumber = entry.second;
     const DocumentKey &key = entry.first;
     // Pass in the exact sequence number as the upper bound so we know it won't be pinned by being
     // too recent.
     if (![self isPinnedAtSequenceNumber:sequenceNumber document:key]) {
-      block(key, sequenceNumber, &stop);
+      callback(key, sequenceNumber);
     }
   }
 }
@@ -259,9 +259,9 @@ - (int)removeTargetsThroughSequenceNumber:(ListenSequenceNumber)sequenceNumber
 }
 
 - (size_t)sequenceNumberCount {
-  __block size_t totalCount = _persistence.queryCache->size();
-  [self enumerateMutationsUsingBlock:^(const DocumentKey &key, ListenSequenceNumber sequenceNumber,
-                                       BOOL *stop) {
+  size_t totalCount = _persistence.queryCache->size();
+  [self enumerateMutationsUsingCallback:[&totalCount](const DocumentKey &key,
+                                                      ListenSequenceNumber sequenceNumber) {
     totalCount++;
   }];
   return totalCount;

Firestore/Source/Model/FSTDocument.h

@@ -48,7 +48,7 @@ typedef NS_ENUM(NSInteger, FSTDocumentState) {
 /**
  * Whether this document has a local mutation applied that has not yet been acknowledged by Watch.
  */
-- (BOOL)hasPendingWrites;
+- (bool)hasPendingWrites;
 
 @end
 
@@ -65,8 +65,8 @@ typedef NS_ENUM(NSInteger, FSTDocumentState) {
                            proto:(GCFSDocument *)proto;
 
 - (nullable FSTFieldValue *)fieldForPath:(const firebase::firestore::model::FieldPath &)path;
-- (BOOL)hasLocalMutations;
-- (BOOL)hasCommittedMutations;
+- (bool)hasLocalMutations;
+- (bool)hasCommittedMutations;
 
 @property(nonatomic, strong, readonly) FSTObjectValue *data;
 
@@ -81,9 +81,9 @@ typedef NS_ENUM(NSInteger, FSTDocumentState) {
 @interface FSTDeletedDocument : FSTMaybeDocument
 + (instancetype)documentWithKey:(firebase::firestore::model::DocumentKey)key
                         version:(firebase::firestore::model::SnapshotVersion)version
-          hasCommittedMutations:(BOOL)committedMutations;
+          hasCommittedMutations:(bool)committedMutations;
 
-- (BOOL)hasCommittedMutations;
+- (bool)hasCommittedMutations;
 
 @end
 

Firestore/Source/Model/FSTDocument.mm

@@ -55,7 +55,7 @@ - (instancetype)initWithKey:(DocumentKey)key version:(SnapshotVersion)version {
   return self;
 }
 
-- (BOOL)hasPendingWrites {
+- (bool)hasPendingWrites {
   @throw FSTAbstractMethodException();  // NOLINT
 }
 
@@ -127,15 +127,15 @@ - (instancetype)initWithData:(FSTObjectValue *)data
   return self;
 }
 
-- (BOOL)hasLocalMutations {
+- (bool)hasLocalMutations {
   return _documentState == FSTDocumentStateLocalMutations;
 }
 
-- (BOOL)hasCommittedMutations {
+- (bool)hasCommittedMutations {
   return _documentState == FSTDocumentStateCommittedMutations;
 }
 
-- (BOOL)hasPendingWrites {
+- (bool)hasPendingWrites {
   return self.hasLocalMutations || self.hasCommittedMutations;
 }
 
@@ -174,12 +174,12 @@ - (nullable FSTFieldValue *)fieldForPath:(const FieldPath &)path {
 @end
 
 @implementation FSTDeletedDocument {
-  BOOL _hasCommittedMutations;
+  bool _hasCommittedMutations;
 }
 
 + (instancetype)documentWithKey:(DocumentKey)key
                         version:(SnapshotVersion)version
-          hasCommittedMutations:(BOOL)committedMutations {
+          hasCommittedMutations:(bool)committedMutations {
   FSTDeletedDocument *deletedDocument = [[FSTDeletedDocument alloc] initWithKey:std::move(key)
                                                                         version:std::move(version)];
 
@@ -190,11 +190,11 @@ + (instancetype)documentWithKey:(DocumentKey)key
   return deletedDocument;
 }
 
-- (BOOL)hasCommittedMutations {
+- (bool)hasCommittedMutations {
   return _hasCommittedMutations;
 }
 
-- (BOOL)hasPendingWrites {
+- (bool)hasPendingWrites {
   return self.hasCommittedMutations;
 }
 
@@ -233,8 +233,8 @@ + (instancetype)documentWithKey:(DocumentKey)key version:(SnapshotVersion)versio
   return [[FSTUnknownDocument alloc] initWithKey:std::move(key) version:std::move(version)];
 }
 
-- (BOOL)hasPendingWrites {
-  return YES;
+- (bool)hasPendingWrites {
+  return true;
 }
 
 - (BOOL)isEqual:(id)other {

Firestore/core/src/firebase/firestore/local/CMakeLists.txt

@@ -16,11 +16,18 @@ if(HAVE_LEVELDB)
   cc_library(
     firebase_firestore_local_persistence_leveldb
     SOURCES
+      leveldb_index_manager.h
+      #leveldb_index_manager.mm
       leveldb_key.cc
       leveldb_key.h
-      #leveldb_index_manager.mm
       leveldb_migrations.cc
       leveldb_migrations.h
+      leveldb_mutation_queue.h
+      #leveldb_mutation_queue.mm
+      leveldb_query_cache.h
+      #leveldb_query_cache.mm
+      leveldb_remote_document_cache.h
+      #leveldb_remote_document_cache.mm
       leveldb_transaction.cc
       leveldb_transaction.h
       leveldb_util.cc
@@ -49,13 +56,25 @@ cc_library(
   SOURCES
     document_reference.h
     document_reference.cc
+    index_manager.h
+    listen_sequence.h
     local_serializer.h
     local_serializer.cc
     memory_index_manager.cc
+    memory_index_manager.h
+    memory_mutation_queue.h
+    #memory_mutation_queue.mm
+    memory_query_cache.h
+    #memory_query_cache.mm
+    memory_remote_document_cache.h
+    #memory_remote_document_cache.mm
+    mutation_queue.h
+    query_cache.h
     query_data.cc
     query_data.h
     reference_set.cc
     reference_set.h
+    remote_document_cache.h
   DEPENDS
     # TODO(b/111328563) Force nanopb first to work around ODR violations
     protobuf-nanopb

Firestore/core/src/firebase/firestore/local/leveldb_query_cache.h

@@ -47,11 +47,6 @@ namespace local {
 /** Cached Queries backed by LevelDB. */
 class LevelDbQueryCache : public QueryCache {
  public:
-  /** Enumerator callback type for orphaned documents */
-  typedef void (^OrphanedDocumentEnumerator)(const model::DocumentKey&,
-                                             model::ListenSequenceNumber,
-                                             BOOL*);
-
   /**
    * Retrieves the global singleton metadata row from the given database, if it
    * exists.
@@ -75,7 +70,7 @@ class LevelDbQueryCache : public QueryCache {
 
   FSTQueryData* _Nullable GetTarget(FSTQuery* query) override;
 
-  void EnumerateTargets(TargetEnumerator block) override;
+  void EnumerateTargets(const TargetCallback& callback) override;
 
   int RemoveTargets(model::ListenSequenceNumber upper_bound,
                     const std::unordered_map<model::TargetId, FSTQueryData*>&
@@ -123,7 +118,7 @@ class LevelDbQueryCache : public QueryCache {
   // Non-interface methods
   void Start();
 
-  void EnumerateOrphanedDocuments(OrphanedDocumentEnumerator block);
+  void EnumerateOrphanedDocuments(const OrphanedDocumentCallback& callback);
 
  private:
   void Save(FSTQueryData* query_data);