Make wdspec tests runnable

components/webdriver_server/Cargo.toml

@@ -26,4 +26,4 @@ servo_config = {path = "../config"}
 servo_url = {path = "../url"}
 url = "1.2"
 uuid = {version = "0.5", features = ["v4"]}
-webdriver = "0.22"
+webdriver = "0.32"

components/webdriver_server/keys.rs

@@ -168,11 +168,11 @@ fn key_from_char(key_string: &char) -> Option<(Key, bool)> {
     }
 }
 
-pub fn keycodes_to_keys(key_codes: &[char]) -> Result<Vec<(Key, KeyModifiers, KeyState)>, String> {
+pub fn keycodes_to_keys(key_codes: &str) -> Result<Vec<(Key, KeyModifiers, KeyState)>, String> {
     let mut rv = vec![];
 
-    for char_code in key_codes.iter() {
-        let (key, with_shift) = key_from_char(char_code).ok_or(format!("Unsupported character code {}", char_code))?;
+    for char_code in key_codes.chars() {
+        let (key, with_shift) = key_from_char(&char_code).ok_or(format!("Unsupported character code {}", char_code))?;
         let modifiers = if with_shift {
             KeyModifiers::SHIFT
         } else {

components/webdriver_server/lib.rs

@@ -52,13 +52,13 @@ use webdriver::command::{AddCookieParameters, GetParameters, JavascriptCommandPa
 use webdriver::command::{LocatorParameters, Parameters};
 use webdriver::command::{SendKeysParameters, SwitchToFrameParameters, TimeoutsParameters};
 use webdriver::command::{WebDriverCommand, WebDriverExtensionCommand, WebDriverMessage};
-use webdriver::command::WindowSizeParameters;
+use webdriver::command::WindowRectParameters;
 use webdriver::common::{Date, LocatorStrategy, Nullable, WebElement};
 use webdriver::error::{ErrorStatus, WebDriverError, WebDriverResult};
 use webdriver::httpapi::WebDriverExtensionRoute;
-use webdriver::response::{Cookie, CookieResponse};
+use webdriver::response::{Cookie, CookieResponse, CookiesResponse};
 use webdriver::response::{ElementRectResponse, NewSessionResponse, ValueResponse};
-use webdriver::response::{WebDriverResponse, WindowSizeResponse};
+use webdriver::response::{WebDriverResponse, WindowRectResponse};
 use webdriver::server::{self, Session, WebDriverHandler};
 
 fn extension_routes() -> Vec<(Method, &'static str, ServoExtensionRoute)> {
@@ -402,13 +402,23 @@ impl Handler {
 
         let window_size = receiver.recv().unwrap();
         let vp = window_size.initial_viewport;
-        let window_size_response = WindowSizeResponse::new(vp.width as u64, vp.height as u64);
-        Ok(WebDriverResponse::WindowSize(window_size_response))
+        let window_size_response = WindowRectResponse {
+            x: 0, y: 0, width: vp.width as i32, height: vp.height as i32
+        };
+        Ok(WebDriverResponse::WindowRect(window_size_response))
     }
 
-    fn handle_set_window_size(&self, params: &WindowSizeParameters) -> WebDriverResult<WebDriverResponse> {
+    fn handle_set_window_size(&self, params: &WindowRectParameters) -> WebDriverResult<WebDriverResponse> {
         let (sender, receiver) = ipc::channel().unwrap();
-        let size = Size2D::new(params.width as u32, params.height as u32);
+        let width = match params.width {
+            Nullable::Value(v) => v,
+            Nullable::Null => 0,
+        };
+        let height = match params.height {
+            Nullable::Value(v) => v,
+            Nullable::Null => 0,
+        };
+        let size = Size2D::new(width as u32, height as u32);
         let top_level_browsing_context_id = self.session()?.top_level_browsing_context_id;
         let cmd_msg = WebDriverCommandMsg::SetWindowSize(top_level_browsing_context_id, size, sender.clone());
 
@@ -426,8 +436,10 @@ impl Handler {
 
         let window_size = receiver.recv().unwrap();
         let vp = window_size.initial_viewport;
-        let window_size_response = WindowSizeResponse::new(vp.width as u64, vp.height as u64);
-        Ok(WebDriverResponse::WindowSize(window_size_response))
+        let window_size_response = WindowRectResponse {
+            x: 0, y: 0, width: vp.width as i32, height: vp.height as i32
+        };
+        Ok(WebDriverResponse::WindowRect(window_size_response))
     }
 
     fn handle_is_enabled(&self, element: &WebElement) -> WebDriverResult<WebDriverResponse> {
@@ -588,8 +600,10 @@ impl Handler {
         self.browsing_context_script_command(cmd)?;
         match receiver.recv().unwrap() {
             Ok(rect) => {
-                let response = ElementRectResponse::new(rect.origin.x, rect.origin.y,
-                                                        rect.size.width, rect.size.height);
+                let response = ElementRectResponse {
+                    x: rect.origin.x, y: rect.origin.y,
+                    width: rect.size.width, height: rect.size.height
+                };
                 Ok(WebDriverResponse::ElementRect(response))
             },
             Err(_) => Err(WebDriverError::new(ErrorStatus::StaleElementReference,
@@ -657,7 +671,7 @@ impl Handler {
         let response = cookies.into_iter().map(|cookie| {
             cookie_msg_to_cookie(cookie.into_inner())
         }).collect::<Vec<Cookie>>();
-        Ok(WebDriverResponse::Cookie(CookieResponse::new(response)))
+        Ok(WebDriverResponse::Cookies(CookiesResponse { value: response }))
     }
 
     fn handle_get_cookie(&self, name: &str) -> WebDriverResult<WebDriverResponse> {
@@ -667,8 +681,8 @@ impl Handler {
         let cookies = receiver.recv().unwrap();
         let response = cookies.into_iter().map(|cookie| {
             cookie_msg_to_cookie(cookie.into_inner())
-        }).collect::<Vec<Cookie>>();
-        Ok(WebDriverResponse::Cookie(CookieResponse::new(response)))
+        }).next().unwrap();
+        Ok(WebDriverResponse::Cookie(CookieResponse { value: response }))
     }
 
     fn handle_add_cookie(&self, params: &AddCookieParameters) -> WebDriverResult<WebDriverResponse> {
@@ -779,7 +793,7 @@ impl Handler {
         receiver.recv().unwrap().or_else(|_| Err(WebDriverError::new(
             ErrorStatus::StaleElementReference, "Element not found or not focusable")))?;
 
-        let keys = keycodes_to_keys(&keys.value).or_else(|_|
+        let keys = keycodes_to_keys(&keys.text).or_else(|_|
             Err(WebDriverError::new(ErrorStatus::UnsupportedOperation, "Failed to convert keycodes")))?;
 
         // TODO: there's a race condition caused by the focus command and the
@@ -880,8 +894,8 @@ impl WebDriverHandler<ServoExtensionRoute> for Handler {
             WebDriverCommand::AddCookie(ref parameters) => self.handle_add_cookie(parameters),
             WebDriverCommand::Get(ref parameters) => self.handle_get(parameters),
             WebDriverCommand::GetCurrentUrl => self.handle_current_url(),
-            WebDriverCommand::GetWindowSize => self.handle_window_size(),
-            WebDriverCommand::SetWindowSize(ref size) => self.handle_set_window_size(size),
+            WebDriverCommand::GetWindowRect => self.handle_window_size(),
+            WebDriverCommand::SetWindowRect(ref size) => self.handle_set_window_size(size),
             WebDriverCommand::IsEnabled(ref element) => self.handle_is_enabled(element),
             WebDriverCommand::IsSelected(ref element) => self.handle_is_selected(element),
             WebDriverCommand::GoBack => self.handle_go_back(),

ports/servo/Cargo.toml

@@ -32,7 +32,7 @@ style_tests = {path = "../../tests/unit/style"}
 default = ["unstable", "default-except-unstable"]
 default-except-unstable = ["webdriver", "max_log_level"]
 max_log_level = ["log/release_max_level_info"]
-webdriver = ["libservo/webdriver_server"]
+webdriver = ["libservo/webdriver"]
 energy-profiling = ["libservo/energy-profiling"]
 debugmozjs = ["libservo/debugmozjs"]
 googlevr = ["libservo/googlevr"]

servo-tidy.toml

@@ -35,6 +35,7 @@ num = []
 # Ignored packages with duplicated versions
 packages = [
   "bitflags",
+  "cookie",
   "mime",
   "semver",
   "toml",

tests/wpt/run.py

@@ -35,7 +35,7 @@ def run_tests(paths=None, **kwargs):
     use_mach_logging = False
     if len(kwargs["test_list"]) == 1:
         file_ext = os.path.splitext(kwargs["test_list"][0])[1].lower()
-        if file_ext in [".htm", ".html", ".js", ".xhtml", ".xht"]:
+        if file_ext in [".htm", ".html", ".js", ".xhtml", ".xht", ".py"]:
             use_mach_logging = True
 
     if use_mach_logging:
@@ -65,6 +65,7 @@ def set_defaults(paths, kwargs):
         bin_path = servo_path("target", bin_dir, bin_name)
 
         kwargs["binary"] = bin_path
+        kwargs["webdriver_binary"] = bin_path
 
     if kwargs["processes"] is None:
         kwargs["processes"] = multiprocessing.cpu_count()

tests/wpt/web-platform-tests/tools/wptrunner/wptrunner/browsers/servo.py

@@ -42,6 +42,8 @@ def executor_kwargs(test_type, server_config, cache_manager, run_info_data,
     rv = base_executor_kwargs(test_type, server_config,
                               cache_manager, **kwargs)
     rv["pause_after_test"] = kwargs["pause_after_test"]
+    if test_type == "wdspec":
+        rv["capabilities"] = {}
     return rv
 
 

tests/wpt/web-platform-tests/tools/wptrunner/wptrunner/executors/executorservo.py

@@ -18,7 +18,7 @@
                    RefTestImplementation,
                    testharness_result_converter,
                    reftest_result_converter,
-                   WdspecExecutor)
+                   WdspecExecutor, WebDriverProtocol)
 from .process import ProcessTestExecutor
 from ..browsers.base import browser_command
 from ..wpttest import WdspecResult, WdspecSubtestResult
@@ -286,82 +286,9 @@ def on_output(self, line):
                                        line,
                                        " ".join(self.command))
 
-class ServoWdspecProtocol(Protocol):
-    def __init__(self, executor, browser):
-        self.do_delayed_imports()
-        Protocol.__init__(self, executor, browser)
-        self.session = None
-        self.server = None
-
-    def setup(self, runner):
-        try:
-            self.server = ServoDriverServer(self.logger, binary=self.browser.binary, binary_args=self.browser.binary_args)
-            self.server.start(block=False)
-            self.logger.info(
-                "WebDriver HTTP server listening at %s" % self.server.url)
-
-            self.logger.info(
-                "Establishing new WebDriver session with %s" % self.server.url)
-            self.session = webdriver.Session(
-                self.server.host, self.server.port, self.server.base_path)
-        except Exception:
-            self.logger.error(traceback.format_exc())
-            self.executor.runner.send_message("init_failed")
-        else:
-            self.executor.runner.send_message("init_succeeded")
-
-    def teardown(self):
-        if self.server is not None:
-            try:
-                if self.session.session_id is not None:
-                    self.session.end()
-            except Exception:
-                pass
-            if self.server.is_alive:
-                self.server.stop()
-
-    @property
-    def is_alive(self):
-        conn = httplib.HTTPConnection(self.server.host, self.server.port)
-        conn.request("HEAD", self.server.base_path + "invalid")
-        res = conn.getresponse()
-        return res.status == 404
-
-    def do_delayed_imports(self):
-        global pytestrunner, webdriver
-        from . import pytestrunner
-        import webdriver
 
+class ServoDriverProtocol(WebDriverProtocol):
+    server_cls = ServoDriverServer
 
 class ServoWdspecExecutor(WdspecExecutor):
-    def __init__(self, browser, server_config,
-                 timeout_multiplier=1, close_after_done=True, debug_info=None,
-                 **kwargs):
-        WdspecExecutor.__init__(self, browser, server_config,
-                                timeout_multiplier=timeout_multiplier,
-                                debug_info=debug_info)
-        self.protocol = ServoWdspecProtocol(self, browser)
-
-    def is_alive(self):
-        return self.protocol.is_alive
-
-    def on_environment_change(self, new_environment):
-        pass
-
-    def do_test(self, test):
-        timeout = test.timeout * self.timeout_multiplier + extra_timeout
-
-        success, data = WdspecRun(self.do_wdspec,
-                                  self.protocol.session,
-                                  test.path,
-                                  timeout).run()
-
-        if success:
-            return self.convert_result(test, data)
-
-        return (test.result_cls(*data), [])
-
-    def do_wdspec(self, session, path, timeout):
-        harness_result = ("OK", None)
-        subtest_results = pytestrunner.run(path, session, timeout=timeout)
-        return (harness_result, subtest_results)
+    protocol_cls = ServoDriverProtocol

tests/wpt/web-platform-tests/tools/wptrunner/wptrunner/webdriver_server.py

@@ -195,10 +195,11 @@ def make_command(self):
 
 
 class ServoDriverServer(WebDriverServer):
-    def __init__(self, logger, binary="servo", binary_args=None, host="127.0.0.1", port=None):
+    def __init__(self, logger, binary="servo", binary_args=None, host="127.0.0.1",
+                 port=None, args=None):
         env = os.environ.copy()
         env["RUST_BACKTRACE"] = "1"
-        WebDriverServer.__init__(self, logger, binary, host=host, port=port, env=env)
+        WebDriverServer.__init__(self, logger, binary, host=host, port=port, env=env, args=args)
         self.binary_args = binary_args
 
     def make_command(self):