Finish sizer interface (#3752)

* Use int64_t for CalculateSizeBytes

This avoids a bunch of nasty casting/checking in other parts of the code

* Use the Sizer for MutationBatches

* Don't double-count document key size.

Author: wilhuff

Firestore/Source/Local/FSTLRUGarbageCollector.h

@@ -70,7 +70,7 @@ namespace model = firebase::firestore::model;
                                   (const std::unordered_map<model::TargetId, local::QueryData> &)
                                       liveQueries;
 
-- (size_t)byteSize;
+- (int64_t)byteSize;
 
 /** Returns the number of targets and orphaned documents cached. */
 - (size_t)sequenceNumberCount;

Firestore/Source/Local/FSTLevelDB.mm

@@ -16,6 +16,7 @@
 
 #import "Firestore/Source/Local/FSTLevelDB.h"
 
+#include <limits>
 #include <memory>
 #include <unordered_map>
 #include <utility>
@@ -99,7 +100,7 @@
 
 @interface FSTLevelDB ()
 
-- (size_t)byteSize;
+- (int64_t)byteSize;
 
 @property(nonatomic, assign, getter=isStarted) BOOL started;
 
@@ -276,7 +277,7 @@ - (void)limboDocumentUpdated:(const DocumentKey &)key {
   [self writeSentinelForKey:key];
 }
 
-- (size_t)byteSize {
+- (int64_t)byteSize {
   return [_db byteSize];
 }
 
@@ -379,7 +380,7 @@ - (instancetype)initWithLevelDB:(std::unique_ptr<leveldb::DB>)db
   return self;
 }
 
-- (size_t)byteSize {
+- (int64_t)byteSize {
   int64_t count = 0;
   auto iter = util::DirectoryIterator::Create(_directory);
   for (; iter->Valid(); iter->Next()) {
@@ -388,8 +389,9 @@ - (size_t)byteSize {
   }
   HARD_ASSERT(iter->status().ok(), "Failed to iterate leveldb directory: %s",
               iter->status().error_message().c_str());
-  HARD_ASSERT(count >= 0 && count <= SIZE_MAX, "Overflowed counting bytes cached");
-  return static_cast<size_t>(count);
+  HARD_ASSERT(count >= 0 && count <= std::numeric_limits<int64_t>::max(),
+              "Overflowed counting bytes cached");
+  return count;
 }
 
 - (const std::set<std::string> &)users {

Firestore/Source/Local/FSTMemoryPersistence.mm

@@ -322,17 +322,17 @@ - (BOOL)isPinnedAtSequenceNumber:(ListenSequenceNumber)upperBound
   return NO;
 }
 
-- (size_t)byteSize {
+- (int64_t)byteSize {
   // Note that this method is only used for testing because this delegate is only
   // 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;
+  int64_t count = 0;
   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);
+    count += entry.second->CalculateByteSize(sizer);
   }
   return count;
 }

Firestore/core/src/firebase/firestore/local/lru_garbage_collector.cc

@@ -113,8 +113,8 @@ LruResults LruGarbageCollector::Collect(const LiveQueryMap& live_targets) {
     return LruResults::DidNotRun();
   }
 
-  size_t current_size = CalculateByteSize();
-  if (current_size < static_cast<size_t>(params_.min_bytes_threshold)) {
+  int64_t current_size = CalculateByteSize();
+  if (current_size < params_.min_bytes_threshold) {
     // Not enough on disk to warrant collection. Wait another timeout cycle.
     LOG_DEBUG(
         "Garbage collection skipped; Cache size %s is lower than threshold %s",

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

@@ -73,7 +73,7 @@ class LruDelegate {
   /** Access to the underlying LRU Garbage collector instance. */
   virtual LruGarbageCollector* garbage_collector() = 0;
 
-  virtual size_t CalculateByteSize() const = 0;
+  virtual int64_t CalculateByteSize() = 0;
 
   /** Returns the number of targets and orphaned documents cached. */
   virtual size_t GetSequenceNumberCount() = 0;
@@ -121,7 +121,7 @@ class LruDelegateBridge : public LruDelegate {
     return target_.gc;
   }
 
-  size_t CalculateByteSize() const override {
+  int64_t CalculateByteSize() override {
     return [target_ byteSize];
   }
 
@@ -178,7 +178,7 @@ class LruGarbageCollector {
  public:
   LruGarbageCollector(LruDelegate* delegate, LruParams params);
 
-  size_t CalculateByteSize() const {
+  int64_t CalculateByteSize() const {
     return delegate_->CalculateByteSize();
   }
 

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

@@ -34,7 +34,6 @@
 #include "Firestore/core/src/firebase/firestore/model/document_key_set.h"
 #include "Firestore/core/src/firebase/firestore/model/types.h"
 
-@class FSTLocalSerializer;
 @class FSTMemoryPersistence;
 
 NS_ASSUME_NONNULL_BEGIN
@@ -43,6 +42,8 @@ namespace firebase {
 namespace firestore {
 namespace local {
 
+class Sizer;
+
 class MemoryMutationQueue : public MutationQueue {
  public:
   explicit MemoryMutationQueue(FSTMemoryPersistence* persistence);
@@ -86,7 +87,7 @@ class MemoryMutationQueue : public MutationQueue {
 
   bool ContainsKey(const model::DocumentKey& key);
 
-  size_t CalculateByteSize(FSTLocalSerializer* serializer);
+  int64_t CalculateByteSize(const Sizer& sizer);
 
   nanopb::ByteString GetLastStreamToken() override;
   void SetLastStreamToken(const nanopb::ByteString& token) override;

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

@@ -18,11 +18,10 @@
 
 #include <utility>
 
-#import "Firestore/Protos/objc/firestore/local/Mutation.pbobjc.h"
-#import "Firestore/Source/Local/FSTLocalSerializer.h"
 #import "Firestore/Source/Local/FSTMemoryPersistence.h"
 
 #include "Firestore/core/src/firebase/firestore/local/document_key_reference.h"
+#include "Firestore/core/src/firebase/firestore/local/sizer.h"
 #include "Firestore/core/src/firebase/firestore/model/mutation_batch.h"
 #include "Firestore/core/src/firebase/firestore/model/resource_path.h"
 #include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
@@ -257,10 +256,10 @@ MutationBatch batch(batch_id, local_write_time, std::move(base_mutations),
   return begin != range.end() && begin->key() == key;
 }
 
-size_t MemoryMutationQueue::CalculateByteSize(FSTLocalSerializer* serializer) {
-  size_t count = 0;
+int64_t MemoryMutationQueue::CalculateByteSize(const Sizer& sizer) {
+  int64_t count = 0;
   for (const auto& batch : queue_) {
-    count += [[serializer encodedMutationBatch:batch] serializedSize];
+    count += sizer.CalculateByteSize(batch);
   };
   return count;
 }

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

@@ -76,7 +76,7 @@ class MemoryQueryCache : public QueryCache {
   bool Contains(const model::DocumentKey& key) override;
 
   // Other methods and accessors
-  size_t CalculateByteSize(const Sizer& sizer);
+  int64_t CalculateByteSize(const Sizer& sizer);
 
   size_t size() const override {
     return queries_.size();

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

@@ -122,8 +122,8 @@
   return references_.ContainsKey(key);
 }
 
-size_t MemoryQueryCache::CalculateByteSize(const Sizer& sizer) {
-  size_t count = 0;
+int64_t MemoryQueryCache::CalculateByteSize(const Sizer& sizer) {
+  int64_t count = 0;
   for (const auto& kv : queries_) {
     count += sizer.CalculateByteSize(kv.second);
   }

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

@@ -58,7 +58,7 @@ class MemoryRemoteDocumentCache : public RemoteDocumentCache {
       FSTMemoryLRUReferenceDelegate* reference_delegate,
       model::ListenSequenceNumber upper_bound);
 
-  size_t CalculateByteSize(const Sizer& sizer);
+  int64_t CalculateByteSize(const Sizer& sizer);
 
  private:
   /** Underlying cache of documents. */