@capgo/capacitor-inappbrowser 8.6.15 → 8.6.16

package/android/src/main/java/ee/forgr/capacitor_inappbrowser/InAppBrowserPlugin.java

@@ -63,7 +63,7 @@ import org.json.JSONObject;
 )
 public class InAppBrowserPlugin extends Plugin implements WebViewDialog.PermissionHandler {
 
-    private final String pluginVersion = "8.6.15";
+    private final String pluginVersion = "8.6.16";
 
     public static final String CUSTOM_TAB_PACKAGE_NAME = "com.android.chrome"; // Change when in stable
     private CustomTabsClient customTabsClient;

package/ios/Sources/InAppBrowserPlugin/InAppBrowserPlugin.swift

@@ -77,7 +77,7 @@ public class InAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
         case aware = "AWARE"
         case fakeVisible = "FAKE_VISIBLE"
     }
-    private let pluginVersion: String = "8.6.15"
+    private let pluginVersion: String = "8.6.16"
     public let identifier = "InAppBrowserPlugin"
     public let jsName = "InAppBrowser"
     public let pluginMethods: [CAPPluginMethod] = [

package/ios/Sources/InAppBrowserPlugin/ProxySchemeHandler.swift

@@ -403,6 +403,7 @@ enum ProxySchemeRequestSupport {
 }
 
 final class PendingProxyTask {
+    let requestId: String
     let schemeTask: WKURLSchemeTask
     var requestContext: NativeRequestContext
     var responseData: NativeResponseData?
@@ -411,12 +412,32 @@ final class PendingProxyTask {
     var redirectRequest: URLRequest?
     var timeoutToken: UUID?
     var canceled = false
-
-    init(schemeTask: WKURLSchemeTask, requestContext: NativeRequestContext, phase: String) {
+    /// Set true when WebKit calls `webView(_:stop:)` for this task. Once stopped,
+    /// the `WKURLSchemeTask` must never receive `didReceive`/`didFinish`/`didFailWithError`
+    /// again or WebKit raises an uncatchable NSException.
+    var isStopped = false
+    /// Set true the first time a terminal scheme-task call sequence is committed.
+    /// Guarantees at-most-once completion even when multiple async sources
+    /// (URLSession delegate queue, cookie-sync main hop, global timeout, cancel-all)
+    /// race to finish the same request.
+    private var isComplete = false
+
+    init(requestId: String, schemeTask: WKURLSchemeTask, requestContext: NativeRequestContext, phase: String) {
+        self.requestId = requestId
         self.schemeTask = schemeTask
         self.requestContext = requestContext
         self.phase = phase
     }
+
+    /// Claims the right to issue the single allowed terminal call sequence on the
+    /// scheme task. Returns true exactly once, and only while the task is live
+    /// (not stopped). Callers MUST hold the handler's `taskLock` so the claim is
+    /// atomic with respect to `webView(_:stop:)` marking the task stopped.
+    func beginCompletionIfLive() -> Bool {
+        if isComplete || isStopped { return false }
+        isComplete = true
+        return true
+    }
 }
 
 // swiftlint:disable type_body_length
@@ -491,7 +512,7 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
             base64Body: extractBody(from: urlSchemeTask.request),
             isMainFrame: ProxySchemeRequestSupport.isMainFrameRequest(urlSchemeTask.request)
         )
-        let pendingTask = PendingProxyTask(schemeTask: urlSchemeTask, requestContext: requestContext, phase: "outbound")
+        let pendingTask = PendingProxyTask(requestId: requestId, schemeTask: urlSchemeTask, requestContext: requestContext, phase: "outbound")
 
         taskLock.lock()
         pendingTasks[requestId] = pendingTask
@@ -503,6 +524,7 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
     public func webView(_ webView: WKWebView, stop urlSchemeTask: WKURLSchemeTask) {
         taskLock.lock()
         if let entry = pendingTasks.first(where: { $0.value.schemeTask === urlSchemeTask }) {
+            entry.value.isStopped = true
             pendingTasks.removeValue(forKey: entry.key)
             let cleanupToken = UUID()
             stoppedRequests[entry.key] = cleanupToken
@@ -573,7 +595,6 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
 
         if pendingTask.canceled {
             finishWithCanceledResponse(task: pendingTask)
-            removePendingTask(requestId: requestId)
             return
         }
 
@@ -583,7 +604,6 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
         ) {
         case .finishCachedResponse:
             guard let responseData = pendingTask.responseData else { return }
-            removePendingTask(requestId: requestId)
             syncResponseCookies(from: responseData, fallbackURL: pendingTask.requestContext.url) {
                 self.finish(task: pendingTask, with: responseData)
             }
@@ -600,14 +620,14 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
         do {
             request = try makeURLRequest(from: pendingTask.requestContext)
         } catch {
-            pendingTask.schemeTask.didFailWithError(
-                NSError(
+            failSchemeTask(
+                pendingTask,
+                with: NSError(
                     domain: "ProxySchemeHandler",
                     code: -3,
                     userInfo: [NSLocalizedDescriptionKey: error.localizedDescription]
                 )
             )
-            removePendingTask(requestId: requestId)
             return
         }
         let task = session.dataTask(with: request) { [weak self] data, response, error in
@@ -615,13 +635,18 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
             guard let pendingTask = self.pendingTask(for: requestId) else { return }
 
             if let error {
-                if (error as NSError).code == NSURLErrorCancelled, pendingTask.redirectRequest != nil {
+                if (error as NSError).code == NSURLErrorCancelled {
+                    // The data task is only canceled by webView(_:stop:) or
+                    // cancelAllPendingTasks(), and both own the task's lifecycle: stop has
+                    // already removed it (and marked it stopped) before canceling, while
+                    // cancelAll routes a terminal failSchemeTask through completeSchemeTask,
+                    // which removes it on the main queue. Removing it here on the URLSession
+                    // background queue would unhook it from pendingTasks before a racing
+                    // stop could mark it stopped, reopening the post-stop completion crash.
+                    // So just stop processing and let the owning path complete it.
                     return
                 }
-                if (error as NSError).code != NSURLErrorCancelled {
-                    pendingTask.schemeTask.didFailWithError(error)
-                }
-                self.removePendingTask(requestId: requestId)
+                self.failSchemeTask(pendingTask, with: error)
                 return
             }
 
@@ -680,13 +705,11 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
             switch inboundRule.action {
             case .cancel:
                 finishWithCanceledResponse(task: pendingTask)
-                removePendingTask(requestId: requestId)
             case .continue:
                 if pendingTask.redirectRequest != nil {
                     followPendingRedirect(requestId: requestId)
                 } else {
                     finish(task: pendingTask, with: responseData)
-                    removePendingTask(requestId: requestId)
                 }
             case .delegateToJs:
                 emitProxyEvent(requestId: requestId, pendingTask: pendingTask)
@@ -697,7 +720,6 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
                 followPendingRedirect(requestId: requestId)
             } else {
                 finish(task: pendingTask, with: responseData)
-                removePendingTask(requestId: requestId)
             }
         }
     }
@@ -759,7 +781,6 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
                 self.fallbackToNativePipeline(requestId: requestId)
                 return
             case .finishCachedResponse:
-                self.pendingTasks.removeValue(forKey: requestId)
                 self.taskLock.unlock()
                 guard let responseData else { return }
                 self.syncResponseCookies(from: responseData, fallbackURL: pendingTask.requestContext.url) {
@@ -767,12 +788,12 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
                 }
                 return
             case .failRequest:
-                self.pendingTasks.removeValue(forKey: requestId)
                 self.taskLock.unlock()
             }
 
-            pendingTask.schemeTask.didFailWithError(
-                NSError(
+            self.failSchemeTask(
+                pendingTask,
+                with: NSError(
                     domain: "ProxySchemeHandler",
                     code: NSURLErrorTimedOut,
                     userInfo: [NSLocalizedDescriptionKey: "Proxy handler did not respond within \(Int(self.proxyTimeoutSeconds)) seconds"]
@@ -825,14 +846,6 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
         return task
     }
 
-    private func removePendingTask(requestId: String) {
-        taskLock.lock()
-        pendingTasks.removeValue(forKey: requestId)
-        stoppedRequests.removeValue(forKey: requestId)
-        timedOutRequests.removeValue(forKey: requestId)
-        taskLock.unlock()
-    }
-
     private func routeCurrentRequest(requestId: String) {
         guard let pendingTask = pendingTask(for: requestId) else { return }
         pendingTask.phase = "outbound"
@@ -842,7 +855,6 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
             switch outboundRule.action {
             case .cancel:
                 finishWithCanceledResponse(task: pendingTask)
-                removePendingTask(requestId: requestId)
             case .continue:
                 executeNativePipeline(requestId: requestId)
             case .delegateToJs:
@@ -1022,27 +1034,73 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
         )
     }
 
+    /// Runs a terminal `WKURLSchemeTask` call sequence at most once, and never after
+    /// the task has been stopped.
+    ///
+    /// `WKURLSchemeTask` raises an uncatchable NSException if `didReceive`/`didFinish`/
+    /// `didFailWithError` is called after `webView(_:stop:)`, after the task already
+    /// completed, or out of order. Completion can be triggered from several racing
+    /// sources — the URLSession delegate queue, the cookie-sync main-thread hop, the
+    /// global timeout closure, `webView(_:stop:)`, and `cancelAllPendingTasks()`. This
+    /// helper funnels every terminal call onto the main thread (the same queue WebKit
+    /// uses for `start`/`stop`) and gates it behind `beginCompletionIfLive()`, so the
+    /// liveness check and the actual call cannot be separated by a `stop`.
+    ///
+    /// This helper is also the single owner of task removal. Callers MUST NOT remove
+    /// the task from `pendingTasks` eagerly on a background thread before calling a
+    /// terminal method: doing so creates a window where `webView(_:stop:)` (which only
+    /// finds tasks via `pendingTasks`) can no longer mark the task stopped, so a queued
+    /// completion would then call `didReceive`/`didFinish`/`didFailWithError` on an
+    /// already-stopped task and crash. Keeping the task tracked until this main-queue
+    /// block runs lets a racing `stop` win the liveness claim.
+    private func completeSchemeTask(_ task: PendingProxyTask, _ body: @escaping (WKURLSchemeTask) -> Void) {
+        let runBody: () -> Void = { [weak self] in
+            guard let self else { return }
+            self.taskLock.lock()
+            let isLive = task.beginCompletionIfLive()
+            self.pendingTasks.removeValue(forKey: task.requestId)
+            self.stoppedRequests.removeValue(forKey: task.requestId)
+            self.timedOutRequests.removeValue(forKey: task.requestId)
+            self.taskLock.unlock()
+            guard isLive else { return }
+            body(task.schemeTask)
+        }
+        if Thread.isMainThread {
+            runBody()
+        } else {
+            DispatchQueue.main.async(execute: runBody)
+        }
+    }
+
+    private func failSchemeTask(_ task: PendingProxyTask, with error: Error) {
+        completeSchemeTask(task) { schemeTask in
+            schemeTask.didFailWithError(error)
+        }
+    }
+
     private func finish(task: PendingProxyTask, with responseData: NativeResponseData) {
-        guard let url = URL(string: task.requestContext.url),
-              let httpResponse = HTTPURLResponse(
-                url: url,
-                statusCode: responseData.statusCode,
-                httpVersion: "HTTP/1.1",
-                headerFields: responseData.headers
-              )
-        else {
-            task.schemeTask.didFailWithError(
-                NSError(
-                    domain: "ProxySchemeHandler",
-                    code: -2,
-                    userInfo: [NSLocalizedDescriptionKey: "Failed to create response"]
+        completeSchemeTask(task) { schemeTask in
+            guard let url = URL(string: task.requestContext.url),
+                  let httpResponse = HTTPURLResponse(
+                    url: url,
+                    statusCode: responseData.statusCode,
+                    httpVersion: "HTTP/1.1",
+                    headerFields: responseData.headers
+                  )
+            else {
+                schemeTask.didFailWithError(
+                    NSError(
+                        domain: "ProxySchemeHandler",
+                        code: -2,
+                        userInfo: [NSLocalizedDescriptionKey: "Failed to create response"]
+                    )
                 )
-            )
-            return
+                return
+            }
+            schemeTask.didReceive(httpResponse)
+            schemeTask.didReceive(responseData.body)
+            schemeTask.didFinish()
         }
-        task.schemeTask.didReceive(httpResponse)
-        task.schemeTask.didReceive(responseData.body)
-        task.schemeTask.didFinish()
     }
 
     private func finishWithCanceledResponse(task: PendingProxyTask) {
@@ -1138,15 +1196,19 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
     func cancelAllPendingTasks() {
         taskLock.lock()
         let pending = pendingTasks
-        pendingTasks.removeAll()
+        // Do not clear pendingTasks here. completeSchemeTask removes each task on the
+        // main queue once its failure is claimed, so a concurrent webView(_:stop:) can
+        // still find and mark the task stopped before the queued failure runs. Clearing
+        // eagerly would reopen the post-stop completion crash this fix closes.
         stoppedRequests.removeAll()
         taskLock.unlock()
         session.invalidateAndCancel()
 
         for (_, task) in pending {
             task.urlSessionTask?.cancel()
-            task.schemeTask.didFailWithError(
-                NSError(
+            failSchemeTask(
+                task,
+                with: NSError(
                     domain: "ProxySchemeHandler",
                     code: NSURLErrorCancelled,
                     userInfo: [NSLocalizedDescriptionKey: "WebView closed"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-inappbrowser",
-  "version": "8.6.15",
+  "version": "8.6.16",
   "description": "Capacitor plugin in app browser",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",