clean up internal continue

Author: rwoll

playwright/_impl/_browser_context.py

@@ -171,7 +171,7 @@ async def inner_route() -> None:
                         asyncio.create_task(self._disable_interception())
                 if handled:
                     return
-            route._internal_continue()
+            await route._internal_continue(is_internal=True)
 
         asyncio.create_task(inner_route())
 

playwright/_impl/_network.py

@@ -315,63 +315,58 @@ async def continue_(
         headers: Dict[str, str] = None,
         postData: Union[str, bytes] = None,
     ) -> None:
+        overrides = cast(FallbackOverrideParameters, locals_to_params(locals()))
         # FIXME: This is getting triggered when it shouldn't be
         # self._check_not_handled()
-        overrides: FallbackOverrideParameters = {}
-        if url:
-            overrides["url"] = url
-        if method:
-            overrides["method"] = method
-        if headers:
-            overrides["headers"] = headers
-        if postData:
-            overrides["postData"] = postData
-
-        # 1. request.url et. al. may be called after contine by user and it should reflect the overrides
-        # 2. existing overrides should be used when continueing
         self.request._apply_fallback_overrides(overrides)
-
-        post_data_for_wire: Optional[str] = None
-        post_data_from_overrides = self.request._fallback_overrides.get("postData")
-        if post_data_from_overrides is not None:
-            post_data_for_wire = (
-                base64.b64encode(post_data_from_overrides.encode()).decode()
-                if isinstance(post_data_from_overrides, str)
-                else base64.b64encode(post_data_from_overrides).decode()
-            )
-        await self._race_with_page_close(
-            self._channel.send(
-                "continue",
-                cast(
-                    Any,
-                    locals_to_params(
-                        {
-                            "url": self.request._fallback_overrides.get("url"),
-                            "method": self.request._fallback_overrides.get("method"),
-                            "headers": serialize_headers(
-                                cast(
-                                    Dict[str, str],
-                                    self.request._fallback_overrides["headers"],
-                                )
-                            )
-                            if self.request._fallback_overrides.get("headers")
-                            else None,
-                            "postData": post_data_for_wire,
-                        }
-                    ),
-                ),
-            )
-        )
+        await self._internal_continue()
         self._report_handled(True)
 
-    def _internal_continue(self) -> None:
+    def _internal_continue(
+        self, is_internal: bool = False
+    ) -> Coroutine[Any, Any, None]:
         async def continue_route() -> None:
             try:
-                await self.continue_()
-            except Exception:
-                pass
-
-        asyncio.create_task(continue_route())
+                post_data_for_wire: Optional[str] = None
+                post_data_from_overrides = self.request._fallback_overrides.get(
+                    "postData"
+                )
+                if post_data_from_overrides is not None:
+                    post_data_for_wire = (
+                        base64.b64encode(post_data_from_overrides.encode()).decode()
+                        if isinstance(post_data_from_overrides, str)
+                        else base64.b64encode(post_data_from_overrides).decode()
+                    )
+                await self._race_with_page_close(
+                    self._channel.send(
+                        "continue",
+                        cast(
+                            Any,
+                            locals_to_params(
+                                {
+                                    "url": self.request._fallback_overrides.get("url"),
+                                    "method": self.request._fallback_overrides.get(
+                                        "method"
+                                    ),
+                                    "headers": serialize_headers(
+                                        cast(
+                                            Dict[str, str],
+                                            self.request._fallback_overrides["headers"],
+                                        )
+                                    )
+                                    if self.request._fallback_overrides.get("headers")
+                                    else None,
+                                    "postData": post_data_for_wire,
+                                }
+                            ),
+                        ),
+                    )
+                )
+            except Exception as e:
+                if not is_internal:
+                    raise e
+
+        return continue_route()
 
     # FIXME: Port corresponding tests, and call this method
     async def _redirected_navigation_request(self, url: str) -> None: