[Functions] Remove completion-handler based internal logic (#15058)

Author: ncooke3

FirebaseFunctions/Sources/Functions.swift

@@ -438,30 +438,6 @@ enum FunctionsConstants {
     }
   }
 
-  func callFunction(at url: URL,
-                    withObject data: Any?,
-                    options: HTTPSCallableOptions?,
-                    timeout: TimeInterval,
-                    completion: @escaping @MainActor (Result<HTTPSCallableResult, Error>) -> Void) {
-    // Get context first.
-    contextProvider.getContext(options: options) { context, error in
-      // Note: context is always non-nil since some checks could succeed, we're only failing if
-      // there's an error.
-      if let error {
-        DispatchQueue.main.async {
-          completion(.failure(error))
-        }
-      } else {
-        self.callFunction(url: url,
-                          withObject: data,
-                          options: options,
-                          timeout: timeout,
-                          context: context,
-                          completion: completion)
-      }
-    }
-  }
-
   private func callFunction(url: URL,
                             withObject data: Any?,
                             options: HTTPSCallableOptions?,

FirebaseFunctions/Sources/HTTPSCallable.swift

@@ -184,34 +184,12 @@ private extension HTTPSCallable {
     func call(_ data: sending Any? = nil,
               completion: @escaping @MainActor (HTTPSCallableResult?, Error?) -> Void) {
       let data = (data as? SendableWrapper)?.value ?? data
-      if #available(iOS 13, macCatalyst 13, macOS 10.15, tvOS 13, watchOS 7, *) {
-        Task {
-          do {
-            let result = try await call(data)
-            await completion(result, nil)
-          } catch {
-            await completion(nil, error)
-          }
-        }
-      } else {
-        // This isn’t expected to ever be called because Functions
-        // doesn’t officially support the older platforms.
-        functions.callFunction(
-          at: url,
-          withObject: data,
-          options: options,
-          timeout: timeoutInterval
-        ) { result in
-          switch result {
-          case let .success(callableResult):
-            DispatchQueue.main.async {
-              completion(callableResult, nil)
-            }
-          case let .failure(error):
-            DispatchQueue.main.async {
-              completion(nil, error)
-            }
-          }
+      Task {
+        do {
+          let result = try await call(data)
+          await completion(result, nil)
+        } catch {
+          await completion(nil, error)
         }
       }
     }

FirebaseFunctions/Sources/Internal/FunctionsContext.swift

@@ -82,56 +82,4 @@ struct FunctionsContextProvider: Sendable {
       }
     }
   }
-
-  func getContext(options: HTTPSCallableOptions? = nil,
-                  _ completion: @escaping ((FunctionsContext, Error?) -> Void)) {
-    let dispatchGroup = DispatchGroup()
-
-    var authToken: String?
-    var appCheckToken: String?
-    var error: Error?
-    var limitedUseAppCheckToken: String?
-
-    if let auth {
-      dispatchGroup.enter()
-
-      auth.getToken(forcingRefresh: false) { token, authError in
-        authToken = token
-        error = authError
-        dispatchGroup.leave()
-      }
-    }
-
-    if let appCheck {
-      dispatchGroup.enter()
-
-      if options?.requireLimitedUseAppCheckTokens == true {
-        // `getLimitedUseToken(completion:)` is an optional protocol method.
-        // If it’s not implemented, we still need to leave the dispatch group.
-        if let limitedUseTokenClosure = appCheck.getLimitedUseToken {
-          limitedUseTokenClosure { tokenResult in
-            // In the case of an error, the token will be the placeholder token.
-            limitedUseAppCheckToken = tokenResult.token
-            dispatchGroup.leave()
-          }
-        } else {
-          dispatchGroup.leave()
-        }
-      } else {
-        appCheck.getToken(forcingRefresh: false) { tokenResult in
-          // In the case of an error, the token will be the placeholder token.
-          appCheckToken = tokenResult.token
-          dispatchGroup.leave()
-        }
-      }
-    }
-
-    dispatchGroup.notify(queue: .main) {
-      let context = FunctionsContext(authToken: authToken,
-                                     fcmToken: self.messaging?.fcmToken,
-                                     appCheckToken: appCheckToken,
-                                     limitedUseAppCheckToken: limitedUseAppCheckToken)
-      completion(context, error)
-    }
-  }
 }

FirebaseFunctions/Tests/CombineUnit/HTTPSCallableTests.swift

@@ -40,25 +40,6 @@ class MockFunctions: Functions, @unchecked Sendable {
     return try mockCallFunction()
   }
 
-  override func callFunction(at url: URL,
-                             withObject data: Any?,
-                             options: HTTPSCallableOptions?,
-                             timeout: TimeInterval,
-                             completion: @escaping @MainActor
-                             (Result<HTTPSCallableResult, any Error>) -> Void) {
-    do {
-      try verifyParameters?(url, data, timeout)
-      let result = try mockCallFunction()
-      DispatchQueue.main.async {
-        completion(.success(result))
-      }
-    } catch {
-      DispatchQueue.main.async {
-        completion(.failure(error))
-      }
-    }
-  }
-
   init(mockCallFunction: @escaping () throws -> HTTPSCallableResult) {
     self.mockCallFunction = mockCallFunction
     super.init(