Auto merge of #5939 - jdm:websocket, r=jdm

...ets using rust-websocket.

Authors:
Shivaji Vidhale <savidhal@ncsu.edu>
William Galliher <wpgallih@ncsu.edu>
Allen Chen <achen4@ncsu.edu>
Rucha Jogaikar <rsjogaik@ncsu.edu>

<!-- Reviewable:start -->
[<img src="https://reviewable.io/review_button.png" height=40 alt="Review on Reviewable"/>](https://reviewable.io/reviews/servo/servo/5939)
<!-- Reviewable:end -->

components/script/Cargo.toml

@@ -80,3 +80,4 @@ hyper = "0.3"
 cssparser = "0.3.1"
 unicase = "0.1"
 num = "0.1.24"
+websocket = "0.11.0"

components/script/dom/closeevent.rs

@@ -0,0 +1,89 @@
+/* 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/. */
+
+use dom::bindings::cell::DOMRefCell;
+use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
+use dom::bindings::codegen::Bindings::CloseEventBinding;
+use dom::bindings::codegen::Bindings::CloseEventBinding::CloseEventMethods;
+use dom::bindings::codegen::InheritTypes::EventCast;
+use dom::bindings::error::Fallible;
+use dom::bindings::global::GlobalRef;
+use dom::bindings::js::{JSRef,Temporary, Rootable};
+use dom::bindings::utils::reflect_dom_object;
+use dom::event::{Event, EventTypeId, EventBubbles, EventCancelable};
+use script_task::ScriptChan;
+use std::borrow::ToOwned;
+use std::cell::Cell;
+use util::str::DOMString;
+
+
+#[dom_struct]
+pub struct CloseEvent{
+    event: Event,
+    wasClean: Cell<bool>,
+    code: Cell<u16>,
+    reason: DOMRefCell<DOMString>
+}
+
+impl CloseEvent{
+    pub fn new_inherited(type_id: EventTypeId) -> CloseEvent{
+        CloseEvent{
+            event: Event::new_inherited(type_id),
+            wasClean: Cell::new(true),
+            code: Cell::new(0),
+            reason: DOMRefCell::new("".to_owned())
+        }
+    }
+
+    pub fn new(global: GlobalRef,
+               type_: DOMString,
+               bubbles: EventBubbles,
+               cancelable: EventCancelable,
+               wasClean: bool,
+               code: u16,
+               reason: DOMString) -> Temporary<CloseEvent> {
+        let ev = reflect_dom_object(box CloseEvent::new_inherited(EventTypeId::CloseEvent),
+                                    global,
+                                    CloseEventBinding::Wrap);
+        let ev = ev.root();
+        let event: JSRef<Event> = EventCast::from_ref(ev.r());
+        event.InitEvent(type_,
+                        bubbles == EventBubbles::Bubbles,
+                        cancelable == EventCancelable::Cancelable);
+        let ev = ev.r();
+        ev.wasClean.set(wasClean);
+        ev.code.set(code);
+        *ev.reason.borrow_mut() = reason;
+        Temporary::from_rooted(ev)
+    }
+
+    pub fn Constructor(global: GlobalRef,
+                       type_: DOMString,
+                       init: &CloseEventBinding::CloseEventInit) -> Fallible<Temporary<CloseEvent>> {
+        let clean_status = init.wasClean.unwrap_or(true);
+        let cd = init.code.unwrap_or(0);
+        let rsn = match init.reason.as_ref() {
+            Some(reason) => reason.clone(),
+            None => "".to_owned(),
+        };
+        let bubbles = if init.parent.bubbles { EventBubbles::Bubbles } else { EventBubbles::DoesNotBubble };
+        let cancelable = if init.parent.cancelable { EventCancelable::Cancelable } else { EventCancelable::NotCancelable };
+        Ok(CloseEvent::new(global, type_, bubbles, cancelable, clean_status, cd, rsn))
+    }
+}
+
+impl<'a> CloseEventMethods for JSRef<'a, CloseEvent>{
+    fn WasClean(self) -> bool {
+        self.wasClean.get()
+    }
+
+    fn Code(self) -> u16 {
+        self.code.get()
+    }
+
+    fn Reason(self) -> DOMString {
+        let reason = self.reason.borrow();
+        reason.clone()
+    }
+}

components/script/dom/event.rs

@@ -39,7 +39,8 @@ pub enum EventTypeId {
     ProgressEvent,
     StorageEvent,
     UIEvent,
-    ErrorEvent
+    ErrorEvent,
+    CloseEvent
 }
 
 #[derive(PartialEq)]

components/script/dom/mod.rs

@@ -206,6 +206,7 @@ pub mod cssstyledeclaration;
 pub mod domrect;
 pub mod domrectlist;
 pub mod domstringmap;
+pub mod closeevent;
 pub mod comment;
 pub mod console;
 mod create;

components/script/dom/webidls/CloseEvent.webidl

@@ -0,0 +1,17 @@
+/* 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/. */
+
+//https://html.spec.whatwg.org/multipage/#the-closeevent-interfaces
+[Constructor(DOMString type, optional CloseEventInit eventInitDict)/*, Exposed=(Window,Worker)*/]
+interface CloseEvent : Event {
+  readonly attribute boolean wasClean;
+  readonly attribute unsigned short code;
+  readonly attribute DOMString reason;
+};
+
+dictionary CloseEventInit : EventInit {
+  boolean wasClean;
+  unsigned short code;
+  DOMString reason;
+};

components/script/dom/webidls/WebSocket.webidl

@@ -2,26 +2,34 @@
  * 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/. */
 
+enum BinaryType { "blob", "arraybuffer" };
+
 [Constructor(DOMString url)]
 interface WebSocket : EventTarget {
-readonly attribute DOMString url;
-    //attribute DOMString port;
-    //attribute DOMString host;
+    readonly attribute DOMString url;
     //ready state
     const unsigned short CONNECTING = 0;
     const unsigned short OPEN = 1;
     const unsigned short CLOSING = 2;
     const unsigned short CLOSED = 3;
-    //readonly attribute unsigned short readyState;
+    readonly attribute unsigned short readyState;
     //readonly attribute unsigned long bufferedAmount;
+
     //networking
-    //attribute EventHandler onopen;
-    //attribute EventHandler onerror;
-    //attribute EventHandler onclose;
+    attribute EventHandler onopen;
+    attribute EventHandler onerror;
+    attribute EventHandler onclose;
     //readonly attribute DOMString extensions;
     //readonly attribute DOMString protocol;
-    //void send(USVString data);
+    //[Throws] void close([Clamp] optional unsigned short code, optional DOMString reason); //Clamp doesn't work
+    [Throws] void close(optional unsigned short code, optional DOMString reason); //No clamp version - works
+
+    //messaging
+    //attribute EventHandler onmessage;
+    //attribute BinaryType binaryType;
+    [Throws] void send(optional DOMString data);
     //void send(Blob data);
     //void send(ArrayBuffer data);
     //void send(ArrayBufferView data);
+
 };

components/script/dom/websocket.rs

@@ -2,34 +2,137 @@
  * 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 dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::WebSocketBinding;
 use dom::bindings::codegen::Bindings::WebSocketBinding::WebSocketMethods;
-use dom::bindings::error::Fallible;
-use dom::bindings::global::GlobalRef;
-use dom::bindings::js::{Temporary, JSRef};
+use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
+use dom::bindings::codegen::InheritTypes::EventTargetCast;
+use dom::bindings::codegen::InheritTypes::EventCast;
+use dom::bindings::error::{Error, Fallible};
+use dom::bindings::error::Error::InvalidAccess;
+use dom::bindings::error::Error::Syntax;
+use dom::bindings::global::{GlobalField, GlobalRef};
+use dom::bindings::js::{Temporary, JSRef, Rootable};
+use dom::bindings::refcounted::Trusted;
+use dom::bindings::trace::JSTraceable;
 use dom::bindings::utils::reflect_dom_object;
-use dom::eventtarget::{EventTarget, EventTargetTypeId};
+use dom::closeevent::CloseEvent;
+use dom::event::{Event, EventBubbles, EventCancelable, EventHelpers};
+use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
+use script_task::Runnable;
+use script_task::ScriptMsg;
+use std::cell::{Cell, RefCell};
+use std::borrow::ToOwned;
 use util::str::DOMString;
 
-// https://html.spec.whatwg.org/#the-websocket-interface
+use websocket::Message;
+use websocket::ws::sender::Sender as Sender_Object;
+use websocket::client::sender::Sender;
+use websocket::client::receiver::Receiver;
+use websocket::stream::WebSocketStream;
+use websocket::client::request::Url;
+use websocket::Client;
+
+
+#[derive(PartialEq, Copy, Clone)]
+#[jstraceable]
+enum WebSocketRequestState {
+    Connecting = 0,
+    Open = 1,
+    Closing = 2,
+    Closed = 3,
+}
+
+no_jsmanaged_fields!(Sender<WebSocketStream>);
+no_jsmanaged_fields!(Receiver<WebSocketStream>);
+
 #[dom_struct]
 pub struct WebSocket {
     eventtarget: EventTarget,
-    url: DOMString
+    url: DOMString,
+    global: GlobalField,
+    ready_state: Cell<WebSocketRequestState>,
+    sender: RefCell<Option<Sender<WebSocketStream>>>,
+    receiver: RefCell<Option<Receiver<WebSocketStream>>>,
+    failed: Cell<bool>, //Flag to tell if websocket was closed due to failure
+    full: Cell<bool>, //Flag to tell if websocket queue is full
+    clean_close: Cell<bool>, //Flag to tell if the websocket closed cleanly (not due to full or fail)
+    code: Cell<u16>, //Closing code
+    reason: DOMRefCell<DOMString>, //Closing reason
+    data: DOMRefCell<DOMString>, //Data from send - TODO: Remove after buffer is added.
+    sendCloseFrame: Cell<bool>
 }
 
 impl WebSocket {
-    pub fn new_inherited(url: DOMString) -> WebSocket {
+    pub fn new_inherited(global: GlobalRef, url: DOMString) -> WebSocket {
         WebSocket {
             eventtarget: EventTarget::new_inherited(EventTargetTypeId::WebSocket),
-            url: url
+            url: url,
+            global: GlobalField::from_rooted(&global),
+            ready_state: Cell::new(WebSocketRequestState::Connecting),
+            failed: Cell::new(false),
+            sender: RefCell::new(None),
+            receiver: RefCell::new(None),
+            full: Cell::new(false),
+            clean_close: Cell::new(true),
+            code: Cell::new(0),
+            reason: DOMRefCell::new("".to_owned()),
+            data: DOMRefCell::new("".to_owned()),
+            sendCloseFrame: Cell::new(false)
         }
+
     }
 
     pub fn new(global: GlobalRef, url: DOMString) -> Temporary<WebSocket> {
-        reflect_dom_object(box WebSocket::new_inherited(url),
-                           global,
-                           WebSocketBinding::Wrap)
+        /*TODO: This constructor is only a prototype, it does not accomplish the specs
+          defined here:
+          http://html.spec.whatwg.org
+          All 9 items must be satisfied.
+          TODO: This constructor should be responsible for spawning a thread for the
+          receive loop after ws_root.r().Open() - See comment
+        */
+        let ws_root = reflect_dom_object(box WebSocket::new_inherited(global, url),
+                                         global,
+                                         WebSocketBinding::Wrap).root();
+        let ws_root = ws_root.r();
+        let parsed_url = Url::parse(&ws_root.url).unwrap();
+        let request = Client::connect(parsed_url).unwrap();
+        let response = request.send().unwrap();
+        response.validate().unwrap();
+        ws_root.ready_state.set(WebSocketRequestState::Open);
+        //Check to see if ready_state is Closing or Closed and failed = true - means we failed the websocket
+        //if so return without setting any states
+        let ready_state = ws_root.ready_state.get();
+        let failed = ws_root.failed.get();
+        if failed && (ready_state == WebSocketRequestState::Closed || ready_state == WebSocketRequestState::Closing) {
+            //Do nothing else. Let the close finish.
+            return Temporary::from_rooted(ws_root);
+        }
+        let (temp_sender, temp_receiver) = response.begin().split();
+        let mut other_sender = ws_root.sender.borrow_mut();
+        let mut other_receiver = ws_root.receiver.borrow_mut();
+        *other_sender = Some(temp_sender);
+        *other_receiver = Some(temp_receiver);
+
+        //Create everything necessary for starting the open asynchronous task, then begin the task.
+        let global_root = ws_root.global.root();
+        let addr: Trusted<WebSocket> = Trusted::new(global_root.r().get_cx(), ws_root, global_root.r().script_chan().clone());
+        let open_task = box WebSocketTaskHandler::new(addr.clone(), WebSocketTask::Open);
+        global_root.r().script_chan().send(ScriptMsg::RunnableMsg(open_task)).unwrap();
+        //TODO: Spawn thread here for receive loop
+        /*TODO: Add receive loop here and make new thread run this
+          Receive is an infinite loop "similiar" the one shown here:
+          https://github.com/cyderize/rust-websocket/blob/master/examples/client.rs#L64
+          TODO: The receive loop however does need to follow the spec. These are outlined here
+          under "WebSocket message has been received" items 1-5:
+          https://github.com/cyderize/rust-websocket/blob/master/examples/client.rs#L64
+          TODO: The receive loop also needs to dispatch an asynchronous event as stated here:
+          https://github.com/cyderize/rust-websocket/blob/master/examples/client.rs#L64
+          TODO: When the receive loop receives a close message from the server,
+          it confirms the websocket is now closed. This requires the close event
+          to be fired (dispatch_close fires the close event - see implementation below)
+        */
+        Temporary::from_rooted(ws_root)
     }
 
     pub fn Constructor(global: GlobalRef, url: DOMString) -> Fallible<Temporary<WebSocket>> {
@@ -38,8 +141,162 @@ impl WebSocket {
 }
 
 impl<'a> WebSocketMethods for JSRef<'a, WebSocket> {
-    // https://html.spec.whatwg.org/#dom-websocket-url
+    event_handler!(open, GetOnopen, SetOnopen);
+    event_handler!(close, GetOnclose, SetOnclose);
+    event_handler!(error, GetOnerror, SetOnerror);
+
     fn Url(self) -> DOMString {
         self.url.clone()
     }
+
+    fn ReadyState(self) -> u16 {
+        self.ready_state.get() as u16
+    }
+
+    fn Send(self, data: Option<DOMString>)-> Fallible<()>{
+        /*TODO: This is not up to spec see http://html.spec.whatwg.org/multipage/comms.html search for "If argument is a string"
+          TODO: Need to buffer data
+          TODO: bufferedAmount attribute returns the size of the buffer in bytes - this is a required attribute defined in the websocket.webidle file
+          TODO: The send function needs to flag when full by using the following
+          self.full.set(true). This needs to be done when the buffer is full
+        */
+        let mut other_sender = self.sender.borrow_mut();
+        let my_sender = other_sender.as_mut().unwrap();
+        if self.sendCloseFrame.get() { //TODO: Also check if the buffer is full
+            self.sendCloseFrame.set(false);
+            let _ = my_sender.send_message(Message::Close(None));
+            return Ok(());
+        }
+        let _ = my_sender.send_message(Message::Text(data.unwrap()));
+        return Ok(())
+    }
+
+    fn Close(self, code: Option<u16>, reason: Option<DOMString>) -> Fallible<()>{
+        if let Some(code) = code {
+            //Check code is NOT 1000 NOR in the range of 3000-4999 (inclusive)
+            if  code != 1000 && (code < 3000 || code > 4999) {
+                return Err(Error::InvalidAccess);
+            }
+        }
+        if let Some(ref reason) = reason {
+            if reason.as_bytes().len() > 123 { //reason cannot be larger than 123 bytes
+                return Err(Error::Syntax);
+            }
+        }
+
+        match self.ready_state.get() {
+            WebSocketRequestState::Closing | WebSocketRequestState::Closed  => {} //Do nothing
+            WebSocketRequestState::Connecting => { //Connection is not yet established
+                /*By setting the state to closing, the open function
+                  will abort connecting the websocket*/
+                self.ready_state.set(WebSocketRequestState::Closing);
+                self.failed.set(true);
+                self.sendCloseFrame.set(true);
+                //Dispatch send task to send close frame
+                //TODO: Sending here is just empty string, though no string is really needed. Another send, empty send, could be used.
+                let _ = self.Send(None);
+                //Note: After sending the close message, the receive loop confirms a close message from the server and must fire a close event
+            }
+            WebSocketRequestState::Open => {
+                //Closing handshake not started - still in open
+                //Start the closing by setting the code and reason if they exist
+                if let Some(code) = code {
+                    self.code.set(code);
+                }
+                if let Some(reason) = reason {
+                    *self.reason.borrow_mut() = reason;
+                }
+                self.ready_state.set(WebSocketRequestState::Closing);
+                self.sendCloseFrame.set(true);
+                //Dispatch send task to send close frame
+                let _ = self.Send(None);
+                //Note: After sending the close message, the receive loop confirms a close message from the server and must fire a close event
+            }
+        }
+        Ok(()) //Return Ok
+    }
 }
+
+
+pub enum WebSocketTask {
+    Open,
+    Close,
+}
+
+pub struct WebSocketTaskHandler {
+    addr: Trusted<WebSocket>,
+    task: WebSocketTask,
+}
+
+impl WebSocketTaskHandler {
+    pub fn new(addr: Trusted<WebSocket>, task: WebSocketTask) -> WebSocketTaskHandler {
+        WebSocketTaskHandler {
+            addr: addr,
+            task: task,
+        }
+    }
+
+    fn dispatch_open(&self) {
+        /*TODO: Items 1, 3, 4, & 5 under "WebSocket connection is established" as specified here:
+          https://html.spec.whatwg.org/multipage/#feedback-from-the-protocol
+        */
+        let ws = self.addr.to_temporary().root(); //Get root
+        let ws = ws.r(); //Get websocket reference
+        let global = ws.global.root();
+        let event = Event::new(global.r(),
+            "open".to_owned(),
+            EventBubbles::DoesNotBubble,
+            EventCancelable::Cancelable).root();
+        let target: JSRef<EventTarget> = EventTargetCast::from_ref(ws);
+        event.r().fire(target);
+    }
+
+    fn dispatch_close(&self) {
+        let ws = self.addr.to_temporary().root();
+        let ws = ws.r();
+        let global = ws.global.root();
+        ws.ready_state.set(WebSocketRequestState::Closed);
+        //If failed or full, fire error event
+        if ws.failed.get() || ws.full.get() {
+            ws.failed.set(false);
+            ws.full.set(false);
+            //A Bad close
+            ws.clean_close.set(false);
+            let event = Event::new(global.r(),
+                                   "error".to_owned(),
+                                   EventBubbles::DoesNotBubble,
+                                   EventCancelable::Cancelable).root();
+            let target: JSRef<EventTarget> = EventTargetCast::from_ref(ws);
+            event.r().fire(target);
+        }
+        let rsn = ws.reason.borrow();
+        let rsn_clone = rsn.clone();
+        /*In addition, we also have to fire a close even if error event fired
+         https://html.spec.whatwg.org/multipage/#closeWebSocket
+        */
+        let close_event = CloseEvent::new(global.r(),
+                                          "close".to_owned(),
+                                          EventBubbles::DoesNotBubble,
+                                          EventCancelable::Cancelable,
+                                          ws.clean_close.get(),
+                                          ws.code.get(),
+                                          rsn_clone).root();
+        let target: JSRef<EventTarget> = EventTargetCast::from_ref(ws);
+        let event: JSRef<Event> = EventCast::from_ref(close_event.r());
+        event.fire(target);
+    }
+}
+
+impl Runnable for WebSocketTaskHandler {
+    fn handler(self: Box<WebSocketTaskHandler>) {
+        match self.task {
+            WebSocketTask::Open => {
+                self.dispatch_open();
+            }
+            WebSocketTask::Close => {
+                self.dispatch_close();
+            }
+        }
+    }
+}
+

components/script/lib.rs

@@ -44,6 +44,7 @@ extern crate profile_traits;
 extern crate script_traits;
 extern crate selectors;
 extern crate util;
+extern crate websocket;
 #[macro_use]
 extern crate style;
 extern crate unicase;

components/servo/Cargo.lock

@@ -58,6 +58,11 @@ name = "bitflags"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
+[[package]]
+name = "byteorder"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
 [[package]]
 name = "canvas"
 version = "0.0.1"
@@ -1022,6 +1027,7 @@ dependencies = [
  "util 0.0.1",
  "uuid 0.1.16 (git+https://github.com/rust-lang/uuid)",
  "webdriver_traits 0.0.1",
+ "websocket 0.11.8 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -1276,6 +1282,21 @@ dependencies = [
  "rustc-serialize 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "websocket"
+version = "0.11.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "byteorder 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "hyper 0.3.16 (registry+https://github.com/rust-lang/crates.io-index)",
+ "openssl 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-serialize 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicase 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "url 0.2.31 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "winapi"
 version = "0.1.17"

ports/cef/Cargo.lock

@@ -57,6 +57,11 @@ name = "bitflags"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
+[[package]]
+name = "byteorder"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
 [[package]]
 name = "canvas"
 version = "0.0.1"
@@ -1012,6 +1017,7 @@ dependencies = [
  "util 0.0.1",
  "uuid 0.1.16 (git+https://github.com/rust-lang/uuid)",
  "webdriver_traits 0.0.1",
+ "websocket 0.11.8 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -1261,6 +1267,21 @@ dependencies = [
  "rustc-serialize 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "websocket"
+version = "0.11.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "byteorder 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "hyper 0.3.16 (registry+https://github.com/rust-lang/crates.io-index)",
+ "openssl 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-serialize 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicase 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "url 0.2.31 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "winapi"
 version = "0.1.17"

ports/gonk/Cargo.lock

@@ -50,6 +50,11 @@ name = "bitflags"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
+[[package]]
+name = "byteorder"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
 [[package]]
 name = "canvas"
 version = "0.0.1"
@@ -985,6 +990,7 @@ dependencies = [
  "util 0.0.1",
  "uuid 0.1.16 (git+https://github.com/rust-lang/uuid)",
  "webdriver_traits 0.0.1",
+ "websocket 0.11.8 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -1233,6 +1239,21 @@ dependencies = [
  "rustc-serialize 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "websocket"
+version = "0.11.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "byteorder 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "hyper 0.3.16 (registry+https://github.com/rust-lang/crates.io-index)",
+ "openssl 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-serialize 0.3.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicase 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "url 0.2.31 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "winapi"
 version = "0.1.17"

tests/html/test-websocket.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>  
+
+<meta charset="utf-8" />  
+
+<title>WebSocket Test</title>  
+
+<script language="javascript" type="text/javascript">  
+
+var wsUri = "ws://echo.websocket.org/"; 
+var output;  
+
+function init() { 
+	output = document.getElementById("output"); 
+	testWebSocket(); 
+}  
+
+function testWebSocket() { 
+	websocket = new WebSocket(wsUri); 
+	websocket.onopen = function(evt) { 
+		onOpen(evt) 
+	}; 
+	websocket.onclose = function(evt) { 
+		onClose(evt) 
+	}; 
+	websocket.onmessage = function(evt) { 
+		onMessage(evt) 
+	}; 
+	websocket.onerror = function(evt) { 
+		onError(evt) 
+	}; 
+}  
+
+function onOpen(evt) { 
+	writeToScreen("CONNECTED"); 
+	doSend("WebSocket rocks"); 
+}  
+
+function onClose(evt) { 
+	writeToScreen("DISCONNECTED"); 
+}  
+
+function onMessage(evt) { 
+	writeToScreen('<span style="color: blue;">RESPONSE: ' + evt.data+'</span>'); 
+	websocket.close(); 
+}  
+
+function onError(evt) { 
+	writeToScreen('<span style="color: red;">ERROR:</span> ' + evt.data); 
+}  
+
+function doSend(message) { 
+	writeToScreen("SENT: " + message);  
+	websocket.send(message); 
+}  
+
+function writeToScreen(message) { 
+	var pre = document.createElement("p"); 
+	pre.style.wordWrap = "break-word"; 
+	pre.innerHTML = message; 
+	output.appendChild(pre); 
+}  
+
+window.addEventListener("load", init, false);  
+
+</script>  
+
+<h2>WebSocket Test</h2>  
+
+<div id="output"></div> 

tests/wpt/include.ini

@@ -97,5 +97,7 @@ skip: true
   skip: false
 [encoding]
   skip: false
+[websockets]
+  skip: false
 [_mozilla]
   skip: false

tests/wpt/metadata/html/dom/interfaces.html.ini

@@ -8805,21 +8805,9 @@
   [WebSocket interface object length]
     expected: FAIL
 
-  [WebSocket interface: attribute readyState]
-    expected: FAIL
-
   [WebSocket interface: attribute bufferedAmount]
     expected: FAIL
 
-  [WebSocket interface: attribute onopen]
-    expected: FAIL
-
-  [WebSocket interface: attribute onerror]
-    expected: FAIL
-
-  [WebSocket interface: attribute onclose]
-    expected: FAIL
-
   [WebSocket interface: attribute extensions]
     expected: FAIL
 
@@ -8835,39 +8823,12 @@
   [WebSocket interface: attribute binaryType]
     expected: FAIL
 
-  [WebSocket interface: operation send(DOMString)]
-    expected: FAIL
-
-  [WebSocket interface: operation send(Blob)]
-    expected: FAIL
-
-  [WebSocket interface: operation send(ArrayBuffer)]
-    expected: FAIL
-
-  [WebSocket interface: operation send(ArrayBufferView)]
-    expected: FAIL
-
   [CloseEvent interface: existence and properties of interface object]
     expected: FAIL
 
   [CloseEvent interface object length]
     expected: FAIL
 
-  [CloseEvent interface: existence and properties of interface prototype object]
-    expected: FAIL
-
-  [CloseEvent interface: existence and properties of interface prototype object's "constructor" property]
-    expected: FAIL
-
-  [CloseEvent interface: attribute wasClean]
-    expected: FAIL
-
-  [CloseEvent interface: attribute code]
-    expected: FAIL
-
-  [CloseEvent interface: attribute reason]
-    expected: FAIL
-
   [MessageChannel interface: existence and properties of interface object]
     expected: FAIL
 

tests/wpt/metadata/websockets/Close-1000-reason.htm.ini

@@ -0,0 +1,6 @@
+[Close-1000-reason.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create WebSocket - Close the Connection - close(1000, reason) - readyState should be in CLOSED state and wasClean is TRUE - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Close-1000.htm.ini

@@ -0,0 +1,6 @@
+[Close-1000.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create WebSocket - Close the Connection - close(1000) - readyState should be in CLOSED state and wasClean is TRUE - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Close-reason-unpaired-surrogates.htm.ini

@@ -0,0 +1,3 @@
+[Close-reason-unpaired-surrogates.htm]
+  type: testharness
+  expected: TIMEOUT

tests/wpt/metadata/websockets/Close-undefined.htm.ini

@@ -0,0 +1,5 @@
+[Close-undefined.htm]
+  type: testharness
+  [W3C WebSocket API - Close WebSocket - Code is undefined]
+    expected: FAIL
+

tests/wpt/metadata/websockets/Create-Secure-blocked-port.htm.ini

@@ -0,0 +1,3 @@
+[Create-Secure-blocked-port.htm]
+  type: testharness
+  expected: TIMEOUT

tests/wpt/metadata/websockets/Create-Secure-extensions-empty.htm.ini

@@ -0,0 +1,9 @@
+[Create-Secure-extensions-empty.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - wsocket.extensions should be set to '' after connection is established - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create Secure WebSocket - wsocket.extensions should be set to '' after connection is established - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Create-Secure-url-with-space.htm.ini

@@ -0,0 +1,3 @@
+[Create-Secure-url-with-space.htm]
+  type: testharness
+  expected: TIMEOUT

tests/wpt/metadata/websockets/Create-Secure-valid-url-array-protocols.htm.ini

@@ -0,0 +1,9 @@
+[Create-Secure-valid-url-array-protocols.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Pass a valid URL and array of protocol strings - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create Secure WebSocket - Pass a valid URL and array of protocol strings - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Create-Secure-valid-url-binaryType-blob.htm.ini

@@ -0,0 +1,9 @@
+[Create-Secure-valid-url-binaryType-blob.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - wsocket.binaryType should be set to 'blob' after connection is established - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create Secure WebSocket - wsocket.binaryType should be set to 'blob' after connection is established - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Create-Secure-valid-url-protocol-setCorrectly.htm.ini

@@ -0,0 +1,9 @@
+[Create-Secure-valid-url-protocol-setCorrectly.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Pass a valid URL and protocol string - protocol should be set correctly - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create Secure WebSocket - Pass a valid URL and protocol string - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Create-Secure-valid-url-protocol-string.htm.ini

@@ -0,0 +1,9 @@
+[Create-Secure-valid-url-protocol-string.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Check readyState is 1]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create Secure WebSocket - Pass a valid URL and protocol string - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Create-Secure-valid-url.htm.ini

@@ -0,0 +1,9 @@
+[Create-Secure-valid-url.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Pass a valid URL  - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create Secure WebSocket - Pass a valid URL - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Create-Secure-verify-url-set-non-default-port.htm.ini

@@ -0,0 +1,3 @@
+[Create-Secure-verify-url-set-non-default-port.htm]
+  type: testharness
+  expected: TIMEOUT

tests/wpt/metadata/websockets/Create-invalid-urls.htm.ini

@@ -0,0 +1,3 @@
+[Create-invalid-urls.htm]
+  type: testharness
+  expected: TIMEOUT

tests/wpt/metadata/websockets/Create-non-absolute-url.htm.ini

@@ -0,0 +1,3 @@
+[Create-non-absolute-url.htm]
+  type: testharness
+  expected: TIMEOUT

tests/wpt/metadata/websockets/Create-nonAscii-protocol-string.htm.ini

@@ -0,0 +1,5 @@
+[Create-nonAscii-protocol-string.htm]
+  type: testharness
+  [W3C WebSocket API - Create WebSocket - Pass a valid URL and a protocol string with non-ascii values - SYNTAX_ERR is thrown]
+    expected: FAIL
+

tests/wpt/metadata/websockets/Create-protocol-with-space.htm.ini

@@ -0,0 +1,5 @@
+[Create-protocol-with-space.htm]
+  type: testharness
+  [W3C WebSocket API - Create WebSocket - Pass a valid URL and a protocol string with a space in it - SYNTAX_ERR is thrown]
+    expected: FAIL
+

tests/wpt/metadata/websockets/Create-protocols-repeated.htm.ini

@@ -0,0 +1,5 @@
+[Create-protocols-repeated.htm]
+  type: testharness
+  [W3C WebSocket API - Create WebSocket - Pass a valid URL and an array of protocol strings with repeated values - SYNTAX_ERR is thrown]
+    expected: FAIL
+

tests/wpt/metadata/websockets/Create-valid-url-array-protocols.htm.ini

@@ -0,0 +1,6 @@
+[Create-valid-url-array-protocols.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create WebSocket - Pass a valid URL and array of protocol strings - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Create-valid-url-protocol-empty.htm.ini

@@ -0,0 +1,5 @@
+[Create-valid-url-protocol-empty.htm]
+  type: testharness
+  [W3C WebSocket API - Create WebSocket - wsocket.protocol should be empty before connection is established]
+    expected: FAIL
+

tests/wpt/metadata/websockets/Create-valid-url-protocol.htm.ini

@@ -0,0 +1,6 @@
+[Create-valid-url-protocol.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create WebSocket - Pass a valid URL and a protocol string - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Create-valid-url.htm.ini

@@ -0,0 +1,6 @@
+[Create-valid-url.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create WebSocket - Pass a valid URL - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Create-wrong-scheme.htm.ini

@@ -0,0 +1,3 @@
+[Create-wrong-scheme.htm]
+  type: testharness
+  expected: TIMEOUT

tests/wpt/metadata/websockets/Secure-Close-0.htm.ini

@@ -0,0 +1,6 @@
+[Secure-Close-0.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(0) - INVALID_ACCESS_ERR is thrown]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-1000-reason.htm.ini

@@ -0,0 +1,9 @@
+[Secure-Close-1000-reason.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(1000, reason) - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(1000, reason) - readyState should be in CLOSED state and wasClean is TRUE - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-1000-verify-code.htm.ini

@@ -0,0 +1,9 @@
+[Secure-Close-1000-verify-code.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(1000, reason) - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(1000, reason) - event.code == 1000 and event.reason = 'Clean Close']
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-1000.htm.ini

@@ -0,0 +1,9 @@
+[Secure-Close-1000.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(1000) - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(1000) - readyState should be in CLOSED state and wasClean is TRUE - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-1005-verify-code.htm.ini

@@ -0,0 +1,9 @@
+[Secure-Close-1005-verify-code.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close() - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close() - return close code is 1005 - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-1005.htm.ini

@@ -0,0 +1,6 @@
+[Secure-Close-1005.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(1005) - see '7.1.5.  The WebSocket Connection Close Code' in http://www.ietf.org/rfc/rfc6455.txt]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-2999-reason.htm.ini

@@ -0,0 +1,6 @@
+[Secure-Close-2999-reason.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(2999, reason) - INVALID_ACCESS_ERR is thrown]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-3000-reason.htm.ini

@@ -0,0 +1,9 @@
+[Secure-Close-3000-reason.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(3000, reason) - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(3000, reason) - readyState should be in CLOSED state and wasClean is TRUE - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-3000-verify-code.htm.ini

@@ -0,0 +1,9 @@
+[Secure-Close-3000-verify-code.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(3000, reason) - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(3000, reason) - verify return code is 3000 - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-4999-reason.htm.ini

@@ -0,0 +1,9 @@
+[Secure-Close-4999-reason.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(4999, reason) - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(4999, reason) - readyState should be in CLOSED state and wasClean is TRUE - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-NaN.htm.ini

@@ -0,0 +1,6 @@
+[Secure-Close-NaN.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create WebSocket - Close the Connection - close(NaN) - INVALID_ACCESS_ERR is thrown]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-Reason-124Bytes.htm.ini

@@ -0,0 +1,6 @@
+[Secure-Close-Reason-124Bytes.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(code, 'reason more than 123 bytes') - SYNTAX_ERR is thrown]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-Reason-Unpaired-surrogates.htm.ini

@@ -0,0 +1,9 @@
+[Secure-Close-Reason-Unpaired-surrogates.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(reason with unpaired surrogates) - connection should get opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(reason with unpaired surrogates) - connection should get closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-null.htm.ini

@@ -0,0 +1,6 @@
+[Secure-Close-null.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create WebSocket - Close the Connection - close(null) - INVALID_ACCESS_ERR is thrown]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-onlyReason.htm.ini

@@ -0,0 +1,6 @@
+[Secure-Close-onlyReason.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - close(only reason) - INVALID_ACCESS_ERR is thrown]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-readyState-Closed.htm.ini

@@ -0,0 +1,9 @@
+[Secure-Close-readyState-Closed.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - readyState should be in CLOSED state and wasClean is TRUE - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-readyState-Closing.htm.ini

@@ -0,0 +1,6 @@
+[Secure-Close-readyState-Closing.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Close the Connection - readyState should be in CLOSING state just before onclose is called]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-server-initiated-close.htm.ini

@@ -0,0 +1,9 @@
+[Secure-Close-server-initiated-close.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create Secure WebSocket - Server initiated Close - Client sends back a CLOSE - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create Secure WebSocket - Server initiated Close - Client sends back a CLOSE - readyState should be in CLOSED state and wasClean is TRUE - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-string.htm.ini

@@ -0,0 +1,6 @@
+[Secure-Close-string.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create WebSocket - Close the Connection - close(string) - INVALID_ACCESS_ERR is thrown]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Close-undefined.htm.ini

@@ -0,0 +1,6 @@
+[Secure-Close-undefined.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Close Secure WebSocket - Code is undefined]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Send-65K-data.htm.ini

@@ -0,0 +1,12 @@
+[Secure-Send-65K-data.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send  65K data on a Secure WebSocket - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send 65K data on a Secure WebSocket - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send 65K data on a Secure WebSocket - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Send-binary-65K-arraybuffer.htm.ini

@@ -0,0 +1,12 @@
+[Secure-Send-binary-65K-arraybuffer.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send 65K binary data on a Secure WebSocket - ArrayBuffer - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send 65K binary data on a Secure WebSocket - ArrayBuffer - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send 65K binary data on a Secure WebSocket - ArrayBuffer - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Send-binary-arraybuffer.htm.ini

@@ -0,0 +1,12 @@
+[Secure-Send-binary-arraybuffer.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send binary data on a Secure WebSocket - ArrayBuffer - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a Secure WebSocket - ArrayBuffer - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a Secure WebSocket - ArrayBuffer - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Send-binary-arraybufferview-float32.htm.ini

@@ -0,0 +1,9 @@
+[Secure-Send-binary-arraybufferview-float32.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Float32Array - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Float32Array - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Send-binary-arraybufferview-float64.htm.ini

@@ -0,0 +1,12 @@
+[Secure-Send-binary-arraybufferview-float64.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Float64Array - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Float64Array - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Float64Array - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Send-binary-arraybufferview-int32.htm.ini

@@ -0,0 +1,12 @@
+[Secure-Send-binary-arraybufferview-int32.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Int32Array - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Int32Array - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Int32Array - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Send-binary-arraybufferview-uint16-offset-length.htm.ini

@@ -0,0 +1,12 @@
+[Secure-Send-binary-arraybufferview-uint16-offset-length.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Uint16Array with offset and length - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Uint16Array with offset and length - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Uint16Array with offset and length - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Send-binary-arraybufferview-uint32-offset.htm.ini

@@ -0,0 +1,12 @@
+[Secure-Send-binary-arraybufferview-uint32-offset.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Uint32Array with offset - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Uint32Array with offset - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Uint32Array with offset - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Send-binary-arraybufferview-uint8-offset-length.htm.ini

@@ -0,0 +1,12 @@
+[Secure-Send-binary-arraybufferview-uint8-offset-length.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Uint8Array with offset and length - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Uint8Array with offset and length - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Uint8Array with offset and length - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Send-binary-arraybufferview-uint8-offset.htm.ini

@@ -0,0 +1,12 @@
+[Secure-Send-binary-arraybufferview-uint8-offset.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Uint8Array with offset - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Uint8Array with offset - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Uint8Array with offset - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Send-binary-blob.htm.ini

@@ -0,0 +1,12 @@
+[Secure-Send-binary-blob.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send binary data on a Secure WebSocket - Blob - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a Secure WebSocket - Blob - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a Secure WebSocket - Blob - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Send-data.htm.ini

@@ -0,0 +1,12 @@
+[Secure-Send-data.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send  data on a Secure WebSocket - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send data on a Secure WebSocket - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send data on a Secure WebSocket - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Send-null.htm.ini

@@ -0,0 +1,12 @@
+[Secure-Send-null.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send null data on a Secure WebSocket - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send null data on a Secure WebSocket - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send null data on a Secure WebSocket - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Send-paired-surrogates.htm.ini

@@ -0,0 +1,12 @@
+[Secure-Send-paired-surrogates.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send paired surrogates data on a Secure WebSocket - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send paired surrogates data on a Secure WebSocket - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send paired surrogates data on a Secure WebSocket - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Send-unicode-data.htm.ini

@@ -0,0 +1,12 @@
+[Secure-Send-unicode-data.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send  unicode data on a Secure WebSocket - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send unicode data on a Secure WebSocket - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send unicode data on a Secure WebSocket - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Secure-Send-unpaired-surrogates.htm.ini

@@ -0,0 +1,12 @@
+[Secure-Send-unpaired-surrogates.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send unpaired surrogates on a Secure WebSocket - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send unpaired surrogates on a Secure WebSocket - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send unpaired surrogates on a Secure WebSocket - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Send-0byte-data.htm.ini

@@ -0,0 +1,12 @@
+[Send-0byte-data.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send 0 byte data on a WebSocket - Connection should be opened]
+    expected: FAIL
+
+  [W3C WebSocket API - Send 0 byte data on a WebSocket - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send 0 byte data on a WebSocket - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Send-65K-data.htm.ini

@@ -0,0 +1,12 @@
+[Send-65K-data.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send 65K data on a WebSocket -  Connection should be opened]
+    expected: FAIL
+
+  [W3C WebSocket API - Send 65K data on a WebSocket - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send 65K data on a WebSocket - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Send-Unpaired-Surrogates.htm.ini

@@ -0,0 +1,3 @@
+[Send-Unpaired-Surrogates.htm]
+  type: testharness
+  expected: TIMEOUT

tests/wpt/metadata/websockets/Send-before-open.htm.ini

@@ -0,0 +1,5 @@
+[Send-before-open.htm]
+  type: testharness
+  [W3C WebSocket API - Send data on a WebSocket before connection is opened - INVALID_STATE_ERR is returned]
+    expected: FAIL
+

tests/wpt/metadata/websockets/Send-binary-65K-arraybuffer.htm.ini

@@ -0,0 +1,12 @@
+[Send-binary-65K-arraybuffer.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send 65K binary data on a WebSocket - ArrayBuffer - Connection should be opened]
+    expected: FAIL
+
+  [W3C WebSocket API - Send 65K binary data on a WebSocket - ArrayBuffer - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send 65K binary data on a WebSocket - ArrayBuffer - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Send-binary-arraybuffer.htm.ini

@@ -0,0 +1,12 @@
+[Send-binary-arraybuffer.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBuffer - Connection should be opened]
+    expected: FAIL
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBuffer - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBuffer - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Send-binary-arraybufferview-int16-offset.htm.ini

@@ -0,0 +1,9 @@
+[Send-binary-arraybufferview-int16-offset.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Int16Array with offset - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Int16Array with offset - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Send-binary-arraybufferview-int8.htm.ini

@@ -0,0 +1,9 @@
+[Send-binary-arraybufferview-int8.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Int8Array - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - ArrayBufferView - Int8Array - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Send-binary-blob.htm.ini

@@ -0,0 +1,9 @@
+[Send-binary-blob.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send binary data on a WebSocket - Blob - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send binary data on a WebSocket - Blob - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Send-data.htm.ini

@@ -0,0 +1,12 @@
+[Send-data.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send data on a WebSocket - Connection should be opened]
+    expected: FAIL
+
+  [W3C WebSocket API - Send data on a WebSocket - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send data on a WebSocket - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Send-null.htm.ini

@@ -0,0 +1,9 @@
+[Send-null.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send null data on a WebSocket - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send null data on a WebSocket - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Send-paired-surrogates.htm.ini

@@ -0,0 +1,12 @@
+[Send-paired-surrogates.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send (paired surrogates) data on a WebSocket - Connection should be opened]
+    expected: FAIL
+
+  [W3C WebSocket API - Send (paired surrogates) data on a WebSocket - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send (paired surrogates) data on a WebSocket - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/Send-unicode-data.htm.ini

@@ -0,0 +1,12 @@
+[Send-unicode-data.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Send unicode data on a WebSocket - Connection should be opened]
+    expected: FAIL
+
+  [W3C WebSocket API - Send unicode data on a WebSocket - Message should be received]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Send unicode data on a WebSocket - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/binary/001.html.ini

@@ -0,0 +1,6 @@
+[001.html]
+  type: testharness
+  expected: TIMEOUT
+  [WebSockets: Send/Receive blob, blob size less than network array buffer]
+    expected: TIMEOUT
+

tests/wpt/metadata/websockets/binary/002.html.ini

@@ -0,0 +1,5 @@
+[002.html]
+  type: testharness
+  [WebSockets: Send/Receive blob, blob size greater than network array buffer]
+    expected: TIMEOUT
+

tests/wpt/metadata/websockets/binary/004.html.ini

@@ -0,0 +1,5 @@
+[004.html]
+  type: testharness
+  [WebSockets: Send/Receive ArrayBuffer, size greater than network array buffer]
+    expected: TIMEOUT
+

tests/wpt/metadata/websockets/binary/005.html.ini

@@ -0,0 +1,6 @@
+[005.html]
+  type: testharness
+  expected: TIMEOUT
+  [WebSockets: Send/Receive ArrayBuffer, size less than network array buffer]
+    expected: TIMEOUT
+

tests/wpt/metadata/websockets/binaryType-wrong-value.htm.ini

@@ -0,0 +1,9 @@
+[binaryType-wrong-value.htm]
+  type: testharness
+  expected: TIMEOUT
+  [W3C WebSocket API - Create WebSocket - set binaryType to something other than blob or arraybuffer - SYNTAX_ERR is returned - Connection should be opened]
+    expected: NOTRUN
+
+  [W3C WebSocket API - Create WebSocket - set binaryType to something other than blob or arraybuffer - SYNTAX_ERR is returned - Connection should be closed]
+    expected: NOTRUN
+

tests/wpt/metadata/websockets/closing-handshake/002.html.ini

@@ -0,0 +1,6 @@
+[002.html]
+  type: testharness
+  expected: TIMEOUT
+  [WebSockets: server sends closing handshake]
+    expected: TIMEOUT
+

tests/wpt/metadata/websockets/closing-handshake/003.html.ini

@@ -0,0 +1,6 @@
+[003.html]
+  type: testharness
+  expected: TIMEOUT
+  [WebSockets: client sends closing handshake]
+    expected: TIMEOUT
+

tests/wpt/metadata/websockets/closing-handshake/004.html.ini

@@ -0,0 +1,6 @@
+[004.html]
+  type: testharness
+  expected: TIMEOUT
+  [WebSockets: data after closing handshake]
+    expected: TIMEOUT
+

tests/wpt/metadata/websockets/constructor/002.html.ini

@@ -0,0 +1,3 @@
+[002.html]
+  type: testharness
+  expected: TIMEOUT

tests/wpt/metadata/websockets/constructor/004.html.ini

@@ -0,0 +1,3 @@
+[004.html]
+  type: testharness
+  expected: TIMEOUT

tests/wpt/metadata/websockets/constructor/005.html.ini

@@ -0,0 +1,3 @@
+[005.html]
+  type: testharness
+  expected: TIMEOUT

tests/wpt/metadata/websockets/constructor/006.html.ini

@@ -0,0 +1,3 @@
+[006.html]
+  type: testharness
+  expected: TIMEOUT

tests/wpt/metadata/websockets/constructor/007.html.ini

@@ -0,0 +1,3 @@
+[007.html]
+  type: testharness
+  expected: TIMEOUT

tests/wpt/metadata/websockets/constructor/008.html.ini

@@ -0,0 +1,3 @@
+[008.html]
+  type: testharness
+  expected: TIMEOUT