Add a Sizer abstraction to MemoryPersistence (#3692)

This breaks the link between MemoryPersistence-related classes and
FSTLocalSerializer, making it possible to use these in straight C++.

Author: wilhuff

Firestore/Source/Local/FSTMemoryPersistence.mm

@@ -29,6 +29,7 @@
 #include "Firestore/core/src/firebase/firestore/local/memory_mutation_queue.h"
 #include "Firestore/core/src/firebase/firestore/local/memory_query_cache.h"
 #include "Firestore/core/src/firebase/firestore/local/memory_remote_document_cache.h"
+#include "Firestore/core/src/firebase/firestore/local/proto_sizer.h"
 #include "Firestore/core/src/firebase/firestore/local/reference_set.h"
 #include "Firestore/core/src/firebase/firestore/model/document_key.h"
 #include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
@@ -43,6 +44,7 @@
 using firebase::firestore::local::MemoryMutationQueue;
 using firebase::firestore::local::MemoryQueryCache;
 using firebase::firestore::local::MemoryRemoteDocumentCache;
+using firebase::firestore::local::ProtoSizer;
 using firebase::firestore::local::QueryData;
 using firebase::firestore::local::ReferenceSet;
 using firebase::firestore::local::TargetCallback;
@@ -325,8 +327,9 @@ - (size_t)byteSize {
   // used for testing. The algorithm here (loop through everything, serialize it
   // and count bytes) is inefficient and inexact, but won't run in production.
   size_t count = 0;
-  count += _persistence.queryCache->CalculateByteSize(_serializer);
-  count += _persistence.remoteDocumentCache->CalculateByteSize(_serializer);
+  ProtoSizer sizer(_serializer);
+  count += _persistence.queryCache->CalculateByteSize(sizer);
+  count += _persistence.remoteDocumentCache->CalculateByteSize(sizer);
   const MutationQueues &queues = [_persistence mutationQueues];
   for (const auto &entry : queues) {
     count += entry.second->CalculateByteSize(_serializer);

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

@@ -75,6 +75,7 @@ cc_library(
     reference_set.cc
     reference_set.h
     remote_document_cache.h
+    sizer.h
   DEPENDS
     # TODO(b/111328563) Force nanopb first to work around ODR violations
     protobuf-nanopb-static

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

@@ -43,6 +43,8 @@ namespace firebase {
 namespace firestore {
 namespace local {
 
+class Sizer;
+
 class MemoryQueryCache : public QueryCache {
  public:
   explicit MemoryQueryCache(FSTMemoryPersistence* persistence);
@@ -74,7 +76,7 @@ class MemoryQueryCache : public QueryCache {
   bool Contains(const model::DocumentKey& key) override;
 
   // Other methods and accessors
-  size_t CalculateByteSize(FSTLocalSerializer* serializer);
+  size_t CalculateByteSize(const Sizer& sizer);
 
   size_t size() const override {
     return queries_.size();

Firestore/core/src/firebase/firestore/local/memory_query_cache.mm

@@ -16,14 +16,12 @@
 
 #include "Firestore/core/src/firebase/firestore/local/memory_query_cache.h"
 
-#import <Protobuf/GPBMessage.h>
-
 #include <vector>
 
-#import "Firestore/Protos/objc/firestore/local/Target.pbobjc.h"
 #import "Firestore/Source/Local/FSTMemoryPersistence.h"
 
 #include "Firestore/core/src/firebase/firestore/local/query_data.h"
+#include "Firestore/core/src/firebase/firestore/local/sizer.h"
 #include "Firestore/core/src/firebase/firestore/model/document_key.h"
 
 NS_ASSUME_NONNULL_BEGIN
@@ -124,11 +122,10 @@
   return references_.ContainsKey(key);
 }
 
-size_t MemoryQueryCache::CalculateByteSize(FSTLocalSerializer* serializer) {
+size_t MemoryQueryCache::CalculateByteSize(const Sizer& sizer) {
   size_t count = 0;
   for (const auto& kv : queries_) {
-    const QueryData& query_data = kv.second;
-    count += [[serializer encodedQueryData:query_data] serializedSize];
+    count += sizer.CalculateByteSize(kv.second);
   }
   return count;
 }

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

@@ -39,6 +39,8 @@ namespace firebase {
 namespace firestore {
 namespace local {
 
+class Sizer;
+
 class MemoryRemoteDocumentCache : public RemoteDocumentCache {
  public:
   explicit MemoryRemoteDocumentCache(FSTMemoryPersistence* persistence);
@@ -56,7 +58,7 @@ class MemoryRemoteDocumentCache : public RemoteDocumentCache {
       FSTMemoryLRUReferenceDelegate* reference_delegate,
       model::ListenSequenceNumber upper_bound);
 
-  size_t CalculateByteSize(FSTLocalSerializer* serializer);
+  size_t CalculateByteSize(const Sizer& sizer);
 
  private:
   /** Underlying cache of documents. */

Firestore/core/src/firebase/firestore/local/memory_remote_document_cache.mm

@@ -18,15 +18,14 @@
 
 #include <utility>
 
-#import "Firestore/Protos/objc/firestore/local/MaybeDocument.pbobjc.h"
 #import "Firestore/Source/Local/FSTMemoryPersistence.h"
 
+#include "Firestore/core/src/firebase/firestore/local/sizer.h"
 #include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
 
 namespace firebase {
 namespace firestore {
 namespace local {
-namespace {
 
 using core::Query;
 using model::Document;
@@ -38,20 +37,6 @@
 using model::MaybeDocumentMap;
 using model::OptionalMaybeDocumentMap;
 
-/**
- * Returns an estimate of the number of bytes used to store the given
- * document key in memory. This is only an estimate and includes the size
- * of the segments of the path, but not any object overhead or path separators.
- */
-size_t DocumentKeyByteSize(const DocumentKey& key) {
-  size_t count = 0;
-  for (const auto& segment : key.path()) {
-    count += segment.size();
-  }
-  return count;
-}
-}  // namespace
-
 MemoryRemoteDocumentCache::MemoryRemoteDocumentCache(
     FSTMemoryPersistence* persistence) {
   persistence_ = persistence;
@@ -130,12 +115,10 @@ size_t DocumentKeyByteSize(const DocumentKey& key) {
   return removed;
 }
 
-size_t MemoryRemoteDocumentCache::CalculateByteSize(
-    FSTLocalSerializer* serializer) {
+size_t MemoryRemoteDocumentCache::CalculateByteSize(const Sizer& sizer) {
   size_t count = 0;
   for (const auto& kv : docs_) {
-    count += DocumentKeyByteSize(kv.first);
-    count += [[serializer encodedMaybeDocument:kv.second] serializedSize];
+    count += sizer.CalculateByteSize(kv.second);
   }
   return count;
 }

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

@@ -0,0 +1,53 @@
+/*
+ * 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_LOCAL_PROTO_SIZER_H_
+#define FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_LOCAL_PROTO_SIZER_H_
+
+#if !defined(__OBJC__)
+#error "This header only supports Objective-C++"
+#endif  // !defined(__OBJC__)
+
+#include "Firestore/core/src/firebase/firestore/local/sizer.h"
+
+@class FSTLocalSerializer;
+
+namespace firebase {
+namespace firestore {
+namespace local {
+
+/**
+ * Estimates the stored size of documents and queries by translating to protos
+ * and using the serialized sizes to estimate.
+ */
+class ProtoSizer : public Sizer {
+ public:
+  explicit ProtoSizer(FSTLocalSerializer* serializer);
+
+  size_t CalculateByteSize(
+      const model::MaybeDocument& maybe_doc) const override;
+
+  size_t CalculateByteSize(const QueryData& query_data) const override;
+
+ private:
+  FSTLocalSerializer* serializer_;
+};
+
+}  // namespace local
+}  // namespace firestore
+}  // namespace firebase
+
+#endif  // FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_LOCAL_PROTO_SIZER_H_

Firestore/core/src/firebase/firestore/local/proto_sizer.mm

@@ -0,0 +1,65 @@
+/*
+ * 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/local/proto_sizer.h"
+
+#import "Firestore/Protos/objc/firestore/local/MaybeDocument.pbobjc.h"
+#import "Firestore/Protos/objc/firestore/local/Target.pbobjc.h"
+#import "Firestore/Source/Local/FSTLocalSerializer.h"
+
+#include "Firestore/core/src/firebase/firestore/model/document_key.h"
+#include "Firestore/core/src/firebase/firestore/model/maybe_document.h"
+
+namespace firebase {
+namespace firestore {
+namespace local {
+namespace {
+
+using model::DocumentKey;
+using model::MaybeDocument;
+
+/**
+ * Returns an estimate of the number of bytes used to store the given document
+ * key in memory. This is only an estimate and includes the size of the segments
+ * of the path, but not any object overhead or path separators.
+ */
+size_t DocumentKeyByteSize(const DocumentKey& key) {
+  size_t count = 0;
+  for (const auto& segment : key.path()) {
+    count += segment.size();
+  }
+  return count;
+}
+
+}  // namespace
+
+ProtoSizer::ProtoSizer(FSTLocalSerializer* serializer)
+    : serializer_(serializer) {
+}
+
+size_t ProtoSizer::CalculateByteSize(const MaybeDocument& maybe_doc) const {
+  size_t count = DocumentKeyByteSize(maybe_doc.key());
+  count += [[serializer_ encodedMaybeDocument:maybe_doc] serializedSize];
+  return count;
+}
+
+size_t ProtoSizer::CalculateByteSize(const QueryData& query_data) const {
+  return [[serializer_ encodedQueryData:query_data] serializedSize];
+}
+
+}  // namespace local
+}  // namespace firestore
+}  // namespace firebase

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

@@ -0,0 +1,58 @@
+/*
+ * 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_LOCAL_SIZER_H_
+#define FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_LOCAL_SIZER_H_
+
+#include <cstddef>
+
+namespace firebase {
+namespace firestore {
+namespace model {
+
+class MaybeDocument;
+
+}  // namespace model
+
+namespace local {
+
+class QueryData;
+
+/**
+ * Estimates the stored size of documents and queries.
+ */
+class Sizer {
+ public:
+  virtual ~Sizer() = default;
+
+  /**
+   * Calculates the size of the given maybe_doc in bytes. Note that even
+   * NoDocuments have an associated size.
+   */
+  virtual size_t CalculateByteSize(
+      const model::MaybeDocument& maybe_doc) const = 0;
+
+  /**
+   * Calculates the size of the given query_data in bytes.
+   */
+  virtual size_t CalculateByteSize(const QueryData& query_data) const = 0;
+};
+
+}  // namespace local
+}  // namespace firestore
+}  // namespace firebase
+
+#endif  // FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_LOCAL_SIZER_H_