feat(roll): roll to Playwright 1.12.0-next-1621456974000 (microsoft#682)

Author: kumaraditya303

README.md

@@ -6,9 +6,9 @@ Playwright is a Python library to automate [Chromium](https://www.chromium.org/H
 
 |          | Linux | macOS | Windows |
 |   :---   | :---: | :---: | :---:   |
-| Chromium <!-- GEN:chromium-version -->92.0.4498.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Chromium <!-- GEN:chromium-version -->92.0.4500.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 | WebKit <!-- GEN:webkit-version -->14.2<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| Firefox <!-- GEN:firefox-version -->89.0b6<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Firefox <!-- GEN:firefox-version -->89.0b9<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 
 Headless execution is supported for all browsers on all platforms.
 

playwright/_impl/_browser_context.py

@@ -22,7 +22,11 @@
 from playwright._impl._api_structures import Cookie, Geolocation, StorageState
 from playwright._impl._api_types import Error
 from playwright._impl._cdp_session import CDPSession
-from playwright._impl._connection import ChannelOwner, from_channel
+from playwright._impl._connection import (
+    ChannelOwner,
+    from_channel,
+    from_nullable_channel,
+)
 from playwright._impl._event_context_manager import EventContextManagerImpl
 from playwright._impl._helper import (
     RouteHandler,
@@ -33,8 +37,9 @@
     is_safe_close_error,
     locals_to_params,
 )
-from playwright._impl._network import Request, Route, serialize_headers
+from playwright._impl._network import Request, Response, Route, serialize_headers
 from playwright._impl._page import BindingCall, Page, Worker
+from playwright._impl._tracing import Tracing
 from playwright._impl._wait_helper import WaitHelper
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -48,6 +53,10 @@ class BrowserContext(ChannelOwner):
         Close="close",
         Page="page",
         ServiceWorker="serviceworker",
+        Request="request",
+        Response="response",
+        RequestFailed="requestfailed",
+        RequestFinished="requestfinished",
     )
 
     def __init__(
@@ -64,7 +73,7 @@ def __init__(
         self._options: Dict[str, Any] = {}
         self._background_pages: Set[Page] = set()
         self._service_workers: Set[Worker] = set()
-
+        self._tracing = Tracing(self)
         self._channel.on(
             "bindingCall",
             lambda params: self._on_binding(from_channel(params["binding"])),
@@ -89,6 +98,37 @@ def __init__(
             "serviceWorker",
             lambda params: self._on_service_worker(from_channel(params["worker"])),
         )
+        self._channel.on(
+            "request",
+            lambda params: self._on_request(
+                from_channel(params["request"]),
+                from_nullable_channel(params.get("page")),
+            ),
+        )
+        self._channel.on(
+            "response",
+            lambda params: self._on_response(
+                from_channel(params["response"]),
+                from_nullable_channel(params.get("page")),
+            ),
+        )
+        self._channel.on(
+            "requestFailed",
+            lambda params: self._on_request_failed(
+                from_channel(params["request"]),
+                params["responseEndTiming"],
+                params["failureText"],
+                from_nullable_channel(params.get("page")),
+            ),
+        )
+        self._channel.on(
+            "requestFinished",
+            lambda params: self._on_request_finished(
+                from_channel(params["request"]),
+                params["responseEndTiming"],
+                from_nullable_channel(params.get("page")),
+            ),
+        )
 
     def __repr__(self) -> str:
         return f"<BrowserContext browser={self.browser}>"
@@ -287,6 +327,39 @@ def _on_service_worker(self, worker: Worker) -> None:
         self._service_workers.add(worker)
         self.emit(BrowserContext.Events.ServiceWorker, worker)
 
+    def _on_request_failed(
+        self,
+        request: Request,
+        response_end_timing: float,
+        failure_text: Optional[str],
+        page: Optional[Page],
+    ) -> None:
+        request._failure_text = failure_text
+        if request._timing:
+            request._timing["responseEnd"] = response_end_timing
+        self.emit(BrowserContext.Events.RequestFailed, request)
+        if page:
+            page.emit(Page.Events.RequestFailed, request)
+
+    def _on_request_finished(
+        self, request: Request, response_end_timing: float, page: Optional[Page]
+    ) -> None:
+        if request._timing:
+            request._timing["responseEnd"] = response_end_timing
+        self.emit(BrowserContext.Events.RequestFinished, request)
+        if page:
+            page.emit(Page.Events.RequestFinished, request)
+
+    def _on_request(self, request: Request, page: Optional[Page]) -> None:
+        self.emit(BrowserContext.Events.Request, request)
+        if page:
+            page.emit(Page.Events.Request, request)
+
+    def _on_response(self, response: Response, page: Optional[Page]) -> None:
+        self.emit(BrowserContext.Events.Response, response)
+        if page:
+            page.emit(Page.Events.Response, response)
+
     @property
     def background_pages(self) -> List[Page]:
         return list(self._background_pages)
@@ -299,3 +372,7 @@ async def new_cdp_session(self, page: Page) -> CDPSession:
         return from_channel(
             await self._channel.send("newCDPSession", {"page": page._channel})
         )
+
+    @property
+    def tracing(self) -> Tracing:
+        return self._tracing

playwright/_impl/_browser_type.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import asyncio
+import pathlib
 from pathlib import Path
 from typing import Dict, List, Optional, Union, cast
 
@@ -75,6 +76,7 @@ async def launch(
         proxy: ProxySettings = None,
         downloadsPath: Union[str, Path] = None,
         slowMo: float = None,
+        traceDir: Union[pathlib.Path, str] = None,
         chromiumSandbox: bool = None,
         firefoxUserPrefs: Dict[str, Union[str, float, bool]] = None,
     ) -> Browser:
@@ -123,6 +125,7 @@ async def launch_persistent_context(
         hasTouch: bool = None,
         colorScheme: ColorScheme = None,
         acceptDownloads: bool = None,
+        traceDir: Union[pathlib.Path, str] = None,
         chromiumSandbox: bool = None,
         recordHarPath: Union[Path, str] = None,
         recordHarOmitContent: bool = None,
@@ -209,7 +212,14 @@ async def connect(
         browser._is_remote = True
         browser._is_connected_over_websocket = True
 
-        transport.once("close", browser._on_close)
+        def handle_transport_close() -> None:
+            for context in browser.contexts:
+                for page in context.pages:
+                    page._on_close()
+                context._on_close()
+            browser._on_close()
+
+        transport.once("close", handle_transport_close)
 
         return browser
 

playwright/_impl/_download.py

@@ -26,6 +26,7 @@ class Download:
     def __init__(
         self, page: "Page", url: str, suggested_filename: str, artifact: Artifact
     ) -> None:
+        self._page = page
         self._loop = page._loop
         self._dispatcher_fiber = page._dispatcher_fiber
         self._url = url
@@ -35,6 +36,10 @@ def __init__(
     def __repr__(self) -> str:
         return f"<Download url={self.url!r} suggested_filename={self.suggested_filename!r}>"
 
+    @property
+    def page(self) -> "Page":
+        return self._page
+
     @property
     def url(self) -> str:
         return self._url

playwright/_impl/_helper.py

@@ -59,7 +59,6 @@
     "chrome-beta",
     "chrome-canary",
     "chrome-dev",
-    "firefox-stable",
     "msedge",
     "msedge-beta",
     "msedge-canary",

playwright/_impl/_page.py

@@ -173,32 +173,6 @@ def __init__(
                 Page.Events.PageError, parse_error(params["error"]["error"])
             ),
         )
-        self._channel.on(
-            "request",
-            lambda params: self.emit(
-                Page.Events.Request, from_channel(params["request"])
-            ),
-        )
-        self._channel.on(
-            "requestFailed",
-            lambda params: self._on_request_failed(
-                from_channel(params["request"]),
-                params["responseEndTiming"],
-                params["failureText"],
-            ),
-        )
-        self._channel.on(
-            "requestFinished",
-            lambda params: self._on_request_finished(
-                from_channel(params["request"]), params["responseEndTiming"]
-            ),
-        )
-        self._channel.on(
-            "response",
-            lambda params: self.emit(
-                Page.Events.Response, from_channel(params["response"])
-            ),
-        )
         self._channel.on(
             "route",
             lambda params: self._on_route(
@@ -219,24 +193,6 @@ def __init__(
     def __repr__(self) -> str:
         return f"<Page url={self.url!r}>"
 
-    def _on_request_failed(
-        self,
-        request: Request,
-        response_end_timing: float,
-        failure_text: str = None,
-    ) -> None:
-        request._failure_text = failure_text
-        if request._timing:
-            request._timing["responseEnd"] = response_end_timing
-        self.emit(Page.Events.RequestFailed, request)
-
-    def _on_request_finished(
-        self, request: Request, response_end_timing: float
-    ) -> None:
-        if request._timing:
-            request._timing["responseEnd"] = response_end_timing
-        self.emit(Page.Events.RequestFinished, request)
-
     def _on_frame_attached(self, frame: Frame) -> None:
         frame._page = self
         self._frames.append(frame)

playwright/_impl/_tracing.py

@@ -0,0 +1,48 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pathlib
+from typing import TYPE_CHECKING, Union, cast
+
+from playwright._impl._artifact import Artifact
+from playwright._impl._connection import from_channel
+from playwright._impl._helper import locals_to_params
+
+if TYPE_CHECKING:
+    from playwright._impl._browser_context import BrowserContext
+
+
+class Tracing:
+    def __init__(self, context: "BrowserContext") -> None:
+        self._context = context
+        self._channel = context._channel
+        self._loop = context._loop
+
+    async def start(
+        self, name: str = None, snapshots: bool = None, screenshots: bool = None
+    ) -> None:
+        params = locals_to_params(locals())
+        await self._channel.send("tracingStart", params)
+
+    async def stop(self) -> None:
+        await self._channel.send("tracingStop")
+
+    async def export(self, path: Union[pathlib.Path, str]) -> None:
+        artifact = cast(
+            Artifact, from_channel(await self._channel.send("tracingExport"))
+        )
+        if self._context._browser:
+            artifact._is_remote = self._context._browser._is_remote
+        await artifact.save_as(path)
+        await artifact.delete()

playwright/_impl/_transport.py

@@ -161,6 +161,7 @@ def __init__(
 
     def request_stop(self) -> None:
         self._stopped = True
+        self.emit("close")
         self._loop.create_task(self._connection.close())
 
     def dispose(self) -> None:
@@ -190,7 +191,10 @@ async def run(self) -> None:
                     break
                 obj = self.deserialize_message(message)
                 self.on_message(obj)
-            except websockets.exceptions.ConnectionClosed:
+            except (
+                websockets.exceptions.ConnectionClosed,
+                websockets.exceptions.ConnectionClosedError,
+            ):
                 if not self._stopped:
                     self.emit("close")
                 self.on_error_future.set_exception(