refactor: Replace BSONBinaryData with Blob on iOS

Author: wu-hui

…al/FirebaseFirestore/FIRBSONBinaryData.h …toreInternal/FirebaseFirestore/FIRBlob.hFirebaseFirestoreInternal/FirebaseFirestore/FIRBSONBinaryData.h renamed to FirebaseFirestoreInternal/FirebaseFirestore/FIRBlob.h FirebaseFirestoreInternal/FirebaseFirestore/FIRBSONBinaryData.h renamed to FirebaseFirestoreInternal/FirebaseFirestore/FIRBlob.h

@@ -12,4 +12,4 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#import <FirebaseFirestoreInternal/FIRBSONBinaryData.h>
+#import <FirebaseFirestoreInternal/FIRBlob.h>

Firestore/Example/Firestore.xcodeproj/project.pbxproj

@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-#import <FirebaseFirestore/FIRBSONBinaryData.h>
 #import <FirebaseFirestore/FIRBSONObjectId.h>
 #import <FirebaseFirestore/FIRBSONTimestamp.h>
+#import <FirebaseFirestore/FIRBlob.h>
 #import <FirebaseFirestore/FIRDecimal128Value.h>
 #import <FirebaseFirestore/FIRFieldValue.h>
 #import <FirebaseFirestore/FIRInt32Value.h>
@@ -138,27 +138,54 @@ - (void)testCreateAndReadAndCompareBsonTimestamp {
   XCTAssertFalse([val1 isEqual:val4]);
 }
 
-- (void)testCreateAndReadAndCompareBsonBinaryData {
+- (void)testCreateAndReadAndCompareBlob {
   uint8_t byteArray1[] = {0x01, 0x02, 0x03, 0x04, 0x05};
   uint8_t byteArray2[] = {0x01, 0x02, 0x03, 0x04, 0x99};
   NSData *data1 = [NSData dataWithBytes:byteArray1 length:sizeof(byteArray1)];
   NSData *data2 = [NSData dataWithBytes:byteArray1 length:sizeof(byteArray1)];
   NSData *data3 = [NSData dataWithBytes:byteArray2 length:sizeof(byteArray2)];
 
-  FIRBSONBinaryData *val1 = [[FIRBSONBinaryData alloc] initWithSubtype:128 data:data1];
-  FIRBSONBinaryData *val2 = [[FIRBSONBinaryData alloc] initWithSubtype:128 data:data2];
-  FIRBSONBinaryData *val3 = [[FIRBSONBinaryData alloc] initWithSubtype:128 data:data3];
-  FIRBSONBinaryData *val4 = [[FIRBSONBinaryData alloc] initWithSubtype:1 data:data1];
+  // Standard Blobs
+  FIRBlob *std1 = [FIRBlob blobWithBytes:data1];
+  FIRBlob *std2 = [FIRBlob blobWithBytes:data2];
+  FIRBlob *std3 = [FIRBlob blobWithBytes:data3];
 
-  // Test reading the values back.
-  XCTAssertEqual(128, val1.subtype);
-  XCTAssertEqual(data1, val1.data);
-  XCTAssertTrue([val1.data isEqualToData:data1]);
+  // BSON Blobs
+  FIRBlob *bson1 = [FIRBlob blobWithBSONBinary:data1 subtype:128];
+  FIRBlob *bson2 = [FIRBlob blobWithBSONBinary:data2 subtype:128];
+  FIRBlob *bson3 = [FIRBlob blobWithBSONBinary:data3 subtype:128];
+  FIRBlob *bson4 = [FIRBlob blobWithBSONBinary:data1 subtype:1];
+
+  // Test reading properties back
+  XCTAssertEqual(0, std1.subtype);
+  XCTAssertFalse(std1.isBSON);
+  XCTAssertEqual(data1, std1.bytes);
+
+  XCTAssertEqual(128, bson1.subtype);
+  XCTAssertTrue(bson1.isBSON);
+  XCTAssertEqual(data1, bson1.bytes);
 
   // Test isEqual
-  XCTAssertTrue([val1 isEqual:val2]);
-  XCTAssertFalse([val1 isEqual:val3]);
-  XCTAssertFalse([val1 isEqual:val4]);
+  XCTAssertTrue([std1 isEqual:std2]);
+  XCTAssertFalse([std1 isEqual:std3]);
+  XCTAssertFalse([std1 isEqual:bson1]);
+
+  XCTAssertTrue([bson1 isEqual:bson2]);
+  XCTAssertFalse([bson1 isEqual:bson3]);
+  XCTAssertFalse([bson1 isEqual:bson4]);
+
+  // Test compare
+  XCTAssertEqual(NSOrderedSame, [std1 compare:std2]);
+  XCTAssertEqual(NSOrderedAscending, [std1 compare:std3]);
+  XCTAssertEqual(NSOrderedDescending, [std3 compare:std1]);
+
+  XCTAssertEqual(NSOrderedSame, [bson1 compare:bson2]);
+  XCTAssertEqual(NSOrderedAscending, [bson1 compare:bson3]);
+
+  // Standard blob (subtype 0) compares less than BSON blob (subtype 1)
+  XCTAssertEqual(NSOrderedAscending, [std1 compare:bson4]);
+  // BSON blob (subtype 1) compares less than BSON blob (subtype 128)
+  XCTAssertEqual(NSOrderedAscending, [bson4 compare:bson1]);
 }
 
 - (void)testFieldValueMinKey {
@@ -205,14 +232,14 @@ - (void)testFieldValueBsonTimestamp {
   XCTAssertEqual(100U, val2.increment);
 }
 
-- (void)testFieldValueBsonBinaryData {
+- (void)testFieldValueBlob {
   uint8_t byteArray[] = {0x01, 0x02, 0x03, 0x04, 0x05};
   NSData *data = [NSData dataWithBytes:byteArray length:sizeof(byteArray)];
-  FIRBSONBinaryData *val1 = [[FIRBSONBinaryData alloc] initWithSubtype:128 data:data];
-  FIRBSONBinaryData *val2 = [[FIRBSONBinaryData alloc] initWithSubtype:128 data:data];
+  FIRBlob *val1 = [FIRBlob blobWithBSONBinary:data subtype:128];
+  FIRBlob *val2 = [FIRBlob blobWithBSONBinary:data subtype:128];
   XCTAssertTrue([val1 isEqual:val2]);
   XCTAssertEqual(128, val2.subtype);
-  XCTAssertEqual(data, val2.data);
+  XCTAssertEqual(data, val2.bytes);
 }
 
 @end

Firestore/Example/Tests/API/FIRBsonTypesUnitTests.mm

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * 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/Source/Public/FirebaseFirestore/FIRBlob.h"
+
+@implementation FIRBlob
+
+- (instancetype)initWithBytes:(NSData *)bytes subtype:(uint8_t)subtype isBSON:(BOOL)isBSON {
+  self = [super init];
+  if (self) {
+    _subtype = subtype;
+    _bytes = [bytes copy];
+    _BSON = isBSON;
+  }
+  return self;
+}
+
++ (instancetype)blobWithBytes:(NSData *)bytes {
+  return [[FIRBlob alloc] initWithBytes:bytes subtype:0 isBSON:NO];
+}
+
++ (instancetype)blobWithBSONBinary:(NSData *)bytes {
+  return [[FIRBlob alloc] initWithBytes:bytes subtype:0 isBSON:YES];
+}
+
++ (instancetype)blobWithBSONBinary:(NSData *)bytes subtype:(uint8_t)subtype {
+  return [[FIRBlob alloc] initWithBytes:bytes subtype:subtype isBSON:YES];
+}
+
+- (BOOL)isEqual:(nullable id)object {
+  if (self == object) {
+    return YES;
+  }
+
+  if (![object isKindOfClass:[FIRBlob class]]) {
+    return NO;
+  }
+
+  FIRBlob *other = (FIRBlob *)object;
+  return self.subtype == other.subtype && [self.bytes isEqualToData:other.bytes];
+}
+
+- (NSUInteger)hash {
+  return [self.bytes hash] ^ self.subtype;
+}
+
+- (id)copyWithZone:(__unused NSZone *_Nullable)zone {
+  return [[FIRBlob alloc] initWithBytes:self.bytes subtype:self.subtype isBSON:self.isBSON];
+}
+
+- (NSComparisonResult)compare:(FIRBlob *)other {
+  if (self.subtype < other.subtype) {
+    return NSOrderedAscending;
+  } else if (self.subtype > other.subtype) {
+    return NSOrderedDescending;
+  }
+
+  NSUInteger selfLength = self.bytes.length;
+  NSUInteger otherLength = other.bytes.length;
+  NSUInteger minLength = MIN(selfLength, otherLength);
+  int cmp = memcmp(self.bytes.bytes, other.bytes.bytes, minLength);
+  if (cmp < 0) {
+    return NSOrderedAscending;
+  } else if (cmp > 0) {
+    return NSOrderedDescending;
+  }
+
+  if (selfLength < otherLength) {
+    return NSOrderedAscending;
+  } else if (selfLength > otherLength) {
+    return NSOrderedDescending;
+  }
+  return NSOrderedSame;
+}
+
+- (NSString *)description {
+  return [NSString stringWithFormat:@"<FIRBlob: isBSON:%@, subtype:%u, bytes:%@>",
+                                    self.isBSON ? @"YES" : @"NO", (unsigned int)self.subtype,
+                                    self.bytes];
+}
+
+@end

Firestore/Source/API/FIRBSONBinaryData.m

@@ -24,9 +24,9 @@
 
 #import "Firestore/Source/API/FSTUserDataReader.h"
 
-#import "FIRBSONBinaryData.h"
 #import "FIRBSONObjectId.h"
 #import "FIRBSONTimestamp.h"
+#import "FIRBlob.h"
 #import "FIRDecimal128Value.h"
 #import "FIRGeoPoint.h"
 #import "FIRInt32Value.h"
@@ -515,26 +515,29 @@ - (ParsedUpdateData)parsedUpdateData:(id)input {
   return std::move(result);
 }
 
-- (Message<google_firestore_v1_Value>)parseBsonBinaryData:(FIRBSONBinaryData *)binaryData
-                                                  context:(ParseContext &&)context {
-  uint8_t subtypeByte = binaryData.subtype;
-  NSData *data = binaryData.data;
+- (Message<google_firestore_v1_Value>)parseBlob:(FIRBlob *)blob context:(ParseContext &&)context {
+  if (blob.isBSON) {
+    uint8_t subtypeByte = blob.subtype;
+    NSData *data = blob.bytes;
 
-  // We need to prepend the data with one byte representation of the subtype.
-  NSMutableData *concatData = [NSMutableData data];
-  [concatData appendBytes:&subtypeByte length:1];
-  [concatData appendData:data];
+    // We need to prepend the data with one byte representation of the subtype.
+    NSMutableData *concatData = [NSMutableData data];
+    [concatData appendBytes:&subtypeByte length:1];
+    [concatData appendData:data];
 
-  __block Message<google_firestore_v1_Value> result;
-  result->which_value_type = google_firestore_v1_Value_map_value_tag;
-  result->map_value = {};
-  result->map_value.fields_count = 1;
-  result->map_value.fields = nanopb::MakeArray<google_firestore_v1_MapValue_FieldsEntry>(1);
-  result->map_value.fields[0].key = nanopb::CopyBytesArray(model::kBsonBinaryDataTypeFieldValue);
-  result->map_value.fields[0].value =
-      *[self encodeBlob:(nanopb::MakeByteString(concatData))].release();
+    __block Message<google_firestore_v1_Value> result;
+    result->which_value_type = google_firestore_v1_Value_map_value_tag;
+    result->map_value = {};
+    result->map_value.fields_count = 1;
+    result->map_value.fields = nanopb::MakeArray<google_firestore_v1_MapValue_FieldsEntry>(1);
+    result->map_value.fields[0].key = nanopb::CopyBytesArray(model::kBsonBinaryDataTypeFieldValue);
+    result->map_value.fields[0].value =
+        *[self encodeBlob:(nanopb::MakeByteString(concatData))].release();
 
-  return std::move(result);
+    return std::move(result);
+  } else {
+    return [self encodeBlob:(nanopb::MakeByteString(blob.bytes))];
+  }
 }
 
 - (Message<google_firestore_v1_Value>)parseArray:(NSArray<id> *)array
@@ -747,9 +750,9 @@ - (void)parseSentinelFieldValue:(FIRFieldValue *)fieldValue context:(ParseContex
   } else if ([input isKindOfClass:[FIRBSONTimestamp class]]) {
     FIRBSONTimestamp *timestamp = input;
     return [self parseBsonTimestamp:timestamp context:std::move(context)];
-  } else if ([input isKindOfClass:[FIRBSONBinaryData class]]) {
-    FIRBSONBinaryData *binaryData = input;
-    return [self parseBsonBinaryData:binaryData context:std::move(context)];
+  } else if ([input isKindOfClass:[FIRBlob class]]) {
+    FIRBlob *blob = input;
+    return [self parseBlob:blob context:std::move(context)];
   } else {
     ThrowInvalidArgument("Unsupported type: %s%s", NSStringFromClass([input class]),
                          context.FieldDescription());

Firestore/Source/API/FIRBlob.m

@@ -23,9 +23,9 @@
 #include "Firestore/Source/API/FIRDocumentReference+Internal.h"
 #include "Firestore/Source/API/FIRFieldValue+Internal.h"
 #include "Firestore/Source/API/converters.h"
-#include "Firestore/Source/Public/FirebaseFirestore/FIRBSONBinaryData.h"
 #include "Firestore/Source/Public/FirebaseFirestore/FIRBSONObjectId.h"
 #include "Firestore/Source/Public/FirebaseFirestore/FIRBSONTimestamp.h"
+#include "Firestore/Source/Public/FirebaseFirestore/FIRBlob.h"
 #include "Firestore/Source/Public/FirebaseFirestore/FIRDecimal128Value.h"
 #include "Firestore/Source/Public/FirebaseFirestore/FIRInt32Value.h"
 #include "Firestore/Source/Public/FirebaseFirestore/FIRMaxKey.h"
@@ -256,7 +256,7 @@ - (FIRBSONTimestamp *)convertedBsonTimestamp:(const google_firestore_v1_MapValue
   return [[FIRBSONTimestamp alloc] initWithSeconds:seconds increment:increment];
 }
 
-- (FIRBSONBinaryData *)convertedBsonBinaryData:(const google_firestore_v1_MapValue &)mapValue {
+- (FIRBlob *)convertedBsonBinaryData:(const google_firestore_v1_MapValue &)mapValue {
   uint8_t subtype = 0;
   NSData *data = [[NSData alloc] init];
 
@@ -275,7 +275,7 @@ - (FIRBSONBinaryData *)convertedBsonBinaryData:(const google_firestore_v1_MapVal
     }
   }
 
-  return [[FIRBSONBinaryData alloc] initWithSubtype:subtype data:data];
+  return [FIRBlob blobWithBSONBinary:data subtype:subtype];
 }
 
 - (NSArray<id> *)convertedArray:(const google_firestore_v1_ArrayValue &)arrayValue {