Revert "fix(asyncio): abort protocol calls on task cancellation"

playwright/_impl/_connection.py

@@ -143,21 +143,13 @@ async def _inner_send(
         callback = self._connection._send_message_to_server(
             self._object, method, augmented_params, timeout
         )
-        try:
-            done, _ = await asyncio.wait(
-                {
-                    self._connection._transport.on_error_future,
-                    callback.future,
-                },
-                return_when=asyncio.FIRST_COMPLETED,
-            )
-        except asyncio.CancelledError as exc:
-            await self._connection._abort(
-                self._object,
-                callback,
-                str(exc) or "Task was cancelled",
-            )
-            raise
+        done, _ = await asyncio.wait(
+            {
+                self._connection._transport.on_error_future,
+                callback.future,
+            },
+            return_when=asyncio.FIRST_COMPLETED,
+        )
         if not callback.future.done():
             callback.future.cancel()
         result = next(iter(done)).result()
@@ -249,10 +241,7 @@ def remove_listener(self, event: str, f: Any) -> None:
 
 
 class ProtocolCallback:
-    def __init__(
-        self, loop: asyncio.AbstractEventLoop, id: int, no_reply: bool = False
-    ) -> None:
-        self.id = id
+    def __init__(self, loop: asyncio.AbstractEventLoop, no_reply: bool = False) -> None:
         self.stack_trace: traceback.StackSummary
         self.no_reply = no_reply
         self.future = loop.create_future()
@@ -404,7 +393,7 @@ def _send_message_to_server(
             )
         self._last_id += 1
         id = self._last_id
-        callback = ProtocolCallback(self._loop, id, no_reply=no_reply)
+        callback = ProtocolCallback(self._loop, no_reply=no_reply)
         task = asyncio.current_task(self._loop)
         callback.stack_trace = cast(
             traceback.StackSummary,
@@ -449,34 +438,6 @@ def _send_message_to_server(
 
         return callback
 
-    async def _abort(
-        self, object: ChannelOwner, callback: ProtocolCallback, reason: str
-    ) -> None:
-        try:
-            self._transport.send(
-                {
-                    "guid": object._guid,
-                    "method": "__abort__",
-                    "params": {"id": callback.id, "reason": reason},
-                }
-            )
-        except (Error, OSError):
-            pass
-        try:
-            done, _ = await asyncio.wait(
-                {
-                    self._transport.on_error_future,
-                    callback.future,
-                },
-                return_when=asyncio.FIRST_COMPLETED,
-            )
-        finally:
-            if not callback.future.done():
-                callback.future.cancel()
-        for future in done:
-            if not future.cancelled():
-                future.exception()
-
     def dispatch(self, msg: ParsedMessagePayload) -> None:
         if self._closed_error:
             return

tests/async/test_asyncio.py

@@ -27,8 +27,7 @@
 
 
 async def test_should_cancel_underlying_protocol_calls(
-    browser_name: str,
-    launch_arguments: Dict,
+    browser_name: str, launch_arguments: Dict
 ) -> None:
     handler_exception = None
 
@@ -41,23 +40,12 @@ def exception_handler(loop: asyncio.AbstractEventLoop, context: Dict) -> None:
     async with async_playwright() as p:
         browser = await p[browser_name].launch(**launch_arguments)
         page = await browser.new_page()
-        await page.set_content(
-            """
-            <button disabled onclick="window.clicked = true">click me</button>
-            <script>window.clicked = false</script>
-            """
-        )
-        task = asyncio.create_task(page.locator("button").click(timeout=0))
-        await page.wait_for_timeout(100)
-        assert not task.done()
-
+        task = asyncio.create_task(page.wait_for_selector("will-never-find"))
+        # make sure that the wait_for_selector message was sent to the server (driver)
+        await asyncio.sleep(0.1)
         task.cancel()
         with pytest.raises(asyncio.CancelledError):
             await task
-
-        await page.locator("button").evaluate("button => button.disabled = false")
-        await page.wait_for_timeout(700)
-        assert not await page.evaluate("window.clicked")
         await browser.close()
 
     # The actual 'Future exception was never retrieved' is logged inside the Future destructor (__del__).