Use workaround to fix double free error

Author: cherylEnkidu

Firestore/Example/Firestore.xcodeproj/xcshareddata/xcschemes/Firestore_IntegrationTests_iOS.xcscheme

@@ -27,6 +27,7 @@
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
       shouldUseLaunchSchemeArgsEnv = "YES"
+      enableAddressSanitizer = "YES"
       enableASanStackUseAfterReturn = "YES">
       <MacroExpansion>
          <BuildableReference
@@ -37,6 +38,13 @@
             ReferencedContainer = "container:Firestore.xcodeproj">
          </BuildableReference>
       </MacroExpansion>
+      <AdditionalOptions>
+         <AdditionalOption
+            key = "NSZombieEnabled"
+            value = "YES"
+            isEnabled = "YES">
+         </AdditionalOption>
+      </AdditionalOptions>
       <Testables>
          <TestableReference
             skipped = "NO">

Firestore/Source/API/FIRCallbackWrapper.mm

@@ -34,22 +34,26 @@
 
 @implementation FIRCallbackWrapper
 
+// In public Swift documentation for integrating Swift and C++, using raw pointers in C++ is
+// generally considered unsafe. However, during an experiment where the result was passed as a value
+// instead of a pointer, a double free error occurred. This issue could not be traced effectively
+// because the implementation resides within the Swift-C++ transition layer. In this specific use
+// case, the C++ OnEvent() scope is destroyed after the Swift callback has been destroyed. Due to
+// this ordering, using a raw pointer is a safe workaround for now.
 + (PipelineSnapshotListener)wrapPipelineCallback:(std::shared_ptr<api::Firestore>)firestore
-                                      completion:(void (^)(PipelineResultVector result,
+                                      completion:(void (^)(CppPipelineResult *_Nullable result,
                                                            NSError *_Nullable error))completion {
-  class Converter : public EventListener<std::vector<PipelineResult>> {
+  class Converter : public EventListener<CppPipelineResult> {
    public:
     explicit Converter(std::shared_ptr<api::Firestore> firestore, PipelineBlock completion)
         : firestore_(firestore), completion_(completion) {
     }
 
-    void OnEvent(StatusOr<std::vector<PipelineResult>> maybe_snapshot) override {
+    void OnEvent(StatusOr<CppPipelineResult> maybe_snapshot) override {
       if (maybe_snapshot.ok()) {
-        completion_(
-            std::initializer_list<PipelineResult>{PipelineResult::GetTestResult(firestore_)},
-            nullptr);
+        completion_(&maybe_snapshot.ValueOrDie(), nullptr);
       } else {
-        completion_(std::initializer_list<PipelineResult>{}, MakeNSError(maybe_snapshot.status()));
+        completion_(nullptr, MakeNSError(maybe_snapshot.status()));
       }
     }
 
@@ -58,7 +62,7 @@ void OnEvent(StatusOr<std::vector<PipelineResult>> maybe_snapshot) override {
     PipelineBlock completion_;
   };
 
-  return absl::make_unique<Converter>(firestore, completion);
+  return std::make_shared<Converter>(firestore, completion);
 }
 
 @end

Firestore/Source/Public/FirebaseFirestore/FIRCallbackWrapper.h

@@ -38,10 +38,10 @@ namespace core = firebase::firestore::core;
 
 NS_ASSUME_NONNULL_BEGIN
 
-typedef void (^PipelineBlock)(std::vector<api::PipelineResult> result, NSError *_Nullable error)
-    NS_SWIFT_UNAVAILABLE("Use Swift's closure syntax instead.");
+typedef api::PipelineResult CppPipelineResult;
 
-typedef std::vector<api::PipelineResult> PipelineResultVector;
+typedef void (^PipelineBlock)(CppPipelineResult *_Nullable result, NSError *_Nullable error)
+    NS_SWIFT_UNAVAILABLE("Use Swift's closure syntax instead.");
 
 NS_SWIFT_SENDABLE
 NS_SWIFT_NAME(CallbackWrapper)
@@ -51,9 +51,9 @@ NS_SWIFT_NAME(CallbackWrapper)
 // are invoked on a different thread than the one they were originally defined in. If this callback
 // is expected to be called on a different thread, it should be marked as `Sendable` to ensure
 // thread safety.
-+ (std::shared_ptr<core::EventListener<std::vector<api::PipelineResult>>>)
++ (std::shared_ptr<core::EventListener<api::PipelineResult>>)
     wrapPipelineCallback:(std::shared_ptr<api::Firestore>)firestore
-              completion:(void (^NS_SWIFT_SENDABLE)(PipelineResultVector result,
+              completion:(void (^NS_SWIFT_SENDABLE)(CppPipelineResult *_Nullable result,
                                                     NSError *_Nullable error))completion
     NS_SWIFT_NAME(wrapPipelineCallback(firestore:completion:));
 

Firestore/Swift/Source/SwiftAPI/Pipeline.swift

@@ -29,15 +29,14 @@ public struct Pipeline {
   }
 
   @discardableResult
-  public func GetPipelineResult() async throws -> [PipelineResult] {
+  public func GetPipelineResult() async throws -> PipelineResult {
     return try await withCheckedThrowingContinuation { continuation in
       let listener = CallbackWrapper.wrapPipelineCallback(firestore: cppObj.GetFirestore()) {
         result, error in
         if let error {
           continuation.resume(throwing: error)
         } else {
-          // Our callbacks guarantee that we either return an error or a progress event.
-          continuation.resume(returning: PipelineResult.convertToArrayFromCppVector(result))
+          continuation.resume(returning: PipelineResult(result!.pointee))
         }
       }
       cppObj.GetPipelineResult(listener)

Firestore/Swift/Source/SwiftAPI/PipelineResult.swift

@@ -24,15 +24,15 @@ public struct PipelineResult {
     cppObj = cppSource
   }
 
-  static func convertToArrayFromCppVector(_ vector: PipelineResultVector)
+  static func convertToArrayFromCppVector(_ vector: CppPipelineResult)
     -> [PipelineResult] {
     // Create a Swift array and populate it by iterating over the C++ vector
     var swiftArray: [PipelineResult] = []
 
-    for index in vector.indices {
-      let cppResult = vector[index]
-      swiftArray.append(PipelineResult(cppResult))
-    }
+//    for index in vector.indices {
+//      let cppResult = vector[index]
+//      swiftArray.append(PipelineResult(cppResult))
+//    }
 
     return swiftArray
   }

Firestore/Swift/Tests/Integration/PipelineTests.swift

@@ -21,6 +21,6 @@ final class PipelineTests: FSTIntegrationTestCase {
   func testCreatePipeline() async throws {
     let pipelineSource: PipelineSource = db.pipeline()
     let pipeline: Pipeline = pipelineSource.GetCollection("path")
-    let _: [PipelineResult] = try await pipeline.GetPipelineResult()
+    let _ = try await pipeline.GetPipelineResult()
   }
 }

Firestore/core/interfaceForSwift/api/pipeline.cc

@@ -45,8 +45,10 @@ void Pipeline::GetPipelineResult(PipelineSnapshotListener callback) const {
       /*include_document_metadata_changes=*/true,
       /*wait_for_sync_when_online=*/true);
 
-  callback->OnEvent(StatusOr<std::vector<PipelineResult>>(
-      {(PipelineResult::GetTestResult(firestore_))}));
+  PipelineResult sample = PipelineResult::GetTestResult(firestore_);
+
+  StatusOr<PipelineResult> res(sample);
+  callback->OnEvent(res);
 
   //  class ListenOnce : public EventListener<std::vector<PipelineResult>> {
   //   public:

Firestore/core/interfaceForSwift/api/pipeline.h

@@ -35,7 +35,7 @@ class Firestore;
 class PipelineResult;
 
 using PipelineSnapshotListener =
-    std::shared_ptr<core::EventListener<std::vector<PipelineResult>>>;
+    std::shared_ptr<core::EventListener<PipelineResult>>;
 
 class Pipeline {
  public:

Firestore/core/interfaceForSwift/api/pipeline_result.cc

@@ -12,8 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "Firestore/core/interfaceForSwift/api/pipeline_result.h"
+#include <iostream>
+
 #include "Firestore/core/include/firebase/firestore/timestamp.h"
+#include "Firestore/core/interfaceForSwift/api/pipeline_result.h"
 
 namespace firebase {
 namespace firestore {