Fix timeout not being passed around to certain send() calls

Author: agg23

playwright/_impl/_clock.py

@@ -27,52 +27,66 @@ 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", None, parse_time(time) if time is not None else {}
+            "clockInstall",
+            self._browser_context._timeout_settings.timeout,
+            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", None, parse_ticks(ticks)
+            "clockFastForward",
+            self._browser_context._timeout_settings.timeout,
+            parse_ticks(ticks),
         )
 
     async def pause_at(
         self,
         time: Union[float, str, datetime.datetime],
     ) -> None:
         await self._browser_context._channel.send(
-            "clockPauseAt", None, parse_time(time)
+            "clockPauseAt",
+            self._browser_context._timeout_settings.timeout,
+            parse_time(time),
         )
 
     async def resume(
         self,
     ) -> None:
-        await self._browser_context._channel.send("clockResume", None)
+        await self._browser_context._channel.send(
+            "clockResume", self._browser_context._timeout_settings.timeout
+        )
 
     async def run_for(
         self,
         ticks: Union[int, str],
     ) -> None:
         await self._browser_context._channel.send(
-            "clockRunFor", None, parse_ticks(ticks)
+            "clockRunFor",
+            self._browser_context._timeout_settings.timeout,
+            parse_ticks(ticks),
         )
 
     async def set_fixed_time(
         self,
         time: Union[float, str, datetime.datetime],
     ) -> None:
         await self._browser_context._channel.send(
-            "clockSetFixedTime", None, parse_time(time)
+            "clockSetFixedTime",
+            self._browser_context._timeout_settings.timeout,
+            parse_time(time),
         )
 
     async def set_system_time(
         self,
         time: Union[float, str, datetime.datetime],
     ) -> None:
         await self._browser_context._channel.send(
-            "clockSetSystemTime", None, parse_time(time)
+            "clockSetSystemTime",
+            self._browser_context._timeout_settings.timeout,
+            parse_time(time),
         )
 
 

playwright/_impl/_connection.py

@@ -648,7 +648,7 @@ def _augment_params(
 ) -> Dict:
     if params is None:
         params = {}
-    if timeout_calculator is not None:
+    if timeout_calculator:
         params["timeout"] = timeout_calculator(params.get("timeout"))
     return _filter_none(params)
 

playwright/_impl/_locator.py

@@ -383,7 +383,7 @@ async def focus(self, timeout: float = None) -> None:
     async def blur(self, timeout: float = None) -> None:
         await self._frame._channel.send(
             "blur",
-            None,
+            self._frame._timeout,
             {
                 "selector": self._selector,
                 "strict": True,
@@ -550,7 +550,7 @@ async def screenshot(
     async def aria_snapshot(self, timeout: float = None) -> str:
         return await self._frame._channel.send(
             "ariaSnapshot",
-            None,
+            self._frame._timeout,
             {
                 "selector": self._selector,
                 **locals_to_params(locals()),
@@ -728,7 +728,7 @@ async def _expect(
             options["expectedValue"] = serialize_argument(options["expectedValue"])
         result = await self._frame._channel.send_return_as_dict(
             "expect",
-            None,
+            self._frame._timeout,
             {
                 "selector": self._selector,
                 "expression": expression,

playwright/_impl/_selectors.py

@@ -46,7 +46,9 @@ async def register(
             engine["contentScript"] = contentScript
         for context in self._contexts_for_selectors:
             await context._channel.send(
-                "registerSelectorEngine", None, {"selectorEngine": engine}
+                "registerSelectorEngine",
+                context._timeout_settings.timeout,
+                {"selectorEngine": engine},
             )
         self._selector_engines.append(engine)
 
@@ -55,5 +57,7 @@ def set_test_id_attribute(self, attributeName: str) -> None:
         self._test_id_attribute_name = attributeName
         for context in self._contexts_for_selectors:
             context._channel.send_no_reply(
-                "setTestIdAttributeName", None, {"testIdAttributeName": attributeName}
+                "setTestIdAttributeName",
+                context._timeout_settings.timeout,
+                {"testIdAttributeName": attributeName},
             )

playwright/_impl/_set_input_files_helpers.py

@@ -84,7 +84,7 @@ async def convert_input_files(
             result = await context._connection.wrap_api_call(
                 lambda: context._channel.send_return_as_dict(
                     "createTempFiles",
-                    None,
+                    context._timeout_settings.timeout,
                     {
                         "rootDirName": (
                             os.path.basename(local_directory)