chore: explicit timeout config for send

playwright/_impl/_accessibility.py

@@ -65,5 +65,5 @@ async def snapshot(
         params = locals_to_params(locals())
         if root:
             params["root"] = root._channel
-        result = await self._channel.send("accessibilitySnapshot", params)
+        result = await self._channel.send("accessibilitySnapshot", None, params)
         return _ax_node_from_protocol(result) if result else None

playwright/_impl/_artifact.py

@@ -33,27 +33,55 @@ async def path_after_finished(self) -> pathlib.Path:
             raise Error(
                 "Path is not available when using browser_type.connect(). Use save_as() to save a local copy."
             )
-        path = await self._channel.send("pathAfterFinished")
+        path = await self._channel.send(
+            "pathAfterFinished",
+            None,
+        )
         return pathlib.Path(path)
 
     async def save_as(self, path: Union[str, Path]) -> None:
-        stream = cast(Stream, from_channel(await self._channel.send("saveAsStream")))
+        stream = cast(
+            Stream,
+            from_channel(
+                await self._channel.send(
+                    "saveAsStream",
+                    None,
+                )
+            ),
+        )
         make_dirs_for_file(path)
         await stream.save_as(path)
 
     async def failure(self) -> Optional[str]:
-        reason = await self._channel.send("failure")
+        reason = await self._channel.send(
+            "failure",
+            None,
+        )
         if reason is None:
             return None
         return patch_error_message(reason)
 
     async def delete(self) -> None:
-        await self._channel.send("delete")
+        await self._channel.send(
+            "delete",
+            None,
+        )
 
     async def read_info_buffer(self) -> bytes:
-        stream = cast(Stream, from_channel(await self._channel.send("stream")))
+        stream = cast(
+            Stream,
+            from_channel(
+                await self._channel.send(
+                    "stream",
+                    None,
+                )
+            ),
+        )
         buffer = await stream.read_all()
         return buffer
 
     async def cancel(self) -> None:  # pyright: ignore[reportIncompatibleMethodOverride]
-        await self._channel.send("cancel")
+        await self._channel.send(
+            "cancel",
+            None,
+        )

playwright/_impl/_browser.py

@@ -168,7 +168,7 @@ async def new_context(
         assert self._browser_type is not None
         await self._browser_type._prepare_browser_context_params(params)
 
-        channel = await self._channel.send("newContext", params)
+        channel = await self._channel.send("newContext", None, params)
         context = cast(BrowserContext, from_channel(channel))
         await context._initialize_har_from_options(
             record_har_content=recordHarContent,
@@ -235,7 +235,7 @@ async def close(self, reason: str = None) -> None:
             if self._should_close_connection_on_close:
                 await self._connection.stop_async()
             else:
-                await self._channel.send("close", {"reason": reason})
+                await self._channel.send("close", None, {"reason": reason})
         except Exception as e:
             if not is_target_closed_error(e):
                 raise e
@@ -245,7 +245,7 @@ def version(self) -> str:
         return self._initializer["version"]
 
     async def new_browser_cdp_session(self) -> CDPSession:
-        return from_channel(await self._channel.send("newBrowserCDPSession"))
+        return from_channel(await self._channel.send("newBrowserCDPSession", None))
 
     async def start_tracing(
         self,
@@ -260,10 +260,12 @@ async def start_tracing(
         if path:
             self._cr_tracing_path = str(path)
             params["path"] = str(path)
-        await self._channel.send("startTracing", params)
+        await self._channel.send("startTracing", None, params)
 
     async def stop_tracing(self) -> bytes:
-        artifact = cast(Artifact, from_channel(await self._channel.send("stopTracing")))
+        artifact = cast(
+            Artifact, from_channel(await self._channel.send("stopTracing", None))
+        )
         buffer = await artifact.read_info_buffer()
         await artifact.delete()
         if self._cr_tracing_path:

playwright/_impl/_browser_context.py

@@ -330,17 +330,17 @@ async def _initialize_har_from_options(
     async def new_page(self) -> Page:
         if self._owner_page:
             raise Error("Please use browser.new_context()")
-        return from_channel(await self._channel.send("newPage"))
+        return from_channel(await self._channel.send("newPage", None))
 
     async def cookies(self, urls: Union[str, Sequence[str]] = None) -> List[Cookie]:
         if urls is None:
             urls = []
         if isinstance(urls, str):
             urls = [urls]
-        return await self._channel.send("cookies", dict(urls=urls))
+        return await self._channel.send("cookies", None, dict(urls=urls))
 
     async def add_cookies(self, cookies: Sequence[SetCookieParam]) -> None:
-        await self._channel.send("addCookies", dict(cookies=cookies))
+        await self._channel.send("addCookies", None, dict(cookies=cookies))
 
     async def clear_cookies(
         self,
@@ -350,6 +350,7 @@ async def clear_cookies(
     ) -> None:
         await self._channel.send(
             "clearCookies",
+            None,
             {
                 "name": name if isinstance(name, str) else None,
                 "nameRegexSource": name.pattern if isinstance(name, Pattern) else None,
@@ -374,21 +375,21 @@ async def clear_cookies(
     async def grant_permissions(
         self, permissions: Sequence[str], origin: str = None
     ) -> None:
-        await self._channel.send("grantPermissions", locals_to_params(locals()))
+        await self._channel.send("grantPermissions", None, locals_to_params(locals()))
 
     async def clear_permissions(self) -> None:
-        await self._channel.send("clearPermissions")
+        await self._channel.send("clearPermissions", None)
 
     async def set_geolocation(self, geolocation: Geolocation = None) -> None:
-        await self._channel.send("setGeolocation", locals_to_params(locals()))
+        await self._channel.send("setGeolocation", None, locals_to_params(locals()))
 
     async def set_extra_http_headers(self, headers: Dict[str, str]) -> None:
         await self._channel.send(
-            "setExtraHTTPHeaders", dict(headers=serialize_headers(headers))
+            "setExtraHTTPHeaders", None, dict(headers=serialize_headers(headers))
         )
 
     async def set_offline(self, offline: bool) -> None:
-        await self._channel.send("setOffline", dict(offline=offline))
+        await self._channel.send("setOffline", None, dict(offline=offline))
 
     async def add_init_script(
         self, script: str = None, path: Union[str, Path] = None
@@ -397,7 +398,7 @@ async def add_init_script(
             script = (await async_readfile(path)).decode()
         if not isinstance(script, str):
             raise Error("Either path or script parameter must be specified")
-        await self._channel.send("addInitScript", dict(source=script))
+        await self._channel.send("addInitScript", None, dict(source=script))
 
     async def expose_binding(
         self, name: str, callback: Callable, handle: bool = None
@@ -411,7 +412,7 @@ async def expose_binding(
             raise Error(f'Function "{name}" has been already registered')
         self._bindings[name] = callback
         await self._channel.send(
-            "exposeBinding", dict(name=name, needsHandle=handle or False)
+            "exposeBinding", None, dict(name=name, needsHandle=handle or False)
         )
 
     async def expose_function(self, name: str, callback: Callable) -> None:
@@ -499,7 +500,7 @@ async def _record_into_har(
         }
         if page:
             params["page"] = page._channel
-        har_id = await self._channel.send("harStart", params)
+        har_id = await self._channel.send("harStart", None, params)
         self._har_recorders[har_id] = {
             "path": str(har),
             "content": update_content,
@@ -535,15 +536,15 @@ async def route_from_har(
     async def _update_interception_patterns(self) -> None:
         patterns = RouteHandler.prepare_interception_patterns(self._routes)
         await self._channel.send(
-            "setNetworkInterceptionPatterns", {"patterns": patterns}
+            "setNetworkInterceptionPatterns", None, {"patterns": patterns}
         )
 
     async def _update_web_socket_interception_patterns(self) -> None:
         patterns = WebSocketRouteHandler.prepare_interception_patterns(
             self._web_socket_routes
         )
         await self._channel.send(
-            "setWebSocketInterceptionPatterns", {"patterns": patterns}
+            "setWebSocketInterceptionPatterns", None, {"patterns": patterns}
         )
 
     def expect_event(
@@ -596,7 +597,7 @@ async def _inner_close() -> None:
                 har = cast(
                     Artifact,
                     from_channel(
-                        await self._channel.send("harExport", {"harId": har_id})
+                        await self._channel.send("harExport", None, {"harId": har_id})
                     ),
                 )
                 # Server side will compress artifact if content is attach or if file is .zip.
@@ -615,14 +616,14 @@ async def _inner_close() -> None:
                 await har.delete()
 
         await self._channel._connection.wrap_api_call(_inner_close, True)
-        await self._channel.send("close", {"reason": reason})
+        await self._channel.send("close", None, {"reason": reason})
         await self._closed_future
 
     async def storage_state(
         self, path: Union[str, Path] = None, indexedDB: bool = None
     ) -> StorageState:
         result = await self._channel.send_return_as_dict(
-            "storageState", {"indexedDB": indexedDB}
+            "storageState", None, {"indexedDB": indexedDB}
         )
         if path:
             await async_writefile(path, json.dumps(result))
@@ -749,7 +750,7 @@ async def new_cdp_session(self, page: Union[Page, Frame]) -> CDPSession:
             params["frame"] = page._channel
         else:
             raise Error("page: expected Page or Frame")
-        return from_channel(await self._channel.send("newCDPSession", params))
+        return from_channel(await self._channel.send("newCDPSession", None, params))
 
     @property
     def tracing(self) -> Tracing:

playwright/_impl/_browser_type.py

@@ -93,7 +93,12 @@ async def launch(
         params = locals_to_params(locals())
         normalize_launch_params(params)
         browser = cast(
-            Browser, from_channel(await self._channel.send("launch", params))
+            Browser,
+            from_channel(
+                await self._channel.send(
+                    "launch", TimeoutSettings.launch_timeout, params
+                )
+            ),
         )
         browser._connect_to_browser_type(
             self, str(tracesDir) if tracesDir is not None else None
@@ -159,7 +164,7 @@ async def launch_persistent_context(
         await self._prepare_browser_context_params(params)
         normalize_launch_params(params)
         result = await self._channel.send_return_as_dict(
-            "launchPersistentContext", params
+            "launchPersistentContext", TimeoutSettings.launch_timeout, params
         )
         browser = cast(
             Browser,
@@ -197,10 +202,11 @@ async def connect_over_cdp(
         headers: Dict[str, str] = None,
     ) -> Browser:
         params = locals_to_params(locals())
-        params["timeout"] = TimeoutSettings.launch_timeout(timeout)
         if params.get("headers"):
             params["headers"] = serialize_headers(params["headers"])
-        response = await self._channel.send_return_as_dict("connectOverCDP", params)
+        response = await self._channel.send_return_as_dict(
+            "connectOverCDP", TimeoutSettings.launch_timeout, params
+        )
         browser = cast(Browser, from_channel(response["browser"]))
         browser._connect_to_browser_type(self, None)
 
@@ -222,6 +228,7 @@ async def connect(
         pipe_channel = (
             await local_utils._channel.send_return_as_dict(
                 "connect",
+                None,
                 {
                     "wsEndpoint": wsEndpoint,
                     "headers": headers,
@@ -355,4 +362,3 @@ def normalize_launch_params(params: Dict) -> None:
         params["downloadsPath"] = str(Path(params["downloadsPath"]))
     if "tracesDir" in params:
         params["tracesDir"] = str(Path(params["tracesDir"]))
-    params["timeout"] = TimeoutSettings.launch_timeout(params.get("timeout"))

playwright/_impl/_cdp_session.py

@@ -29,7 +29,10 @@ def _on_event(self, params: Any) -> None:
         self.emit(params["method"], params.get("params"))
 
     async def send(self, method: str, params: Dict = None) -> Dict:
-        return await self._channel.send("send", locals_to_params(locals()))
+        return await self._channel.send("send", None, locals_to_params(locals()))
 
     async def detach(self) -> None:
-        await self._channel.send("detach")
+        await self._channel.send(
+            "detach",
+            None,
+        )

playwright/_impl/_clock.py

@@ -27,46 +27,64 @@ def __init__(self, browser_context: "BrowserContext") -> None:
 
     async def install(self, time: Union[float, str, datetime.datetime] = None) -> None:
         await self._browser_context._channel.send(
-            "clockInstall", parse_time(time) if time is not None else {}
+            "clockInstall",
+            None,
+            parse_time(time) if time is not None else {},
         )
 
     async def fast_forward(
         self,
         ticks: Union[int, str],
     ) -> None:
         await self._browser_context._channel.send(
-            "clockFastForward", parse_ticks(ticks)
+            "clockFastForward",
+            None,
+            parse_ticks(ticks),
         )
 
     async def pause_at(
         self,
         time: Union[float, str, datetime.datetime],
     ) -> None:
-        await self._browser_context._channel.send("clockPauseAt", parse_time(time))
+        await self._browser_context._channel.send(
+            "clockPauseAt",
+            None,
+            parse_time(time),
+        )
 
     async def resume(
         self,
     ) -> None:
-        await self._browser_context._channel.send("clockResume")
+        await self._browser_context._channel.send("clockResume", None)
 
     async def run_for(
         self,
         ticks: Union[int, str],
     ) -> None:
-        await self._browser_context._channel.send("clockRunFor", parse_ticks(ticks))
+        await self._browser_context._channel.send(
+            "clockRunFor",
+            None,
+            parse_ticks(ticks),
+        )
 
     async def set_fixed_time(
         self,
         time: Union[float, str, datetime.datetime],
     ) -> None:
-        await self._browser_context._channel.send("clockSetFixedTime", parse_time(time))
+        await self._browser_context._channel.send(
+            "clockSetFixedTime",
+            None,
+            parse_time(time),
+        )
 
     async def set_system_time(
         self,
         time: Union[float, str, datetime.datetime],
     ) -> None:
         await self._browser_context._channel.send(
-            "clockSetSystemTime", parse_time(time)
+            "clockSetSystemTime",
+            None,
+            parse_time(time),
         )