[TODO: REVERT] revert all the changes, keep bidi transport

Author: sadym-chromium

console/console-log-logged.html

@@ -49,45 +49,6 @@
      * @namespace {test_driver}
      */
     window.test_driver = {
-        /**
-         Represents `WebDriver BiDi <https://w3c.github.io/webdriver-bidi>`_ protocol.
-         */
-        bidi: {
-            /**
-             * `log <https://w3c.github.io/webdriver-bidi/#module-log>`_ module.
-             */
-            log: {
-                /**
-                 * `log.entryAdded <https://w3c.github.io/webdriver-bidi/#event-log-entryAdded>`_ event.
-                 */
-                entry_added: {
-                    /**
-                     * Subscribe to the `log.entryAdded` event. This does not add actual listeners. To listen to the
-                     * event, use `on` method.
-                     * @param {{contexts?: null | (string | Window)[]}} props - Parameters for the subscription.
-                     * * `contexts`: an array of window proxies or browsing context ids to listen to the event. If not
-                     *   provided, the event subscription is done for the current window's browsing context. `null` for
-                     *   the global subscription.
-                     * @return {Promise<void>}
-                     */
-                    subscribe: async function (props = {}) {
-                        return window.test_driver_internal.bidi.log.entry_added.subscribe(props);
-                    },
-                    /**
-                     * Add an event listener for the `log.entryAdded
-                     * <https://w3c.github.io/webdriver-bidi/#event-log-entryAdded>`_ event. Make sure `subscribe` is
-                     * called before using this method.
-                     *
-                     * @param callback {function(event): void} - The callback to be called when the event is fired.
-                     * @returns {function(): void} - A function to call to remove the event listener.
-                     */
-                    on: function (callback) {
-                        return window.test_driver_internal.bidi.log.entry_added.on(callback);
-                    },
-                }
-            }
-        },
-
         /**
          * Set the context in which testharness.js is loaded
          *
@@ -1117,19 +1078,6 @@
          */
         in_automation: false,
 
-        bidi: {
-            log: {
-                entry_added: {
-                    subscribe: function () {
-                        throw new Error("bidi.log.entry_added.subscribe is not implemented by testdriver-vendor.js");
-                    },
-                    on: function () {
-                        throw new Error("bidi.log.entry_added.on is not implemented by testdriver-vendor.js");
-                    }
-                }
-            }
-        },
-
         async click(element, coords) {
             if (this.in_automation) {
                 throw new Error("click() is not implemented by testdriver-vendor.js");

resources/testdriver.js

@@ -19,7 +19,7 @@ def __init__(self, message: str, stacktrace: Optional[str] = None):
 
     def __repr__(self):
         """Return the object representation in string format."""
-        return f"{self.__class__.__name__}({self.message}, {self.stacktrace})"
+        return f"{self.__class__.__name__}({self.error}, {self.message}, {self.stacktrace})"
 
     def __str__(self):
         """Return the string representation of the object."""

tools/webdriver/webdriver/bidi/error.py

@@ -4,6 +4,7 @@
 
 import webdriver
 
+
 """WebDriver wire protocol codecs."""
 
 
@@ -23,11 +24,6 @@ def default(self, obj):
             return {webdriver.ShadowRoot.identifier: obj.id}
         elif isinstance(obj, webdriver.WebWindow):
             return {webdriver.WebWindow.identifier: obj.id}
-        # Support for arguments received via BiDi.
-        # https://github.com/web-platform-tests/rfcs/blob/master/rfcs/testdriver_bidi.md
-        elif isinstance(obj, webdriver.bidi.protocol.BidiValue):
-            return obj.to_classic_protocol_value()
-
         return super().default(obj)
 
 

tools/webdriver/webdriver/bidi/protocol.py

@@ -10,12 +10,11 @@
 import socket
 import sys
 from abc import ABCMeta, abstractmethod
-from typing import Any, Callable, ClassVar, Dict, List, Literal, Tuple, Type
+from typing import Any, Callable, ClassVar, Tuple, Type
 from urllib.parse import urljoin, urlsplit, urlunsplit
 
 from . import pytestrunner
 from .actions import actions
-from .asyncactions import async_actions
 from .protocol import Protocol, WdspecProtocol
 
 
@@ -725,14 +724,14 @@ def __init__(self, logger, protocol, test_window):
         self.protocol = protocol
         self.test_window = test_window
         self.logger = logger
-        self.callbacks: Dict[str, Callable[[str, Any], Tuple[bool, Any]]] = {
+        self.callbacks = {
             "action": self.process_action,
             "complete": self.process_complete
         }
 
         self.actions = {cls.name: cls(self.logger, self.protocol) for cls in actions}
 
-    def __call__(self, result: Tuple[str, str, Dict]):
+    def __call__(self, result):
         url, command, payload = result
         self.logger.debug("Got async callback: %s" % result[1])
         try:
@@ -741,11 +740,11 @@ def __call__(self, result: Tuple[str, str, Dict]):
             raise ValueError("Unknown callback type %r" % result[1]) from e
         return callback(url, payload)
 
-    def process_complete(self, url: str, payload: List) -> Tuple[Literal[True], Any]:
+    def process_complete(self, url, payload):
         rv = [strip_server(url)] + payload
         return True, rv
 
-    def process_action(self, url: str, payload: Dict) -> Tuple[Literal[False], None]:
+    def process_action(self, url, payload):
         action = payload["action"]
         cmd_id = payload["id"]
         self.logger.debug(f"Got action: {action}")
@@ -783,67 +782,10 @@ def process_action(self, url: str, payload: Dict) -> Tuple[Literal[False], None]
 
         return False, None
 
-    def _send_message(self, cmd_id: int, message_type: str, status: str, message: str = None):
+    def _send_message(self, cmd_id, message_type, status, message=None):
         self.protocol.testdriver.send_message(cmd_id, message_type, status, message=message)
 
 
-class AsyncCallbackHandler(CallbackHandler):
-    """
-    Handle synchronous and asynchronous actions. Extends `CallbackHandler` with support of async actions.
-    """
-
-    def __init__(self, logger, protocol, test_window, loop):
-        super().__init__(logger, protocol, test_window)
-        self.loop = loop
-        self.async_actions = {cls.name: cls(self.logger, self.protocol) for cls in async_actions}
-
-    def process_action(self, url: str, payload: Dict[str, Any]) -> Tuple[Literal[False], None]:
-        action = payload["action"]
-        if action in self.async_actions:
-            # Schedule async action to be processed in the event loop and return immediately.
-            self.logger.debug(f"Scheduling async action processing: {action}, {payload}")
-            self.loop.create_task(self._process_async_action(action, payload))
-            return False, None
-        else:
-            # Fallback to the default action processing, which will fail if the action is not implemented.
-            self.logger.debug(f"Processing synchronous action: {action}, {payload}")
-            return super().process_action(url, payload)
-
-    async def _process_async_action(self, action: str, payload: Dict[str, Any]):
-        """
-        Process async action and send the result back to the test driver.
-
-        This method is analogous to `process_action` but is intended to be used with async actions in a task, so it does
-        not raise unexpected exceptions. However, the unexpected exceptions are logged and the error message is sent
-        back to the test driver.
-        """
-        async_action_handler = self.async_actions[action]
-        cmd_id = payload["id"]
-        try:
-            result = await async_action_handler(payload)
-        except AttributeError as e:
-            # If we fail to get an attribute from the protocol presumably that's a
-            # ProtocolPart we don't implement
-            # AttributeError got an obj property in Python 3.10, for older versions we
-            # fall back to looking at the error message.
-            if ((hasattr(e, "obj") and getattr(e, "obj") == self.protocol) or
-                    f"'{self.protocol.__class__.__name__}' object has no attribute" in str(e)):
-                raise NotImplementedError from e
-        except self.unimplemented_exc:
-            self.logger.warning("Action %s not implemented" % action)
-            self._send_message(cmd_id, "complete", "error", f"Action {action} not implemented")
-        except self.expected_exc as e:
-            self.logger.debug(f"Action {action} failed with an expected exception: {e}")
-            self._send_message(cmd_id, "complete", "error", f"Action {action} failed: {e}")
-        except Exception as e:
-            self.logger.warning(f"Action {action} failed with an unexpected exception: {e}")
-            self._send_message(cmd_id, "complete", "error", f"Unexpected exception: {e}")
-        else:
-            self.logger.debug(f"Action {action} completed with result {result}")
-            return_message = {"result": result}
-            self._send_message(cmd_id, "complete", "success", json.dumps(return_message))
-
-
 class ActionContext:
     def __init__(self, logger, protocol, context):
         self.logger = logger