Removed duplicate webdriver_traits file and added webdriver handler for GetWindowSize, IsSelected and IsEnabled

components/msg/webdriver_msg.rs

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use constellation_msg::PipelineId;
+use constellation_msg::{PipelineId, WindowSizeData};
 use ipc_channel::ipc::IpcSender;
 use rustc_serialize::json::{Json, ToJson};
 use url::Url;
@@ -21,6 +21,9 @@ pub enum WebDriverScriptCommand {
     GetElementText(String, IpcSender<Result<String, ()>>),
     GetFrameId(WebDriverFrameId, IpcSender<Result<Option<PipelineId>, ()>>),
     GetUrl(IpcSender<Url>),
+    GetWindowSize(IpcSender<Option<WindowSizeData>>),
+    IsEnabled(String, IpcSender<Result<bool, ()>>),
+    IsSelected(String, IpcSender<Result<bool, ()>>),
     GetTitle(IpcSender<String>)
 }
 

components/script/script_task.rs

@@ -1116,6 +1116,12 @@ impl ScriptTask {
                 webdriver_handlers::handle_get_frame_id(&page, pipeline_id, frame_id, reply),
             WebDriverScriptCommand::GetUrl(reply) =>
                 webdriver_handlers::handle_get_url(&page, pipeline_id, reply),
+            WebDriverScriptCommand::GetWindowSize(reply) =>
+                webdriver_handlers::handle_get_window_size(&page, pipeline_id, reply),
+            WebDriverScriptCommand::IsEnabled(element_id, reply) =>
+                webdriver_handlers::handle_is_enabled(&page, pipeline_id, element_id, reply),
+            WebDriverScriptCommand::IsSelected(element_id, reply) =>
+                webdriver_handlers::handle_is_selected(&page, pipeline_id, element_id, reply),
             WebDriverScriptCommand::GetTitle(reply) =>
                 webdriver_handlers::handle_get_title(&page, pipeline_id, reply),
             WebDriverScriptCommand::ExecuteAsyncScript(script, reply) =>

components/script/webdriver_handlers.rs

@@ -7,6 +7,8 @@ use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
 use dom::bindings::codegen::Bindings::ElementBinding::ElementMethods;
 use dom::bindings::codegen::Bindings::HTMLElementBinding::HTMLElementMethods;
 use dom::bindings::codegen::Bindings::HTMLIFrameElementBinding::HTMLIFrameElementMethods;
+use dom::bindings::codegen::Bindings::HTMLInputElementBinding::HTMLInputElementMethods;
+use dom::bindings::codegen::Bindings::HTMLOptionElementBinding::HTMLOptionElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
 use dom::bindings::codegen::Bindings::NodeListBinding::NodeListMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
@@ -16,13 +18,15 @@ use dom::bindings::js::Root;
 use dom::element::Element;
 use dom::htmlelement::HTMLElement;
 use dom::htmliframeelement::HTMLIFrameElement;
+use dom::htmlinputelement::HTMLInputElement;
+use dom::htmloptionelement::HTMLOptionElement;
 use dom::node::Node;
 use dom::window::ScriptHelpers;
 use ipc_channel::ipc::IpcSender;
 use js::jsapi::JSContext;
 use js::jsapi::{HandleValue, RootedValue};
 use js::jsval::UndefinedValue;
-use msg::constellation_msg::PipelineId;
+use msg::constellation_msg::{PipelineId, WindowSizeData};
 use msg::webdriver_msg::{WebDriverFrameId, WebDriverJSError, WebDriverJSResult, WebDriverJSValue};
 use page::Page;
 use script_task::get_page;
@@ -242,3 +246,49 @@ pub fn handle_get_url(page: &Rc<Page>,
     let url = document.url();
     reply.send((*url).clone()).unwrap();
 }
+
+pub fn handle_get_window_size(page: &Rc<Page>,
+                              _pipeline: PipelineId,
+                              reply: IpcSender<Option<WindowSizeData>>) {
+    let window = page.window();
+    let size = window.window_size();
+    reply.send(size).unwrap();
+}
+
+pub fn handle_is_enabled(page: &Rc<Page>,
+                         pipeline: PipelineId,
+                         element_id: String,
+                         reply: IpcSender<Result<bool, ()>>) {
+    reply.send(match find_node_by_unique_id(page, pipeline, element_id) {
+        Some(ref node) => {
+            match node.downcast::<Element>() {
+                Some(elem) => Ok(elem.get_enabled_state()),
+                None => Err(())
+            }
+        },
+        None => Err(())
+    }).unwrap();
+}
+
+pub fn handle_is_selected(page: &Rc<Page>,
+                          pipeline: PipelineId,
+                          element_id: String,
+                          reply: IpcSender<Result<bool, ()>>) {
+    reply.send(match find_node_by_unique_id(page, pipeline, element_id) {
+        Some(ref node) => {
+            if let Some(input_element) = node.downcast::<HTMLInputElement>() {
+                Ok(input_element.Checked())
+            }
+            else if let Some(option_element) = node.downcast::<HTMLOptionElement>() {
+                Ok(option_element.Selected())
+            }
+            else if let Some(_) = node.downcast::<HTMLElement>() {
+                Ok(false) // regular elements are not selectable
+            }
+            else {
+                Err(())
+            }
+        },
+        None => Err(())
+    }).unwrap();
+}

components/webdriver_server/lib.rs

@@ -49,7 +49,7 @@ use webdriver::command::{WebDriverCommand, WebDriverExtensionCommand, WebDriverM
 use webdriver::common::{LocatorStrategy, WebElement};
 use webdriver::error::{ErrorStatus, WebDriverError, WebDriverResult};
 use webdriver::httpapi::{WebDriverExtensionRoute};
-use webdriver::response::{NewSessionResponse, ValueResponse, WebDriverResponse};
+use webdriver::response::{NewSessionResponse, ValueResponse, WebDriverResponse, WindowSizeResponse};
 use webdriver::server::{self, Session, WebDriverHandler};
 
 fn extension_routes() -> Vec<(Method, &'static str, ServoExtensionRoute)> {
@@ -345,6 +345,57 @@ impl Handler {
         Ok(WebDriverResponse::Generic(ValueResponse::new(url.serialize().to_json())))
     }
 
+    fn handle_window_size(&self) -> WebDriverResult<WebDriverResponse> {
+        let pipeline_id = try!(self.root_pipeline());
+
+        let (sender, receiver) = ipc::channel().unwrap();
+
+        let cmd_msg = WebDriverCommandMsg::ScriptCommand(pipeline_id,
+                                                         WebDriverScriptCommand::GetWindowSize(sender));
+        self.constellation_chan.send(ConstellationMsg::WebDriverCommand(cmd_msg)).unwrap();
+
+        match receiver.recv().unwrap() {
+            Some(window_size) => {
+                let vp = window_size.visible_viewport;
+                let window_size_response = WindowSizeResponse::new(vp.width.get() as u64, vp.height.get() as u64);
+                Ok(WebDriverResponse::WindowSize(window_size_response))
+            },
+            None => Err(WebDriverError::new(ErrorStatus::NoSuchWindow, "Unable to determine window size"))
+        }
+    }
+
+    fn handle_is_enabled(&self, element: &WebElement) -> WebDriverResult<WebDriverResponse> {
+        let pipeline_id = try!(self.root_pipeline());
+
+        let (sender, receiver) = ipc::channel().unwrap();
+
+        let element_id = element.id.clone();
+        let cmd_msg = WebDriverCommandMsg::ScriptCommand(pipeline_id,
+                                                         WebDriverScriptCommand::IsEnabled(element_id, sender));
+        self.constellation_chan.send(ConstellationMsg::WebDriverCommand(cmd_msg)).unwrap();
+
+        match receiver.recv().unwrap() {
+            Ok(is_enabled) => Ok(WebDriverResponse::Generic(ValueResponse::new(is_enabled.to_json()))),
+            Err(_) => Err(WebDriverError::new(ErrorStatus::StaleElementReference, "Element not found"))
+        }
+    }
+
+    fn handle_is_selected(&self, element: &WebElement) -> WebDriverResult<WebDriverResponse> {
+        let pipeline_id = try!(self.root_pipeline());
+
+        let (sender, receiver) = ipc::channel().unwrap();
+
+        let element_id = element.id.clone();
+        let cmd_msg = WebDriverCommandMsg::ScriptCommand(pipeline_id,
+                                                         WebDriverScriptCommand::IsSelected(element_id, sender));
+        self.constellation_chan.send(ConstellationMsg::WebDriverCommand(cmd_msg)).unwrap();
+
+        match receiver.recv().unwrap() {
+            Ok(is_selected) => Ok(WebDriverResponse::Generic(ValueResponse::new(is_selected.to_json()))),
+            Err(_) => Err(WebDriverError::new(ErrorStatus::StaleElementReference, "Element not found"))
+        }
+    }
+
     fn handle_go_back(&self) -> WebDriverResult<WebDriverResponse> {
         self.constellation_chan.send(ConstellationMsg::Navigate(None, NavigationDirection::Back)).unwrap();
         Ok(WebDriverResponse::Void)
@@ -730,6 +781,9 @@ impl WebDriverHandler<ServoExtensionRoute> for Handler {
             WebDriverCommand::NewSession => self.handle_new_session(),
             WebDriverCommand::Get(ref parameters) => self.handle_get(parameters),
             WebDriverCommand::GetCurrentUrl => self.handle_current_url(),
+            WebDriverCommand::GetWindowSize => self.handle_window_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(),
             WebDriverCommand::GoForward => self.handle_go_forward(),
             WebDriverCommand::Refresh => self.handle_refresh(),

components/webdriver_traits/lib.rs

@@ -1,51 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#![crate_name = "webdriver_traits"]
-#![crate_type = "rlib"]
-
-extern crate rustc_serialize;
-use rustc_serialize::json::{Json, ToJson};
-use std::sync::mpsc::Sender;
-
-pub enum WebDriverScriptCommand {
-    ExecuteScript(String, Sender<WebDriverJSResult>),
-    ExecuteAsyncScript(String, Sender<WebDriverJSResult>),
-    FindElementCSS(String, Sender<Result<Option<String>, ()>>),
-    FindElementsCSS(String, Sender<Result<Vec<String>, ()>>),
-    GetActiveElement(Sender<Option<String>>),
-    GetElementTagName(String, Sender<Result<String, ()>>),
-    GetElementText(String, Sender<Result<String, ()>>),
-    GetTitle(Sender<String>)
-}
-
-pub enum WebDriverJSValue {
-    Undefined,
-    Null,
-    Boolean(bool),
-    Number(f64),
-    String(String),
-    // TODO: ObjectValue and WebElementValue
-}
-
-pub enum WebDriverJSError {
-    Timeout,
-    UnknownType
-}
-
-pub type WebDriverJSResult = Result<WebDriverJSValue, WebDriverJSError>;
-
-impl ToJson for WebDriverJSValue {
-    fn to_json(&self) -> Json {
-        match self {
-            &WebDriverJSValue::Undefined => Json::Null,
-            &WebDriverJSValue::Null => Json::Null,
-            &WebDriverJSValue::Boolean(ref x) => x.to_json(),
-            &WebDriverJSValue::Number(ref x) => x.to_json(),
-            &WebDriverJSValue::String(ref x) => x.to_json()
-        }
-    }
-}
-
-pub struct LoadComplete;