Use common cookie struct add cookie webdriver cmds

One cookie struct to rule them all. One struct to represent them.
One cookie struct to bind them all, and through the IPC carry them.

components/webdriver_server/lib.rs

@@ -10,6 +10,7 @@
 
 #![deny(unsafe_code)]
 
+extern crate cookie as cookie_rs;
 extern crate euclid;
 extern crate hyper;
 extern crate image;
@@ -32,7 +33,8 @@ use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
 use keys::keycodes_to_keys;
 use msg::constellation_msg::{FrameId, LoadData, PipelineId};
 use msg::constellation_msg::{NavigationDirection, PixelFormat, WebDriverCommandMsg};
-use msg::webdriver_msg::{LoadStatus, WebDriverFrameId, WebDriverJSError, WebDriverJSResult, WebDriverScriptCommand};
+use msg::webdriver_msg::{LoadStatus, WebDriverCookieError, WebDriverFrameId};
+use msg::webdriver_msg::{WebDriverJSError, WebDriverJSResult, WebDriverScriptCommand};
 use regex::Captures;
 use rustc_serialize::base64::{CharacterSet, Config, Newline, ToBase64};
 use rustc_serialize::json::{Json, ToJson};
@@ -47,13 +49,15 @@ use url::Url;
 use util::prefs::{get_pref, reset_all_prefs, reset_pref, set_pref, PrefValue};
 use util::thread::spawn_named;
 use uuid::Uuid;
-use webdriver::command::{GetParameters, JavascriptCommandParameters, LocatorParameters};
-use webdriver::command::{Parameters, SendKeysParameters, SwitchToFrameParameters};
-use webdriver::command::{TimeoutsParameters, WindowSizeParameters};
+use webdriver::command::WindowSizeParameters;
+use webdriver::command::{AddCookieParameters, GetParameters, JavascriptCommandParameters};
+use webdriver::command::{LocatorParameters, Parameters};
+use webdriver::command::{SendKeysParameters, SwitchToFrameParameters, TimeoutsParameters};
 use webdriver::command::{WebDriverCommand, WebDriverExtensionCommand, WebDriverMessage};
-use webdriver::common::{LocatorStrategy, WebElement};
+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::{ElementRectResponse, NewSessionResponse, ValueResponse};
 use webdriver::response::{WebDriverResponse, WindowSizeResponse};
 use webdriver::server::{self, Session, WebDriverHandler};
@@ -64,6 +68,25 @@ fn extension_routes() -> Vec<(Method, &'static str, ServoExtensionRoute)> {
                 (Post, "/session/{sessionId}/servo/prefs/reset", ServoExtensionRoute::ResetPrefs)]
 }
 
+fn cookie_msg_to_cookie(cookie: cookie_rs::Cookie) -> Cookie {
+    Cookie {
+        name: cookie.name,
+        value: cookie.value,
+        path: cookie.path.map(Nullable::Value).unwrap_or(Nullable::Null),
+        domain: cookie.domain.map(Nullable::Value).unwrap_or(Nullable::Null),
+        expiry: match cookie.expires {
+            Some(time) => Nullable::Value(Date::new(time.to_timespec().sec as u64)),
+            None => Nullable::Null
+        },
+        maxAge: match cookie.max_age {
+            Some(time) => Nullable::Value(Date::new(time)),
+            None => Nullable::Null
+        },
+        secure: cookie.secure,
+        httpOnly: cookie.httponly,
+    }
+}
+
 pub fn start_server(port: u16, constellation_chan: Sender<ConstellationMsg>) {
     let handler = Handler::new(constellation_chan);
     spawn_named("WebdriverHttpServer".to_owned(), move || {
@@ -615,6 +638,51 @@ impl Handler {
         }
     }
 
+    fn handle_get_cookies(&self) -> WebDriverResult<WebDriverResponse> {
+        let (sender, receiver) = ipc::channel().unwrap();
+        try!(self.frame_script_command(WebDriverScriptCommand::GetCookies(sender)));
+        let cookies = receiver.recv().unwrap();
+        let response = cookies.into_iter().map(|cookie| {
+            cookie_msg_to_cookie(cookie)
+        }).collect::<Vec<Cookie>>();
+        Ok(WebDriverResponse::Cookie(CookieResponse::new(response)))
+    }
+
+    fn handle_get_cookie(&self, name: &str) -> WebDriverResult<WebDriverResponse> {
+        let (sender, receiver) = ipc::channel().unwrap();
+        try!(self.frame_script_command(WebDriverScriptCommand::GetCookie(name.to_owned(), sender)));
+        let cookies = receiver.recv().unwrap();
+        let response = cookies.into_iter().map(|cookie| {
+            cookie_msg_to_cookie(cookie)
+        }).collect::<Vec<Cookie>>();
+        Ok(WebDriverResponse::Cookie(CookieResponse::new(response)))
+    }
+
+    fn handle_add_cookie(&self, params: &AddCookieParameters) -> WebDriverResult<WebDriverResponse> {
+        let (sender, receiver) = ipc::channel().unwrap();
+        let cookie = cookie_rs::Cookie {
+            name: params.name.to_owned(),
+            value: params.value.to_owned(),
+            path: params.path.to_owned().into(),
+            domain: params.domain.to_owned().into(),
+            expires: None,
+            max_age: None,
+            secure: params.secure,
+            httponly: params.httpOnly,
+            custom: BTreeMap::new()
+        };
+        try!(self.frame_script_command(WebDriverScriptCommand::AddCookie(cookie, sender)));
+        match receiver.recv().unwrap() {
+            Ok(_) => Ok(WebDriverResponse::Void),
+            Err(response) => match response {
+                WebDriverCookieError::InvalidDomain => Err(WebDriverError::new(ErrorStatus::InvalidCookieDomain,
+                                                                               "Invalid cookie domain")),
+                WebDriverCookieError::UnableToSetCookie => Err(WebDriverError::new(ErrorStatus::UnableToSetCookie,
+                                                                                   "Unable to set cookie"))
+            }
+        }
+    }
+
     fn handle_set_timeouts(&mut self, parameters: &TimeoutsParameters) -> WebDriverResult<WebDriverResponse> {
         //TODO: this conversion is crazy, spec should limit these to u32 and check upstream
         let value = parameters.ms as u32;
@@ -790,6 +858,7 @@ impl WebDriverHandler<ServoExtensionRoute> for Handler {
         match msg.command {
             WebDriverCommand::NewSession => self.handle_new_session(),
             WebDriverCommand::DeleteSession => self.handle_delete_session(),
+            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(),
@@ -806,6 +875,8 @@ impl WebDriverHandler<ServoExtensionRoute> for Handler {
             WebDriverCommand::SwitchToParentFrame => self.handle_switch_to_parent_frame(),
             WebDriverCommand::FindElement(ref parameters) => self.handle_find_element(parameters),
             WebDriverCommand::FindElements(ref parameters) => self.handle_find_elements(parameters),
+            WebDriverCommand::GetCookie(ref name) => self.handle_get_cookie(name),
+            WebDriverCommand::GetCookies => self.handle_get_cookies(),
             WebDriverCommand::GetActiveElement => self.handle_active_element(),
             WebDriverCommand::GetElementRect(ref element) => self.handle_element_rect(element),
             WebDriverCommand::GetElementText(ref element) => self.handle_element_text(element),