Clean up some of the un needed changes

Author: AustinBenoit

analytics/src/analytics_common.h

@@ -24,7 +24,7 @@ namespace analytics {
 namespace internal {
 
 enum AnalyticsFn {
-  kAnalyticsFnGetAnalyticsInstanceId = 0,
+  kAnalyticsFnGetAnalyticsInstanceId,
   kAnalyticsFnGetSessionId,
   kAnalyticsFnLogAppleTransaction,
   kAnalyticsFnCount,

analytics/src/analytics_ios.mm

@@ -273,8 +273,7 @@ void CompleteLogAppleTransaction(const void* context, bool success) {
   // We capture the C++ handle_ptr inside the Objective-C block. Swift never sees it.
   [AppleTransactionVerifier verifyWithTransactionId:SafeString(transaction_id) 
                                        completion:^(BOOL isFound) {
-      // 3. We are back in C++ land on the Main Thread. 
-      // Call your completion logic directly.
+      // 3. We are back in C++ land. Call your completion logic directly.
       CompleteLogAppleTransaction(handle_ptr, isFound == YES);
   }];
 

analytics/src/ios/swift/AppleTransactionVerifier.swift

@@ -16,57 +16,25 @@ import Foundation
 import StoreKit
 import FirebaseAnalytics
 
-// Pure Swift worker to prevent compiler generation bugs with witness tables 
-// when mixing @objc and Swift Concurrency on older iOS deployment targets.
-@available(iOS 15.0, tvOS 15.0, macOS 12.0, watchOS 8.0, *)
-internal struct AppleTransactionWorker {
-    static func findAndLogTransaction(id: String) async -> Bool {
-        // Using a standard while loop instead of `for await` avoids a known 
-        // Xcode 15+ compiler bug where corrupted witness tables are generated 
-        // for AsyncSequences when targeting iOS 15/16.
-        var iterator = Transaction.all.makeAsyncIterator()
-        while let verificationResult = await iterator.next() {
-            if case .verified(let transaction) = verificationResult {
-                if String(transaction.id) == id {
-                    Analytics.logTransaction(transaction)
-                    return true
-                }
-            }
-        }
-        return false
-    }
-}
-
 @objc public class AppleTransactionVerifier: NSObject {
 
-    // Notice: To avoid C-pointer ABI layout issues across Swift boundaries, 
-    // this interface relies purely on a standard Swift closure. The calling 
-    // C++ layer captures any necessary pointers within an Objective-C block.
     @objc public static func verify(transactionId: String, completion: @escaping @Sendable (Bool) -> Void) {
         if #available(iOS 15.0, tvOS 15.0, macOS 12.0, watchOS 8.0, *) {
-            // Create a pure Swift String copy of the transaction ID.
-            // This ensures we do not rely on the memory of the bridged Objective-C
-            // NSString, which might be destroyed by the calling C++ thread before
-            // the asynchronous Task completes.
-            let safeId = String(transactionId)
-            
-            // Use a detached task to avoid inheriting any C++/ObjC thread context.
-            // This prevents EXC_BAD_ACCESS during `swift_task_alloc` on iOS 15/16.
-            Task.detached(priority: .userInitiated) { [safeId, completion] in
-                let isFound = await AppleTransactionWorker.findAndLogTransaction(id: safeId)
-                
-                // Return to the main thread to ensure thread safety when the C++ 
-                // layer receives the callback and manages internal state.
-                DispatchQueue.main.async {
-                    completion(isFound)
+            Task {
+                var iterator = Transaction.all.makeAsyncIterator()
+                while let verificationResult = await iterator.next() {
+                    if case .verified(let transaction) = verificationResult {
+                        if String(transaction.id) == transactionId {
+                            Analytics.logTransaction(transaction)
+                            completion(true)
+                            return
+                        }
+                    }
                 }
-            }
-        } else {
-            // Not on a supported OS, resolve immediately on the main thread 
-            // to avoid potential deadlocks if called while holding a C++ mutex.
-            DispatchQueue.main.async {
                 completion(false)
             }
+        } else {
+            completion(false)
         }
     }
 }

app/src/secure/user_secure_fake_internal.cc

@@ -29,7 +29,6 @@
 #include <errno.h>
 
 #include <cstdio>
-#include <cstring>
 #include <fstream>
 #include <string>