convert script crate to use hyper

8 files changed, 382 insertions, 260 deletions

diff --git a/components/net/resource_task.rs b/components/net/resource_task.rs
index 60ad9c8578b..0c473d42676 100644
--- a/components/net/resource_task.rs
+++ b/components/net/resource_task.rs
@@ -221,7 +221,7 @@ impl ResourceManager {
 
     fn load(&self, load_data: LoadData) {
         let mut load_data = load_data;
-        self.user_agent.map(|ref ua| load_data.headers.set(UserAgent(ua.clone())));
+        self.user_agent.as_ref().map(|ua| load_data.headers.set(UserAgent(ua.clone())));
         let senders = ResponseSenders {
             immediate_consumer: self.sniffer_task.clone(),
             eventual_consumer: load_data.consumer.clone(),
diff --git a/components/script/Cargo.toml b/components/script/Cargo.toml
index f2adbed80c1..667aa76d7f9 100644
--- a/components/script/Cargo.toml
+++ b/components/script/Cargo.toml
@@ -52,8 +52,8 @@ branch = "servo"
 [dependencies.encoding]
 git = "https://github.com/lifthrasiir/rust-encoding"
 
-[dependencies.http]
-git = "https://github.com/servo/rust-http"
+[dependencies.hyper]
+git = "https://github.com/hyperium/hyper"
 branch = "servo"
 
 [dependencies.js]
diff --git a/components/script/cors.rs b/components/script/cors.rs
index 50e69ca333f..abd99af36d2 100644
--- a/components/script/cors.rs
+++ b/components/script/cors.rs
@@ -9,23 +9,21 @@
 //! This library will eventually become the core of the Fetch crate
 //! with CORSRequest being expanded into FetchRequest (etc)
 
-use std::ascii::{AsciiExt, OwnedAsciiExt};
-use std::from_str::FromStr;
-use std::io::BufReader;
+use std::ascii::AsciiExt;
+use std::fmt::{mod, Show};
+use std::str::from_utf8;
 use time;
 use time::{now, Timespec};
 
-use http::headers::response::HeaderCollection as ResponseHeaderCollection;
-use http::headers::request::HeaderCollection as RequestHeaderCollection;
-use http::headers::request::Header as RequestHeader;
+use hyper::header::{Headers, Header, HeaderFormat, HeaderView};
+use hyper::header::common::util as header_util;
+use hyper::client::Request;
+use hyper::mime::{mod, Mime};
+use hyper::header::common::{ContentType, Host};
+use hyper::method::{Method, Get, Head, Post, Options};
+use hyper::status::Success;
 
-use http::client::{RequestWriter, NetworkStream};
-use http::headers::{HeaderConvertible, HeaderEnum, HeaderValueByteIterator};
-use http::headers::content_type::MediaType;
-use http::headers::request::{Accept, AcceptLanguage, ContentLanguage, ContentType};
-use http::method::{Method, Get, Head, Post, Options};
-
-use url::{RelativeSchemeData, Url, UrlParser};
+use url::{RelativeSchemeData, Url};
 
 #[deriving(Clone)]
 pub struct CORSRequest {
@@ -33,7 +31,7 @@ pub struct CORSRequest {
     pub destination: Url,
     pub mode: RequestMode,
     pub method: Method,
-    pub headers: RequestHeaderCollection,
+    pub headers: Headers,
     /// CORS preflight flag (http://fetch.spec.whatwg.org/#concept-http-fetch)
     /// Indicates that a CORS preflight request and/or cache check is to be performed
     pub preflight_flag: bool
@@ -51,7 +49,7 @@ pub enum RequestMode {
 impl CORSRequest {
     /// Creates a CORS request if necessary. Will return an error when fetching is forbidden
     pub fn maybe_new(referer: Url, destination: Url, mode: RequestMode,
-                     method: Method, headers: RequestHeaderCollection) -> Result<Option<CORSRequest>, ()> {
+                     method: Method, headers: Headers) -> Result<Option<CORSRequest>, ()> {
         if referer.scheme == destination.scheme &&
            referer.host() == destination.host() &&
            referer.port() == destination.port() {
@@ -73,7 +71,7 @@ impl CORSRequest {
     }
 
     fn new(mut referer: Url, destination: Url, mode: RequestMode, method: Method,
-           headers: RequestHeaderCollection) -> CORSRequest {
+           headers: Headers) -> CORSRequest {
         match referer.scheme_data {
             RelativeSchemeData(ref mut data) => data.path = vec!(),
             _ => {}
@@ -104,7 +102,7 @@ impl CORSRequest {
         let cache = &mut CORSCache(vec!()); // XXXManishearth Should come from user agent
         if self.preflight_flag &&
            !cache.match_method(self, &self.method) &&
-           !self.headers.iter().all(|h| is_simple_header(&h) && cache.match_header(self, h.header_name().as_slice())) {
+           !self.headers.iter().all(|h| is_simple_header(&h) && cache.match_header(self, h.name())) {
             if !is_simple_method(&self.method) || self.mode == ForcedPreflightMode {
                 return self.preflight_fetch();
                 // Everything after this is part of XHR::fetch()
@@ -121,69 +119,63 @@ impl CORSRequest {
 
         let mut preflight = self.clone(); // Step 1
         preflight.method = Options; // Step 2
-        preflight.headers = RequestHeaderCollection::new(); // Step 3
+        preflight.headers = Headers::new(); // Step 3
         // Step 4
-        preflight.insert_string_header("Access-Control-Request-Method".to_string(), self.method.http_value());
+        preflight.headers.set(AccessControlRequestMethod(self.method.clone()));
 
         // Step 5 - 7
         let mut header_names = vec!();
         for header in self.headers.iter() {
-            header_names.push(header.header_name().into_ascii_lower());
+            header_names.push(header.name().to_ascii_lower());
         }
         header_names.sort();
-        let header_list = header_names.connect(", "); // 0x2C 0x20
-        preflight.insert_string_header("Access-Control-Request-Headers".to_string(), header_list);
+        preflight.headers.set(AccessControlRequestHeaders(header_names));
 
         // Step 8 unnecessary, we don't use the request body
         // Step 9, 10 unnecessary, we're writing our own fetch code
 
         // Step 11
-        let preflight_request = RequestWriter::<NetworkStream>::new(preflight.method, preflight.destination);
-        let mut writer = match preflight_request {
-            Ok(w) => box w,
+        let preflight_request = Request::new(preflight.method, preflight.destination);
+        let mut req = match preflight_request {
+            Ok(req) => req,
             Err(_) => return error
         };
 
-        let host = writer.headers.host.clone();
-        writer.headers = preflight.headers.clone();
-        writer.headers.host = host;
-        let response = match writer.read_response() {
+        let host = req.headers().get::<Host>().unwrap().clone();
+        *req.headers_mut() = preflight.headers.clone();
+        req.headers_mut().set(host);
+        let stream = match req.start() {
+            Ok(s) => s,
+            Err(_) => return error
+        };
+        let response = match stream.send() {
             Ok(r) => r,
             Err(_) => return error
         };
 
         // Step 12
-        match response.status.code() {
-         200 ... 299 => {}
-         _ => return error
+        match response.status.class() {
+            Success => {}
+            _ => return error
         }
         cors_response.headers = response.headers.clone();
         // Substeps 1-3 (parsing rules: http://fetch.spec.whatwg.org/#http-new-header-syntax)
-        fn find_header(headers: &ResponseHeaderCollection, name: &str) -> Option<String> {
-            headers.iter().find(|h| h.header_name().as_slice()
-                                                   .eq_ignore_ascii_case(name))
-                                    .map(|h| h.header_value())
-        }
-        let methods_string = match find_header(&response.headers, "Access-Control-Allow-Methods") {
-            Some(s) => s,
+        let mut methods = match response.headers.get() {
+            Some(&AccessControlAllowMethods(ref v)) => v.as_slice(),
             _ => return error
         };
-        let methods = methods_string.as_slice().split(',');
-        let headers_string = match find_header(&response.headers, "Access-Control-Allow-Headers") {
-            Some(s) => s,
+        let headers = match response.headers.get() {
+            Some(&AccessControlAllowHeaders(ref h)) => h,
             _ => return error
         };
-        let headers = headers_string.as_slice().split(0x2Cu8 as char);
-        // The ABNF # rule will consider consecutive delimeters as a single delimeter
-        let mut methods: Vec<String> = methods.filter(|s| s.len() > 0).map(|s| s.to_string()).collect();
-        let headers: Vec<String> = headers.filter(|s| s.len() > 0).map(|s| s.to_string()).collect();
         // Substep 4
+        let methods_substep4 = [self.method.clone()];
         if methods.len() == 0 || preflight.mode == ForcedPreflightMode {
-            methods = vec!(self.method.http_value());
+            methods = methods_substep4.as_slice();
         }
         // Substep 5
         if !is_simple_method(&self.method) &&
-           !methods.iter().any(|ref m| self.method.http_value().as_slice().eq_ignore_ascii_case(m.as_slice())) {
+           !methods.iter().any(|m| m == &self.method) {
            return error;
         }
         // Substep 6
@@ -191,30 +183,29 @@ impl CORSRequest {
             if is_simple_header(&h) {
                 continue;
             }
-            if !headers.iter().any(|ref h2| h.header_name().as_slice().eq_ignore_ascii_case(h2.as_slice())) {
+            if !headers.iter().any(|ref h2| h.name().eq_ignore_ascii_case(h2.as_slice())) {
                 return error;
             }
         }
         // Substep 7, 8
-        let max_age: uint = find_header(&response.headers, "Access-Control-Max-Age")
-                                .and_then(|h| FromStr::from_str(h.as_slice())).unwrap_or(0);
+        let max_age = match response.headers.get() {
+            Some(&AccessControlMaxAge(num)) => num,
+            None => 0
+        };
         // Substep 9: Impose restrictions on max-age, if any (unimplemented)
         // Substeps 10-12: Add a cache (partially implemented, XXXManishearth)
         // This cache should come from the user agent, creating a new one here to check
         // for compile time errors
         let cache = &mut CORSCache(vec!());
         for m in methods.iter() {
-            let maybe_method: Option<Method> = FromStr::from_str(m.as_slice());
-            maybe_method.map(|ref m| {
-                let cache_match = cache.match_method_and_update(self, m, max_age);
-                if !cache_match {
-                    cache.insert(CORSCacheEntry::new(self.origin.clone(), self.destination.clone(),
-                                                     max_age, false, MethodData(m.clone())));
-                }
-            });
+            let cache_match = cache.match_method_and_update(self, m, max_age);
+            if !cache_match {
+                cache.insert(CORSCacheEntry::new(self.origin.clone(), self.destination.clone(),
+                                                 max_age, false, MethodData(m.clone())));
+            }
         }
-        for h in headers.iter() {
-            let cache_match = cache.match_header_and_update(self, h.as_slice(), max_age);
+        for h in response.headers.iter() {
+            let cache_match = cache.match_header_and_update(self, h.name(), max_age);
             if !cache_match {
                 cache.insert(CORSCacheEntry::new(self.origin.clone(), self.destination.clone(),
                                                  max_age, false, HeaderData(h.to_string())));
@@ -222,35 +213,26 @@ impl CORSRequest {
         }
         cors_response
     }
-
-    fn insert_string_header(&mut self, name: String, value: String) {
-        let value_bytes = value.into_bytes();
-        let mut reader = BufReader::new(value_bytes.as_slice());
-        let maybe_header: Option<RequestHeader> = HeaderEnum::value_from_stream(
-                                                                String::from_str(name.as_slice()),
-                                                                &mut HeaderValueByteIterator::new(&mut reader));
-        self.headers.insert(maybe_header.unwrap());
-    }
 }
 
 
 pub struct CORSResponse {
     pub network_error: bool,
-    pub headers: ResponseHeaderCollection
+    pub headers: Headers
 }
 
 impl CORSResponse {
     fn new() -> CORSResponse {
         CORSResponse {
             network_error: false,
-            headers: ResponseHeaderCollection::new()
+            headers: Headers::new()
         }
     }
 
     fn new_error() -> CORSResponse {
          CORSResponse {
             network_error: true,
-            headers: ResponseHeaderCollection::new()
+            headers: Headers::new()
         }
     }
 }
@@ -290,14 +272,14 @@ impl HeaderOrMethod {
 pub struct CORSCacheEntry {
     pub origin: Url,
     pub url: Url,
-    pub max_age: uint,
+    pub max_age: u32,
     pub credentials: bool,
     pub header_or_method: HeaderOrMethod,
     created: Timespec
 }
 
 impl CORSCacheEntry {
-    fn new (origin:Url, url: Url, max_age: uint, credentials: bool, header_or_method: HeaderOrMethod) -> CORSCacheEntry {
+    fn new (origin:Url, url: Url, max_age: u32, credentials: bool, header_or_method: HeaderOrMethod) -> CORSCacheEntry {
         CORSCacheEntry {
             origin: origin,
             url: url,
@@ -343,7 +325,7 @@ impl CORSCache {
         self.find_entry_by_header(request, header_name).is_some()
     }
 
-    fn match_header_and_update(&mut self, request: &CORSRequest, header_name: &str, new_max_age: uint) -> bool {
+    fn match_header_and_update(&mut self, request: &CORSRequest, header_name: &str, new_max_age: u32) -> bool {
         self.find_entry_by_header(request, header_name).map(|e| e.max_age = new_max_age).is_some()
     }
 
@@ -365,7 +347,7 @@ impl CORSCache {
         self.find_entry_by_method(request, method).is_some()
     }
 
-    fn match_method_and_update(&mut self, request: &CORSRequest, method: &Method, new_max_age: uint) -> bool {
+    fn match_method_and_update(&mut self, request: &CORSRequest, method: &Method, new_max_age: u32) -> bool {
         self.find_entry_by_method(request, method).map(|e| e.max_age = new_max_age).is_some()
     }
 
@@ -376,12 +358,18 @@ impl CORSCache {
     }
 }
 
-fn is_simple_header(h: &RequestHeader) -> bool {
-    match *h {
-        Accept(_) | AcceptLanguage(_) | ContentLanguage(_) => true,
-        ContentType(MediaType {type_: ref t, subtype: ref s, ..}) => match (t.as_slice(), s.as_slice()) {
-            ("text", "plain") | ("application", "x-www-form-urlencoded") | ("multipart", "form-data") => true,
+fn is_simple_header(h: &HeaderView) -> bool {
+    //FIXME: use h.is::<HeaderType>() when AcceptLanguage and
+    //ContentLanguage headers exist
+    match h.name().to_ascii_lower().as_slice() {
+        "accept" | "accept-language" | "content-language" => true,
+        "content-type" => match h.value() {
+            Some(&ContentType(Mime(mime::Text, mime::Plain, _))) |
+            Some(&ContentType(Mime(mime::Application, mime::WwwFormUrlEncoded, _))) |
+            Some(&ContentType(Mime(mime::Multipart, mime::FormData, _))) => true,
+
             _ => false
+
         },
         _ => false
     }
@@ -394,25 +382,160 @@ fn is_simple_method(m: &Method) -> bool {
     }
 }
 
+//XXX(seanmonstar): worth uplifting to Hyper?
+#[deriving(Clone)]
+struct AccessControlRequestMethod(pub Method);
+
+impl Header for AccessControlRequestMethod {
+    #[inline]
+    fn header_name(_: Option<AccessControlRequestMethod>) -> &'static str {
+        "Access-Control-Request-Method"
+    }
+
+    fn parse_header(raw: &[Vec<u8>]) -> Option<AccessControlRequestMethod> {
+        header_util::from_one_raw_str(raw).map(AccessControlRequestMethod)
+    }
+}
+
+impl HeaderFormat for AccessControlRequestMethod {
+    fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let AccessControlRequestMethod(ref method) = *self;
+        method.fmt(f)
+    }
+}
+
+#[deriving(Clone)]
+struct AccessControlRequestHeaders(pub Vec<String>);
+
+impl Header for AccessControlRequestHeaders {
+    #[inline]
+    fn header_name(_: Option<AccessControlRequestHeaders>) -> &'static str {
+        "Access-Control-Request-Headers"
+    }
+
+    fn parse_header(raw: &[Vec<u8>]) -> Option<AccessControlRequestHeaders> {
+        header_util::from_comma_delimited(raw).map(AccessControlRequestHeaders)
+    }
+}
+
+impl HeaderFormat for AccessControlRequestHeaders {
+    fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let AccessControlRequestHeaders(ref parts) = *self;
+        header_util::fmt_comma_delimited(f, parts.as_slice())
+    }
+}
+
+#[deriving(Clone)]
+struct AccessControlAllowMethods(pub Vec<Method>);
+
+impl Header for AccessControlAllowMethods {
+    #[inline]
+    fn header_name(_: Option<AccessControlAllowMethods>) -> &'static str {
+        "Access-Control-Allow-Methods"
+    }
+
+    fn parse_header(raw: &[Vec<u8>]) -> Option<AccessControlAllowMethods> {
+        header_util::from_comma_delimited(raw).map(AccessControlAllowMethods)
+    }
+}
+
+impl HeaderFormat for AccessControlAllowMethods {
+    fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let AccessControlAllowMethods(ref parts) = *self;
+        header_util::fmt_comma_delimited(f, parts.as_slice())
+    }
+}
+
+#[deriving(Clone)]
+struct AccessControlAllowHeaders(pub Vec<String>);
+
+impl Header for AccessControlAllowHeaders {
+    #[inline]
+    fn header_name(_: Option<AccessControlAllowHeaders>) -> &'static str {
+        "Access-Control-Allow-Headers"
+    }
+
+    fn parse_header(raw: &[Vec<u8>]) -> Option<AccessControlAllowHeaders> {
+        header_util::from_comma_delimited(raw).map(AccessControlAllowHeaders)
+    }
+}
+
+impl HeaderFormat for AccessControlAllowHeaders {
+    fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let AccessControlAllowHeaders(ref parts) = *self;
+        header_util::fmt_comma_delimited(f, parts.as_slice())
+    }
+}
+
+#[deriving(Clone)]
+enum AccessControlAllowOrigin {
+    AllowStar,
+    AllowOrigin(Url),
+}
+
+
+impl Header for AccessControlAllowOrigin {
+    #[inline]
+    fn header_name(_: Option<AccessControlAllowOrigin>) -> &'static str {
+        "Access-Control-Allow-Origin"
+    }
+
+    fn parse_header(raw: &[Vec<u8>]) -> Option<AccessControlAllowOrigin> {
+        if raw.len() == 1 {
+            from_utf8(raw[0].as_slice()).and_then(|s| {
+                if s == "*" {
+                    Some(AllowStar)
+                } else {
+                    Url::parse(s).ok().map(|url| AllowOrigin(url))
+                }
+            })
+        } else {
+            None
+        }
+    }
+}
+
+impl HeaderFormat for AccessControlAllowOrigin {
+    fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            AllowStar => "*".fmt(f),
+            AllowOrigin(ref url) => url.fmt(f)
+        }
+    }
+}
+
+#[deriving(Clone)]
+struct AccessControlMaxAge(pub u32);
+
+impl Header for AccessControlMaxAge {
+    #[inline]
+    fn header_name(_: Option<AccessControlMaxAge>) -> &'static str {
+        "Access-Control-Max-Age"
+    }
+
+    fn parse_header(raw: &[Vec<u8>]) -> Option<AccessControlMaxAge> {
+        header_util::from_one_raw_str(raw).map(AccessControlMaxAge)
+    }
+}
+
+impl HeaderFormat for AccessControlMaxAge {
+    fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let AccessControlMaxAge(ref num) = *self;
+        num.fmt(f)
+    }
+}
+
+
 /// Perform a CORS check on a header list and CORS request
 /// http://fetch.spec.whatwg.org/#cors-check
-pub fn allow_cross_origin_request(req: &CORSRequest, headers: &ResponseHeaderCollection) -> bool {
-    let allow_cross_origin_request =  headers.iter().find(|h| h.header_name()
-                                                               .as_slice()
-                                                               .eq_ignore_ascii_case("Access-Control-Allow-Origin"));
-    match allow_cross_origin_request {
-        Some(h) => {
-            let origin_str = h.header_value();
-            if origin_str.as_slice() == "*" {
-                return true; // Not always true, depends on credentials mode
-            }
-            match UrlParser::new().parse(origin_str.as_slice()) {
-                Ok(parsed) => parsed.scheme == req.origin.scheme &&
-                              parsed.host() == req.origin.host() &&
-                              parsed.port() == req.origin.port(),
-                _ => false
-            }
-        },
+pub fn allow_cross_origin_request(req: &CORSRequest, headers: &Headers) -> bool {
+    //FIXME(seanmonstar): use req.headers.get::<AccessControlAllowOrigin>()
+    match headers.get() {
+        Some(&AllowStar) => true, // Not always true, depends on credentials mode
+        Some(&AllowOrigin(ref url)) =>
+            url.scheme == req.origin.scheme &&
+            url.host() == req.origin.host() &&
+            url.port() == req.origin.port(),
         None => false
     }
 }
diff --git a/components/script/dom/bindings/trace.rs b/components/script/dom/bindings/trace.rs
index a6362baa71c..afd329137c0 100644
--- a/components/script/dom/bindings/trace.rs
+++ b/components/script/dom/bindings/trace.rs
@@ -34,9 +34,8 @@ use dom::node::{Node, TrustedNodeAddress};
 use collections::hash::{Hash, Hasher};
 use geom::rect::Rect;
 use html5ever::tree_builder::QuirksMode;
-use http::headers::request::HeaderCollection as RequestHeaderCollection;
-use http::headers::response::HeaderCollection as ResponseHeaderCollection;
-use http::method::Method;
+use hyper::header::Headers;
+use hyper::method::Method;
 use js::jsapi::{JSObject, JSTracer, JS_CallTracer, JSTRACE_OBJECT};
 use js::jsval::JSVal;
 use js::rust::Cx;
@@ -209,7 +208,7 @@ no_jsmanaged_fields!(PropertyDeclarationBlock)
 no_jsmanaged_fields!(SubpageId, WindowSizeData, PipelineId)
 no_jsmanaged_fields!(QuirksMode)
 no_jsmanaged_fields!(Cx)
-no_jsmanaged_fields!(ResponseHeaderCollection, RequestHeaderCollection, Method)
+no_jsmanaged_fields!(Headers, Method)
 no_jsmanaged_fields!(ConstellationChan)
 no_jsmanaged_fields!(LayoutChan)
 no_jsmanaged_fields!(WindowProxyHandler)
diff --git a/components/script/dom/htmlformelement.rs b/components/script/dom/htmlformelement.rs
index 699b1c9f8b0..a8461618db9 100644
--- a/components/script/dom/htmlformelement.rs
+++ b/components/script/dom/htmlformelement.rs
@@ -20,7 +20,7 @@ use dom::eventtarget::{EventTarget, NodeTargetTypeId};
 use dom::htmlelement::HTMLElement;
 use dom::htmlinputelement::HTMLInputElement;
 use dom::node::{Node, NodeHelpers, ElementNodeTypeId, document_from_node, window_from_node};
-use http::method::Post;
+use hyper::method::Post;
 use servo_msg::constellation_msg::LoadData;
 use servo_util::str::DOMString;
 use script_task::{ScriptChan, TriggerLoadMsg};
diff --git a/components/script/dom/xmlhttprequest.rs b/components/script/dom/xmlhttprequest.rs
index d93bff9ab90..7d2d31efebb 100644
--- a/components/script/dom/xmlhttprequest.rs
+++ b/components/script/dom/xmlhttprequest.rs
@@ -29,13 +29,11 @@ use encoding::all::UTF_8;
 use encoding::label::encoding_from_whatwg_label;
 use encoding::types::{DecodeReplace, Encoding, EncodingRef, EncodeReplace};
 
-use http::headers::response::HeaderCollection as ResponseHeaderCollection;
-use http::headers::request::HeaderCollection as RequestHeaderCollection;
-use http::headers::content_type::MediaType;
-use http::headers::{HeaderEnum, HeaderValueByteIterator};
-use http::headers::request::Header;
-use http::method::{Method, Get, Head, Connect, Trace, ExtensionMethod};
-use http::status::Status;
+use hyper::header::Headers;
+use hyper::header::common::{Accept, ContentLength, ContentType};
+use hyper::http::RawStatus;
+use hyper::mime::{mod, Mime};
+use hyper::method::{Method, Get, Head, Connect, Trace, Extension};
 
 use js::jsapi::{JS_AddObjectRoot, JS_ParseJSON, JS_RemoveObjectRoot, JSContext};
 use js::jsapi::JS_ClearPendingException;
@@ -54,7 +52,7 @@ use std::ascii::AsciiExt;
 use std::cell::Cell;
 use std::comm::{Sender, Receiver, channel};
 use std::default::Default;
-use std::io::{BufReader, MemWriter, Timer};
+use std::io::Timer;
 use std::from_str::FromStr;
 use std::time::duration::Duration;
 use std::num::Zero;
@@ -88,7 +86,7 @@ pub struct GenerationId(uint);
 
 pub enum XHRProgress {
     /// Notify that headers have been received
-    HeadersReceivedMsg(GenerationId, Option<ResponseHeaderCollection>, Option<Status>),
+    HeadersReceivedMsg(GenerationId, Option<Headers>, Option<RawStatus>),
     /// Partial progress (after receiving headers), containing portion of the response
     LoadingMsg(GenerationId, ByteString),
     /// Loading is done
@@ -131,12 +129,12 @@ pub struct XMLHttpRequest {
     response: DOMRefCell<ByteString>,
     response_type: Cell<XMLHttpRequestResponseType>,
     response_xml: MutNullableJS<Document>,
-    response_headers: DOMRefCell<ResponseHeaderCollection>,
+    response_headers: DOMRefCell<Headers>,
 
     // Associated concepts
     request_method: DOMRefCell<Method>,
     request_url: DOMRefCell<Option<Url>>,
-    request_headers: DOMRefCell<RequestHeaderCollection>,
+    request_headers: DOMRefCell<Headers>,
     request_body_len: Cell<uint>,
     sync: Cell<bool>,
     upload_complete: Cell<bool>,
@@ -165,11 +163,11 @@ impl XMLHttpRequest {
             response: DOMRefCell::new(ByteString::new(vec!())),
             response_type: Cell::new(_empty),
             response_xml: Default::default(),
-            response_headers: DOMRefCell::new(ResponseHeaderCollection::new()),
+            response_headers: DOMRefCell::new(Headers::new()),
 
             request_method: DOMRefCell::new(Get),
             request_url: DOMRefCell::new(None),
-            request_headers: DOMRefCell::new(RequestHeaderCollection::new()),
+            request_headers: DOMRefCell::new(Headers::new()),
             request_body_len: Cell::new(0),
             sync: Cell::new(false),
             send_flag: Cell::new(false),
@@ -345,28 +343,26 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
     }
 
     fn Open(self, method: ByteString, url: DOMString) -> ErrorResult {
-        let uppercase_method = method.as_str().map(|s| {
+        //FIXME(seanmonstar): use a Trie instead?
+        let maybe_method = method.as_str().and_then(|s| {
+            // Note: hyper tests against the uppercase versions
+            // Since we want to pass methods not belonging to the short list above
+            // without changing capitalization, this will actually sidestep rust-http's type system
+            // since methods like "patch" or "PaTcH" will be considered extension methods
+            // despite the there being a rust-http method variant for them
             let upper = s.to_ascii_upper();
             match upper.as_slice() {
                 "DELETE" | "GET" | "HEAD" | "OPTIONS" |
                 "POST" | "PUT" | "CONNECT" | "TRACE" |
-                "TRACK" => upper,
-                _ => s.to_string()
+                "TRACK" => from_str(upper.as_slice()),
+                _ => from_str(s)
             }
         });
-        let maybe_method: Option<Method> = uppercase_method.and_then(|s| {
-            // Note: rust-http tests against the uppercase versions
-            // Since we want to pass methods not belonging to the short list above
-            // without changing capitalization, this will actually sidestep rust-http's type system
-            // since methods like "patch" or "PaTcH" will be considered extension methods
-            // despite the there being a rust-http method variant for them
-            Method::from_str_or_new(s.as_slice())
-        });
         // Step 2
         match maybe_method {
             // Step 4
             Some(Connect) | Some(Trace) => Err(Security),
-            Some(ExtensionMethod(ref t)) if t.as_slice() == "TRACK" => Err(Security),
+            Some(Extension(ref t)) if t.as_slice() == "TRACK" => Err(Security),
             Some(_) if method.is_token() => {
 
                 *self.request_method.borrow_mut() = maybe_method.unwrap();
@@ -389,7 +385,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
 
                 // Step 12
                 *self.request_url.borrow_mut() = Some(parsed_url);
-                *self.request_headers.borrow_mut() = RequestHeaderCollection::new();
+                *self.request_headers.borrow_mut() = Headers::new();
                 self.send_flag.set(false);
                 *self.status_text.borrow_mut() = ByteString::new(vec!());
                 self.status.set(0);
@@ -417,7 +413,8 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
         if !name.is_token() || !value.is_field_value() {
             return Err(Syntax); // Step 3, 4
         }
-        let name_str = match name.to_lower().as_str() {
+        let name_lower = name.to_lower();
+        let name_str = match name_lower.as_str() {
             Some(s) => {
                 match s {
                     // Disallowed headers
@@ -431,48 +428,31 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
                     "upgrade" | "user-agent" | "via" => {
                         return Ok(()); // Step 5
                     },
-                    _ => String::from_str(s)
+                    _ => s
                 }
             },
             None => return Err(Syntax)
         };
-        let mut collection = self.request_headers.borrow_mut();
-
 
-        // Steps 6,7
-        let old_header = collection.iter().find(|ref h| -> bool {
-            // XXXManishearth following line waiting on the rust upgrade:
-            ByteString::new(h.header_name().into_bytes()).eq_ignore_case(&value)
-        });
-        match old_header {
-            Some(h) => {
-                unsafe {
-                    // By step 4, the value is a subset of valid utf8
-                    // So this unsafe block should never fail
+        debug!("SetRequestHeader: name={}, value={}", name.as_str(), value.as_str());
+        let mut headers = self.request_headers.borrow_mut();
 
-                    let mut buf = h.header_value();
-                    buf.as_mut_vec().push_all(&[0x2C, 0x20]);
-                    buf.as_mut_vec().push_all(value.as_slice());
-                    value = ByteString::new(buf.into_bytes());
 
-                }
+        // Steps 6,7
+        match headers.get_raw(name_str) {
+            Some(raw) => {
+                debug!("SetRequestHeader: old value = {}", raw[0]);
+                let mut buf = raw[0].clone();
+                buf.push_all(b", ");
+                buf.push_all(value.as_slice());
+                debug!("SetRequestHeader: new value = {}", buf);
+                value = ByteString::new(buf);
             },
             None => {}
         }
 
-        let mut reader = BufReader::new(value.as_slice());
-        let maybe_header: Option<Header> = HeaderEnum::value_from_stream(
-                                                            name_str,
-                                                            &mut HeaderValueByteIterator::new(&mut reader));
-        match maybe_header {
-            Some(h) => {
-                // Overwrites existing headers, which we want since we have
-                // prepended the new header value with the old one already
-                collection.insert(h);
-                Ok(())
-            },
-            None => Err(Syntax)
-        }
+        headers.set_raw(name_str.into_string(), vec![value.as_slice().to_vec()]);
+        Ok(())
     }
     fn Timeout(self) -> u32 {
         self.timeout.get()
@@ -562,29 +542,37 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
         load_data.data = extracted;
 
         // Default headers
-        let ref request_headers = self.request_headers;
-        if request_headers.borrow().content_type.is_none() {
-            let parameters = vec!((String::from_str("charset"), String::from_str("UTF-8")));
-            request_headers.borrow_mut().content_type = match data {
-                Some(eString(_)) =>
-                    Some(MediaType {
-                        type_: String::from_str("text"),
-                        subtype: String::from_str("plain"),
-                        parameters: parameters
-                    }),
-                Some(eURLSearchParams(_)) =>
-                    Some(MediaType {
-                        type_: String::from_str("application"),
-                        subtype: String::from_str("x-www-form-urlencoded"),
-                        parameters: parameters
-                    }),
-                None => None
+        {
+            #[inline]
+            fn join_raw(a: &str, b: &str) -> Vec<u8> {
+                let len = a.len() + b.len();
+                let mut vec = Vec::with_capacity(len);
+                vec.push_all(a.as_bytes());
+                vec.push_all(b.as_bytes());
+                vec
+            }
+            let ref mut request_headers = self.request_headers.borrow_mut();
+            if !request_headers.has::<ContentType>() {
+                // XHR spec differs from http, and says UTF-8 should be in capitals,
+                // instead of "utf-8", which is what Hyper defaults to.
+                let params = ";charset=UTF-8";
+                let n = "content-type";
+                match data {
+                    Some(eString(_)) =>
+                        request_headers.set_raw(n, vec![join_raw("text/plain", params)]),
+                    Some(eURLSearchParams(_)) =>
+                        request_headers.set_raw(
+                            n, vec![join_raw("application/x-www-form-urlencoded", params)]),
+                    None => ()
+                }
             }
-        }
 
-        if request_headers.borrow().accept.is_none() {
-            request_headers.borrow_mut().accept = Some(String::from_str("*/*"))
-        }
+
+            if !request_headers.has::<Accept>() {
+                request_headers.set(
+                    Accept(vec![Mime(mime::TopStar, mime::SubStar, vec![])]));
+            }
+        } // drops the borrow_mut
 
         load_data.headers = (*self.request_headers.borrow()).clone();
         load_data.method = (*self.request_method.borrow()).clone();
@@ -611,13 +599,15 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
                     buf.push_str(format!("{:u}", p).as_slice());
                 });
                 referer_url.serialize_path().map(|ref h| buf.push_str(h.as_slice()));
-                self.request_headers.borrow_mut().referer = Some(buf);
+                self.request_headers.borrow_mut().set_raw("Referer".to_string(), vec![buf.into_bytes()]);
             },
             Ok(Some(ref req)) => self.insert_trusted_header("origin".to_string(),
                                                             format!("{}", req.origin)),
             _ => {}
         }
 
+        debug!("request_headers = {}", *self.request_headers.borrow());
+
         let gen_id = self.generation_id.get();
         if self.sync.get() {
             return XMLHttpRequest::fetch(&mut Sync(self), resource_task, load_data,
@@ -678,22 +668,13 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
     }
     fn GetResponseHeader(self, name: ByteString) -> Option<ByteString> {
         self.filter_response_headers().iter().find(|h| {
-            name.eq_ignore_case(&FromStr::from_str(h.header_name().as_slice()).unwrap())
+            name.eq_ignore_case(&FromStr::from_str(h.name()).unwrap())
         }).map(|h| {
-            // rust-http doesn't decode properly, we'll convert it back to bytes here
-            ByteString::new(h.header_value().as_slice().chars().map(|c| { assert!(c <= '\u00FF'); c as u8 }).collect())
+            ByteString::new(h.value_string().into_bytes())
         })
     }
     fn GetAllResponseHeaders(self) -> ByteString {
-        let mut writer = MemWriter::new();
-        self.filter_response_headers().write_all(&mut writer).ok().expect("Writing response headers failed");
-        let mut vec = writer.unwrap();
-
-        // rust-http appends an extra "\r\n" when using write_all
-        vec.pop();
-        vec.pop();
-
-        ByteString::new(vec)
+        ByteString::new(self.filter_response_headers().to_string().into_bytes())
     }
     fn ResponseType(self) -> XMLHttpRequestResponseType {
         self.response_type.get()
@@ -797,7 +778,7 @@ trait PrivateXMLHttpRequestHelpers {
     fn text_response(self) -> DOMString;
     fn set_timeout(self, timeout:u32);
     fn cancel_timeout(self);
-    fn filter_response_headers(self) -> ResponseHeaderCollection;
+    fn filter_response_headers(self) -> Headers;
 }
 
 impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
@@ -876,17 +857,12 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
                 // Part of step 13, send() (processing response)
                 // XXXManishearth handle errors, if any (substep 1)
                 // Substep 2
-                let status_text = status.as_ref().map_or(vec![], |s| s.reason().into_bytes());
-                let status_code = status.as_ref().map_or(0, |s| s.code());
-
-                *self.status_text.borrow_mut() = ByteString::new(status_text);
-                self.status.set(status_code);
-                match headers {
-                    Some(ref h) => {
-                        *self.response_headers.borrow_mut() = h.clone();
-                    }
-                    None => {}
-                };
+                status.map(|RawStatus(code, reason)| {
+                    self.status.set(code);
+                    *self.status_text.borrow_mut() = ByteString::new(reason.into_bytes());
+                });
+                headers.as_ref().map(|h| *self.response_headers.borrow_mut() = h.clone());
+
                 // Substep 3
                 if !self.sync.get() {
                     self.change_ready_state(HeadersReceived);
@@ -965,13 +941,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
     fn insert_trusted_header(self, name: String, value: String) {
         // Insert a header without checking spec-compliance
         // Use for hardcoded headers
-        let mut collection = self.request_headers.borrow_mut();
-        let value_bytes = value.into_bytes();
-        let mut reader = BufReader::new(value_bytes.as_slice());
-        let maybe_header: Option<Header> = HeaderEnum::value_from_stream(
-                                                                String::from_str(name.as_slice()),
-                                                                &mut HeaderValueByteIterator::new(&mut reader));
-        collection.insert(maybe_header.unwrap());
+        self.request_headers.borrow_mut().set_raw(name, vec![value.into_bytes()]);
     }
 
     fn dispatch_progress_event(self, upload: bool, type_: DOMString, loaded: u64, total: Option<u64>) {
@@ -999,7 +969,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
 
     fn dispatch_response_progress_event(self, type_: DOMString) {
         let len = self.response.borrow().len() as u64;
-        let total = self.response_headers.borrow().content_length.map(|x| {x as u64});
+        let total = self.response_headers.borrow().get::<ContentLength>().map(|x| {x.len() as u64});
         self.dispatch_progress_event(false, type_, len, total);
     }
     fn set_timeout(self, timeout: u32) {
@@ -1030,30 +1000,49 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
 
     fn text_response(self) -> DOMString {
         let mut encoding = UTF_8 as EncodingRef;
-        match self.response_headers.borrow().content_type {
-            Some(ref x) => {
-                for &(ref name, ref value) in x.parameters.iter() {
-                    if name.as_slice().eq_ignore_ascii_case("charset") {
-                        encoding = encoding_from_whatwg_label(value.as_slice()).unwrap_or(encoding);
+        match self.response_headers.borrow().get() {
+            Some(&ContentType(mime::Mime(_, _, ref params))) => {
+                for &(ref name, ref value) in params.iter() {
+                    if name == &mime::Charset {
+                        encoding = encoding_from_whatwg_label(value.to_string().as_slice()).unwrap_or(encoding);
                     }
                 }
             },
             None => {}
         }
+
         // According to Simon, decode() should never return an error, so unwrap()ing
         // the result should be fine. XXXManishearth have a closer look at this later
         encoding.decode(self.response.borrow().as_slice(), DecodeReplace).unwrap().to_string()
     }
-    fn filter_response_headers(self) -> ResponseHeaderCollection {
+    fn filter_response_headers(self) -> Headers {
         // http://fetch.spec.whatwg.org/#concept-response-header-list
-        let mut headers = ResponseHeaderCollection::new();
-        for header in self.response_headers.borrow().iter() {
-            match header.header_name().as_slice().to_ascii_lower().as_slice() {
-                "set-cookie" | "set-cookie2" => {},
-                // XXXManishearth additional CORS filtering goes here
-                _ => headers.insert(header)
-            };
+        use std::fmt;
+        use hyper::header::{Header, HeaderFormat};
+        use hyper::header::common::SetCookie;
+
+        // a dummy header so we can use headers.remove::<SetCookie2>()
+        #[deriving(Clone)]
+        struct SetCookie2;
+        impl Header for SetCookie2 {
+            fn header_name(_: Option<SetCookie2>) -> &'static str {
+                "set-cookie2"
+            }
+
+            fn parse_header(_: &[Vec<u8>]) -> Option<SetCookie2> {
+                unimplemented!()
+            }
         }
+        impl HeaderFormat for SetCookie2 {
+            fn fmt_header(&self, _f: &mut fmt::Formatter) -> fmt::Result {
+                unimplemented!()
+            }
+        }
+
+        let mut headers = self.response_headers.borrow().clone();
+        headers.remove::<SetCookie>();
+        headers.remove::<SetCookie2>();
+        // XXXManishearth additional CORS filtering goes here
         headers
     }
 }
diff --git a/components/script/lib.rs b/components/script/lib.rs
index 3470cd63652..6699ff49d5d 100644
--- a/components/script/lib.rs
+++ b/components/script/lib.rs
@@ -22,7 +22,7 @@ extern crate collections;
 extern crate geom;
 extern crate html5ever;
 extern crate encoding;
-extern crate http;
+extern crate hyper;
 extern crate js;
 extern crate libc;
 extern crate msg;
diff --git a/components/script/parse/html.rs b/components/script/parse/html.rs
index 53a54e11f66..70ffc76e6d9 100644
--- a/components/script/parse/html.rs
+++ b/components/script/parse/html.rs
@@ -28,43 +28,60 @@ use servo_util::task_state;
 use servo_util::task_state::IN_HTML_PARSER;
 use std::ascii::AsciiExt;
 use std::comm::channel;
+use std::fmt::{mod, Show};
 use std::str::MaybeOwned;
 use url::Url;
-use http::headers::HeaderEnum;
-use time;
+use time::{Tm, strptime};
 use html5ever::Attribute;
 use html5ever::tree_builder::{TreeSink, QuirksMode, NodeOrText, AppendNode, AppendText};
 use string_cache::QualName;
+use hyper::header::{Header, HeaderFormat};
+use hyper::header::common::util as header_util;
 
 pub enum HTMLInput {
     InputString(String),
     InputUrl(Url),
 }
 
-// Parses an RFC 2616 compliant date/time string, and returns a localized
-// date/time string in a format suitable for document.lastModified.
-fn parse_last_modified(timestamp: &str) -> String {
-    let format = "%m/%d/%Y %H:%M:%S";
+//FIXME(seanmonstar): uplift to Hyper
+#[deriving(Clone)]
+struct LastModified(pub Tm);
 
-    // RFC 822, updated by RFC 1123
-    match time::strptime(timestamp, "%a, %d %b %Y %T %Z") {
-        Ok(t) => return t.to_local().strftime(format).unwrap(),
-        Err(_) => ()
+impl Header for LastModified {
+    #[inline]
+    fn header_name(_: Option<LastModified>) -> &'static str {
+        "Last-Modified"
     }
 
-    // RFC 850, obsoleted by RFC 1036
-    match time::strptime(timestamp, "%A, %d-%b-%y %T %Z") {
-        Ok(t) => return t.to_local().strftime(format).unwrap(),
-        Err(_) => ()
+    // Parses an RFC 2616 compliant date/time string,
+    fn parse_header(raw: &[Vec<u8>]) -> Option<LastModified> {
+        header_util::from_one_raw_str(raw).and_then(|s: String| {
+            let s = s.as_slice();
+            strptime(s, "%a, %d %b %Y %T %Z").or_else(|_| {
+                strptime(s, "%A, %d-%b-%y %T %Z")
+            }).or_else(|_| {
+                strptime(s, "%c")
+            }).ok().map(|tm| LastModified(tm))
+        })
     }
+}
 
-    // ANSI C's asctime() format
-    match time::strptime(timestamp, "%c") {
-        Ok(t) => t.to_local().strftime(format).unwrap(),
-        Err(_) => String::from_str("")
+impl HeaderFormat for LastModified {
+    // a localized date/time string in a format suitable
+    // for document.lastModified.
+    fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let LastModified(ref tm) = *self;
+        match tm.tm_gmtoff {
+            0 => tm.rfc822().fmt(f),
+            _ => tm.to_utc().rfc822().fmt(f)
+        }
     }
 }
 
+fn dom_last_modified(tm: &Tm) -> String {
+    tm.to_local().strftime("%m/%d/%Y %H:%M:%S").unwrap()
+}
+
 trait SinkHelpers {
     fn get_or_create(&self, child: NodeOrText<TrustedNodeAddress>) -> Temporary<Node>;
 }
@@ -211,15 +228,9 @@ pub fn parse_html(page: &Page,
             let load_response = input_port.recv();
 
             load_response.metadata.headers.as_ref().map(|headers| {
-                let header = headers.iter().find(|h|
-                    h.header_name().as_slice().to_ascii_lower() == "last-modified".to_string()
-                );
-
-                match header {
-                    Some(h) => document.set_last_modified(
-                        parse_last_modified(h.header_value().as_slice())),
-                    None => {},
-                };
+                headers.get().map(|&LastModified(ref tm)| {
+                    document.set_last_modified(dom_last_modified(tm));
+                });
             });
 
             let base_url = load_response.metadata.final_url.clone();