Use C++ Timestamp internally instead of FIRTimestamp (#3156)

This is yet another preparatory step to migrating FIRTimetsampValue to
C++.

Author: wilhuff

Firestore/Example/Tests/Integration/FSTDatastoreTests.mm

@@ -49,6 +49,7 @@
 #include "absl/memory/memory.h"
 
 namespace util = firebase::firestore::util;
+using firebase::Timestamp;
 using firebase::firestore::auth::EmptyCredentialsProvider;
 using firebase::firestore::core::DatabaseInfo;
 using firebase::firestore::model::BatchId;
@@ -221,7 +222,7 @@ - (void)testStreamingWrite {
 
   FSTSetMutation *mutation = [self setMutation];
   FSTMutationBatch *batch = [[FSTMutationBatch alloc] initWithBatchID:23
-                                                       localWriteTime:[FIRTimestamp timestamp]
+                                                       localWriteTime:Timestamp::Now()
                                                         baseMutations:{}
                                                             mutations:{mutation}];
   _testWorkerQueue->Enqueue([=] {

Firestore/Example/Tests/Local/FSTLRUGarbageCollectorTests.mm

@@ -23,14 +23,15 @@
 #include <utility>
 #include <vector>
 
-#import "FIRTimestamp.h"
 #import "Firestore/Example/Tests/Util/FSTHelpers.h"
 #import "Firestore/Source/Local/FSTLRUGarbageCollector.h"
 #import "Firestore/Source/Local/FSTPersistence.h"
 #import "Firestore/Source/Model/FSTDocument.h"
 #import "Firestore/Source/Model/FSTFieldValue.h"
 #import "Firestore/Source/Model/FSTMutation.h"
 #import "Firestore/Source/Util/FSTClasses.h"
+
+#include "Firestore/core/include/firebase/firestore/timestamp.h"
 #include "Firestore/core/src/firebase/firestore/auth/user.h"
 #include "Firestore/core/src/firebase/firestore/local/mutation_queue.h"
 #include "Firestore/core/src/firebase/firestore/local/query_cache.h"
@@ -43,6 +44,7 @@
 #include "absl/strings/str_cat.h"
 
 namespace testutil = firebase::firestore::testutil;
+using firebase::Timestamp;
 using firebase::firestore::auth::User;
 using firebase::firestore::local::LruParams;
 using firebase::firestore::local::LruResults;
@@ -449,7 +451,7 @@ - (void)testRemoveOrphanedDocuments {
   // Insert the mutations. These operations don't have a sequence number, they just
   // serve to keep the mutated documents from being GC'd while the mutations are outstanding.
   _persistence.run("actually register the mutations", [&]() {
-    FIRTimestamp *writeTime = [FIRTimestamp timestamp];
+    Timestamp writeTime = Timestamp::Now();
     _mutationQueue->AddMutationBatch(writeTime, {}, std::move(mutations));
   });
 

Firestore/Example/Tests/Local/FSTLocalSerializerTests.mm

@@ -41,13 +41,15 @@
 
 #import "Firestore/Example/Tests/Util/FSTHelpers.h"
 
+#include "Firestore/core/include/firebase/firestore/timestamp.h"
 #include "Firestore/core/src/firebase/firestore/model/database_id.h"
 #include "Firestore/core/src/firebase/firestore/model/field_mask.h"
 #include "Firestore/core/src/firebase/firestore/model/precondition.h"
 #include "Firestore/core/src/firebase/firestore/util/string_apple.h"
 #include "Firestore/core/test/firebase/firestore/testutil/testutil.h"
 
 namespace testutil = firebase::firestore::testutil;
+using firebase::Timestamp;
 using firebase::firestore::model::DatabaseId;
 using firebase::firestore::model::FieldMask;
 using firebase::firestore::model::Precondition;
@@ -90,7 +92,7 @@ - (void)testEncodesMutationBatch {
                                       value:FSTTestObjectValue(@{@"a" : @"b", @"num" : @1})
                                precondition:Precondition::Exists(true)];
   FSTMutation *del = FSTTestDeleteMutation(@"baz/quux");
-  FIRTimestamp *writeTime = [FIRTimestamp timestamp];
+  Timestamp writeTime = Timestamp::Now();
   FSTMutationBatch *model = [[FSTMutationBatch alloc] initWithBatchID:42
                                                        localWriteTime:writeTime
                                                         baseMutations:{base}
@@ -124,8 +126,8 @@ - (void)testEncodesMutationBatch {
   delProto.delete_p = @"projects/p/databases/d/documents/baz/quux";
 
   GPBTimestamp *writeTimeProto = [GPBTimestamp message];
-  writeTimeProto.seconds = writeTime.seconds;
-  writeTimeProto.nanos = writeTime.nanoseconds;
+  writeTimeProto.seconds = writeTime.seconds();
+  writeTimeProto.nanos = writeTime.nanoseconds();
 
   FSTPBWriteBatch *batchProto = [FSTPBWriteBatch message];
   batchProto.batchId = 42;
@@ -136,7 +138,7 @@ - (void)testEncodesMutationBatch {
   XCTAssertEqualObjects([self.serializer encodedMutationBatch:model], batchProto);
   FSTMutationBatch *decoded = [self.serializer decodedMutationBatch:batchProto];
   XCTAssertEqual(decoded.batchID, model.batchID);
-  XCTAssertEqualObjects(decoded.localWriteTime, model.localWriteTime);
+  XCTAssertEqual(decoded.localWriteTime, model.localWriteTime);
   FSTAssertEqualVectors(decoded.baseMutations, model.baseMutations);
   FSTAssertEqualVectors(decoded.mutations, model.mutations);
   XCTAssertEqual([decoded keys], [model keys]);

Firestore/Example/Tests/Local/FSTLocalStoreTests.mm

@@ -37,6 +37,7 @@
 #import "Firestore/third_party/Immutable/Tests/FSTImmutableSortedDictionary+Testing.h"
 #import "Firestore/third_party/Immutable/Tests/FSTImmutableSortedSet+Testing.h"
 
+#include "Firestore/core/include/firebase/firestore/timestamp.h"
 #include "Firestore/core/src/firebase/firestore/auth/user.h"
 #include "Firestore/core/src/firebase/firestore/model/document_map.h"
 #include "Firestore/core/src/firebase/firestore/model/document_set.h"
@@ -46,6 +47,7 @@
 #include "Firestore/core/test/firebase/firestore/testutil/testutil.h"
 
 namespace testutil = firebase::firestore::testutil;
+using firebase::Timestamp;
 using firebase::firestore::auth::User;
 using firebase::firestore::model::DocumentKey;
 using firebase::firestore::model::DocumentKeySet;
@@ -134,7 +136,7 @@ - (void)writeMutations:(std::vector<FSTMutation *> &&)mutations {
   FSTLocalWriteResult *result = [self.localStore locallyWriteMutations:std::move(mutationsCopy)];
   XCTAssertNotNil(result);
   [self.batches addObject:[[FSTMutationBatch alloc] initWithBatchID:result.batchID
-                                                     localWriteTime:[FIRTimestamp timestamp]
+                                                     localWriteTime:Timestamp::Now()
                                                       baseMutations:{}
                                                           mutations:std::move(mutations)]];
   _lastChanges = result.changes;
@@ -237,7 +239,7 @@ - (void)testMutationBatchKeys {
   FSTMutation *set1 = FSTTestSetMutation(@"foo/bar", @{@"foo" : @"bar"});
   FSTMutation *set2 = FSTTestSetMutation(@"bar/baz", @{@"bar" : @"baz"});
   FSTMutationBatch *batch = [[FSTMutationBatch alloc] initWithBatchID:1
-                                                       localWriteTime:[FIRTimestamp timestamp]
+                                                       localWriteTime:Timestamp::Now()
                                                         baseMutations:{base}
                                                             mutations:{set1, set2}];
   DocumentKeySet keys = [batch keys];

Firestore/Example/Tests/Local/FSTMutationQueueTests.mm

@@ -36,6 +36,7 @@
 #include "Firestore/core/test/firebase/firestore/testutil/testutil.h"
 
 namespace testutil = firebase::firestore::testutil;
+using firebase::Timestamp;
 using firebase::firestore::auth::User;
 using firebase::firestore::model::DocumentKey;
 using firebase::firestore::model::DocumentKeySet;
@@ -201,7 +202,7 @@ - (void)testAllMutationBatchesAffectingDocumentKey {
     NSMutableArray<FSTMutationBatch *> *batches = [NSMutableArray array];
     for (FSTMutation *mutation in mutations) {
       FSTMutationBatch *batch =
-          self.mutationQueue->AddMutationBatch([FIRTimestamp timestamp], {}, {mutation});
+          self.mutationQueue->AddMutationBatch(Timestamp::Now(), {}, {mutation});
       [batches addObject:batch];
     }
 
@@ -228,7 +229,7 @@ - (void)testAllMutationBatchesAffectingDocumentKeys {
     NSMutableArray<FSTMutationBatch *> *batches = [NSMutableArray array];
     for (FSTMutation *mutation in mutations) {
       FSTMutationBatch *batch =
-          self.mutationQueue->AddMutationBatch([FIRTimestamp timestamp], {}, {mutation});
+          self.mutationQueue->AddMutationBatch(Timestamp::Now(), {}, {mutation});
       [batches addObject:batch];
     }
 
@@ -254,16 +255,16 @@ - (void)testAllMutationBatchesAffectingDocumentKeys_handlesOverlap {
         FSTTestSetMutation(@"foo/baz", @{@"a" : @1}),
     };
     FSTMutationBatch *batch1 =
-        self.mutationQueue->AddMutationBatch([FIRTimestamp timestamp], {}, std::move(group1));
+        self.mutationQueue->AddMutationBatch(Timestamp::Now(), {}, std::move(group1));
 
     std::vector<FSTMutation *> group2 = {FSTTestSetMutation(@"food/bar", @{@"a" : @1})};
-    self.mutationQueue->AddMutationBatch([FIRTimestamp timestamp], {}, std::move(group2));
+    self.mutationQueue->AddMutationBatch(Timestamp::Now(), {}, std::move(group2));
 
     std::vector<FSTMutation *> group3 = {
         FSTTestSetMutation(@"foo/bar", @{@"b" : @1}),
     };
     FSTMutationBatch *batch3 =
-        self.mutationQueue->AddMutationBatch([FIRTimestamp timestamp], {}, std::move(group3));
+        self.mutationQueue->AddMutationBatch(Timestamp::Now(), {}, std::move(group3));
 
     DocumentKeySet keys{
         Key("foo/bar"),
@@ -293,7 +294,7 @@ - (void)testAllMutationBatchesAffectingQuery {
     NSMutableArray<FSTMutationBatch *> *batches = [NSMutableArray array];
     for (FSTMutation *mutation in mutations) {
       FSTMutationBatch *batch =
-          self.mutationQueue->AddMutationBatch([FIRTimestamp timestamp], {}, {mutation});
+          self.mutationQueue->AddMutationBatch(Timestamp::Now(), {}, {mutation});
       [batches addObject:batch];
     }
 
@@ -396,8 +397,7 @@ - (FSTMutationBatch *)addMutationBatch {
 - (FSTMutationBatch *)addMutationBatchWithKey:(NSString *)key {
   FSTSetMutation *mutation = FSTTestSetMutation(key, @{@"a" : @1});
 
-  FSTMutationBatch *batch =
-      self.mutationQueue->AddMutationBatch([FIRTimestamp timestamp], {}, {mutation});
+  FSTMutationBatch *batch = self.mutationQueue->AddMutationBatch(Timestamp::Now(), {}, {mutation});
   return batch;
 }
 

Firestore/Example/Tests/Model/FSTFieldValueTests.mm

@@ -22,6 +22,7 @@
 
 #import "Firestore/Source/API/FIRFirestore+Internal.h"
 #import "Firestore/Source/API/FSTUserDataConverter.h"
+#import "Firestore/Source/API/converters.h"
 
 #import "Firestore/Example/Tests/API/FSTAPIHelpers.h"
 #import "Firestore/Example/Tests/Util/FSTHelpers.h"
@@ -31,10 +32,12 @@
 #include "Firestore/core/src/firebase/firestore/model/field_value.h"
 #include "Firestore/core/src/firebase/firestore/util/string_apple.h"
 #include "Firestore/core/test/firebase/firestore/testutil/testutil.h"
+#include "Firestore/core/test/firebase/firestore/testutil/time_testing.h"
 
 namespace testutil = firebase::firestore::testutil;
 namespace util = firebase::firestore::util;
 using firebase::firestore::GeoPoint;
+using firebase::firestore::api::MakeTimestamp;
 using firebase::firestore::model::DatabaseId;
 using firebase::firestore::model::FieldValue;
 
@@ -49,11 +52,11 @@
       // strings that can be used instead.
       if ([value isEqual:@"server-timestamp-1"]) {
         wrappedValue = [FSTServerTimestampValue
-            serverTimestampValueWithLocalWriteTime:FSTTestTimestamp(2016, 5, 20, 10, 20, 0)
+            serverTimestampValueWithLocalWriteTime:testutil::MakeTimestamp(2016, 5, 20, 10, 20, 0)
                                      previousValue:nil];
       } else if ([value isEqual:@"server-timestamp-2"]) {
         wrappedValue = [FSTServerTimestampValue
-            serverTimestampValueWithLocalWriteTime:FSTTestTimestamp(2016, 10, 21, 15, 32, 0)
+            serverTimestampValueWithLocalWriteTime:testutil::MakeTimestamp(2016, 10, 21, 15, 32, 0)
                                      previousValue:nil];
       } else if ([value isKindOfClass:[FSTDocumentKeyReference class]]) {
         // We directly convert these here so that the databaseIDs can be different.
@@ -304,23 +307,17 @@ - (void)testValueEquality {
     @[ FSTTestFieldValue(@"strin") ],
     @[ FSTTestFieldValue(@"e\u0301b") ],  // latin small letter e + combining acute accent
     @[ FSTTestFieldValue(@"\u00e9a") ],   // latin small letter e with acute accent
-    @[
-      FSTTestFieldValue(date1),
-      [FSTTimestampValue timestampValue:[FIRTimestamp timestampWithDate:date1]]
-    ],
+    @[ FSTTestFieldValue(date1), [FSTTimestampValue timestampValue:MakeTimestamp(date1)] ],
     @[ FSTTestFieldValue(date2) ],
     @[
       // NOTE: ServerTimestampValues can't be parsed via FSTTestFieldValue().
-      [FSTServerTimestampValue
-          serverTimestampValueWithLocalWriteTime:[FIRTimestamp timestampWithDate:date1]
-                                   previousValue:nil],
-      [FSTServerTimestampValue
-          serverTimestampValueWithLocalWriteTime:[FIRTimestamp timestampWithDate:date1]
-                                   previousValue:nil]
+      [FSTServerTimestampValue serverTimestampValueWithLocalWriteTime:MakeTimestamp(date1)
+                                                        previousValue:nil],
+      [FSTServerTimestampValue serverTimestampValueWithLocalWriteTime:MakeTimestamp(date1)
+                                                        previousValue:nil]
     ],
-    @[ [FSTServerTimestampValue
-        serverTimestampValueWithLocalWriteTime:[FIRTimestamp timestampWithDate:date2]
-                                 previousValue:nil] ],
+    @[ [FSTServerTimestampValue serverTimestampValueWithLocalWriteTime:MakeTimestamp(date2)
+                                                         previousValue:nil] ],
     @[ FSTTestFieldValue(FSTTestGeoPoint(0, 1)), FieldValue::FromGeoPoint(GeoPoint(0, 1)).Wrap() ],
     @[ FSTTestFieldValue(FSTTestGeoPoint(1, 0)) ],
     @[

Firestore/Example/Tests/Model/FSTMutationTests.mm

@@ -23,11 +23,13 @@
 #include <vector>
 
 #import "Firestore/Source/API/FIRFieldValue+Internal.h"
+#import "Firestore/Source/API/converters.h"
 #import "Firestore/Source/Model/FSTDocument.h"
 #import "Firestore/Source/Model/FSTFieldValue.h"
 
 #import "Firestore/Example/Tests/Util/FSTHelpers.h"
 
+#include "Firestore/core/include/firebase/firestore/timestamp.h"
 #include "Firestore/core/src/firebase/firestore/model/document_key.h"
 #include "Firestore/core/src/firebase/firestore/model/field_mask.h"
 #include "Firestore/core/src/firebase/firestore/model/field_transform.h"
@@ -36,7 +38,9 @@
 #include "Firestore/core/src/firebase/firestore/model/transform_operations.h"
 #include "Firestore/core/test/firebase/firestore/testutil/testutil.h"
 
+namespace api = firebase::firestore::api;
 namespace testutil = firebase::firestore::testutil;
+using firebase::Timestamp;
 using firebase::firestore::model::ArrayTransform;
 using firebase::firestore::model::DocumentKey;
 using firebase::firestore::model::FieldMask;
@@ -50,11 +54,11 @@ @interface FSTMutationTests : XCTestCase
 @end
 
 @implementation FSTMutationTests {
-  FIRTimestamp *_timestamp;
+  Timestamp _timestamp;
 }
 
 - (void)setUp {
-  _timestamp = [FIRTimestamp timestamp];
+  _timestamp = Timestamp::Now();
 }
 
 - (void)testAppliesSetsToDocuments {
@@ -443,12 +447,15 @@ - (void)testAppliesServerAckedServerTimestampTransformToDocuments {
        initWithVersion:testutil::Version(1)
       transformResults:@[ [FSTTimestampValue timestampValue:_timestamp] ]];
 
+  FIRTimestamp *publicTimestamp = api::MakeFIRTimestamp(_timestamp);
   FSTMaybeDocument *transformedDoc = [transform applyToRemoteDocument:baseDoc
                                                        mutationResult:mutationResult];
 
-  NSDictionary *expectedData = @{@"foo" : @{@"bar" : _timestamp.dateValue}, @"baz" : @"baz-value"};
-  XCTAssertEqualObjects(transformedDoc, FSTTestDoc("collection/key", 1, expectedData,
-                                                   FSTDocumentStateCommittedMutations));
+  NSDictionary *expectedData =
+      @{@"foo" : @{@"bar" : publicTimestamp.dateValue}, @"baz" : @"baz-value"};
+  FSTDocument *expectedDoc =
+      FSTTestDoc("collection/key", 1, expectedData, FSTDocumentStateCommittedMutations);
+  XCTAssertEqualObjects(transformedDoc, expectedDoc);
 }
 
 - (void)testAppliesServerAckedArrayTransformsToDocuments {

Firestore/Example/Tests/Model/transform_operations_test.mm

@@ -32,7 +32,7 @@ Type type() const override {
   }
 
   FSTFieldValue* ApplyToLocalView(FSTFieldValue* /* previousValue */,
-                                  FIRTimestamp* /* localWriteTime */) const override {
+                                  const Timestamp& /* localWriteTime */) const override {
     return nil;
   }
 

Firestore/Source/API/FSTUserDataConverter.h

@@ -18,6 +18,7 @@
 
 #include <vector>
 
+#include "Firestore/core/include/firebase/firestore/timestamp.h"
 #include "Firestore/core/src/firebase/firestore/core/user_data.h"
 #include "Firestore/core/src/firebase/firestore/model/database_id.h"
 #include "Firestore/core/src/firebase/firestore/model/document_key.h"

Firestore/Source/API/FSTUserDataConverter.mm

@@ -44,12 +44,15 @@
 #include "Firestore/core/src/firebase/firestore/model/precondition.h"
 #include "Firestore/core/src/firebase/firestore/model/transform_operations.h"
 #include "Firestore/core/src/firebase/firestore/nanopb/nanopb_util.h"
+#include "Firestore/core/src/firebase/firestore/timestamp_internal.h"
 #include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
 #include "Firestore/core/src/firebase/firestore/util/string_apple.h"
 #include "absl/memory/memory.h"
 #include "absl/strings/match.h"
 
 namespace util = firebase::firestore::util;
+using firebase::Timestamp;
+using firebase::TimestampInternal;
 using firebase::firestore::GeoPoint;
 using firebase::firestore::api::ThrowInvalidArgument;
 using firebase::firestore::core::ParsedSetData;
@@ -98,6 +101,8 @@ - (instancetype)initWithKey:(DocumentKey)key databaseID:(DatabaseId)databaseID {
 
 @end
 
+#pragma mark - Conversion helpers
+
 #pragma mark - FSTUserDataConverter
 
 @interface FSTUserDataConverter ()
@@ -447,14 +452,13 @@ - (nullable FSTFieldValue *)parseScalarValue:(nullable id)input context:(ParseCo
     return FieldValue::FromString(util::MakeString(input)).Wrap();
 
   } else if ([input isKindOfClass:[NSDate class]]) {
-    return [FSTTimestampValue timestampValue:[FIRTimestamp timestampWithDate:input]];
+    NSDate *inputDate = input;
+    return [FSTTimestampValue timestampValue:api::MakeTimestamp(inputDate)];
 
   } else if ([input isKindOfClass:[FIRTimestamp class]]) {
-    FIRTimestamp *originalTimestamp = (FIRTimestamp *)input;
-    FIRTimestamp *truncatedTimestamp =
-        [FIRTimestamp timestampWithSeconds:originalTimestamp.seconds
-                               nanoseconds:originalTimestamp.nanoseconds / 1000 * 1000];
-    return [FSTTimestampValue timestampValue:truncatedTimestamp];
+    FIRTimestamp *inputTimestamp = input;
+    Timestamp timestamp = TimestampInternal::Truncate(api::MakeTimestamp(inputTimestamp));
+    return [FSTTimestampValue timestampValue:timestamp];
 
   } else if ([input isKindOfClass:[FIRGeoPoint class]]) {
     return FieldValue::FromGeoPoint(api::MakeGeoPoint(input)).Wrap();