Split out shared networking code into net_traits crate

Fixes #4476

components/net/resource_task.rs

@@ -10,19 +10,20 @@ use file_loader;
 use http_loader;
 use sniffer_task;
 use sniffer_task::SnifferTask;
-use cookie_storage::{CookieStorage, CookieSource};
+use cookie_storage::CookieStorage;
 use cookie;
 
+use net_traits::{ControlMsg, LoadData, LoadResponse};
+use net_traits::{Metadata, ProgressMsg, ResourceTask};
+use net_traits::ProgressMsg::Done;
 use util::task::spawn_named;
 
 use hyper::header::UserAgent;
-use hyper::header::{Headers, Header, SetCookie};
-use hyper::http::RawStatus;
-use hyper::method::Method;
-use hyper::mime::{Mime, Attr};
+use hyper::header::{Header, SetCookie};
+#[cfg(test)]
 use url::Url;
 
-use std::borrow::{ToOwned, IntoCow};
+use std::borrow::ToOwned;
 use std::boxed;
 use std::collections::HashMap;
 use std::env;
@@ -57,110 +58,6 @@ pub fn global_init() {
     }
 }
 
-pub enum ControlMsg {
-    /// Request the data associated with a particular URL
-    Load(LoadData),
-    /// Store a set of cookies for a given originating URL
-    SetCookiesForUrl(Url, String, CookieSource),
-    /// Retrieve the stored cookies for a given URL
-    GetCookiesForUrl(Url, Sender<Option<String>>, CookieSource),
-    Exit
-}
-
-#[derive(Clone)]
-pub struct LoadData {
-    pub url: Url,
-    pub method: Method,
-    /// Headers that will apply to the initial request only
-    pub headers: Headers,
-    /// Headers that will apply to the initial request and any redirects
-    pub preserved_headers: Headers,
-    pub data: Option<Vec<u8>>,
-    pub cors: Option<ResourceCORSData>,
-    pub consumer: Sender<LoadResponse>,
-}
-
-impl LoadData {
-    pub fn new(url: Url, consumer: Sender<LoadResponse>) -> LoadData {
-        LoadData {
-            url: url,
-            method: Method::Get,
-            headers: Headers::new(),
-            preserved_headers: Headers::new(),
-            data: None,
-            cors: None,
-            consumer: consumer,
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct ResourceCORSData {
-    /// CORS Preflight flag
-    pub preflight: bool,
-    /// Origin of CORS Request
-    pub origin: Url
-}
-
-/// Metadata about a loaded resource, such as is obtained from HTTP headers.
-#[derive(Clone)]
-pub struct Metadata {
-    /// Final URL after redirects.
-    pub final_url: Url,
-
-    /// MIME type / subtype.
-    pub content_type: Option<(String, String)>,
-
-    /// Character set.
-    pub charset: Option<String>,
-
-    /// Headers
-    pub headers: Option<Headers>,
-
-    /// HTTP Status
-    pub status: Option<RawStatus>,
-}
-
-impl Metadata {
-    /// Metadata with defaults for everything optional.
-    pub fn default(url: Url) -> Metadata {
-        Metadata {
-            final_url:    url,
-            content_type: None,
-            charset:      None,
-            headers: None,
-            // http://fetch.spec.whatwg.org/#concept-response-status-message
-            status: Some(RawStatus(200, "OK".into_cow())),
-        }
-    }
-
-    /// Extract the parts of a Mime that we care about.
-    pub fn set_content_type(&mut self, content_type: Option<&Mime>) {
-        match content_type {
-            None => (),
-            Some(&Mime(ref type_, ref subtype, ref parameters)) => {
-                self.content_type = Some((type_.to_string(), subtype.to_string()));
-                for &(ref k, ref v) in parameters.iter() {
-                    if &Attr::Charset == k {
-                        self.charset = Some(v.to_string());
-                    }
-                }
-            }
-        }
-    }
-}
-
-/// Message sent in response to `Load`.  Contains metadata, and a port
-/// for receiving the data.
-///
-/// Even if loading fails immediately, we send one of these and the
-/// progress_port will provide the error.
-pub struct LoadResponse {
-    /// Metadata, such as from HTTP headers.
-    pub metadata: Metadata,
-    /// Port for reading data.
-    pub progress_port: Receiver<ProgressMsg>,
-}
 /// A LoadResponse directed at a particular consumer
 pub struct TargetedLoadResponse {
     pub load_response: LoadResponse,
@@ -173,15 +70,6 @@ pub struct ResponseSenders {
     pub eventual_consumer: Sender<LoadResponse>,
 }
 
-/// Messages sent in response to a `Load` message
-#[derive(PartialEq,Debug)]
-pub enum ProgressMsg {
-    /// Binary data - there may be multiple of these
-    Payload(Vec<u8>),
-    /// Indicates loading is complete, either successfully or not
-    Done(Result<(), String>)
-}
-
 /// For use by loaders in responding to a Load message.
 pub fn start_sending(senders: ResponseSenders, metadata: Metadata) -> Sender<ProgressMsg> {
     start_sending_opt(senders, metadata).ok().unwrap()
@@ -203,26 +91,6 @@ pub fn start_sending_opt(senders: ResponseSenders, metadata: Metadata) -> Result
     }
 }
 
-/// Convenience function for synchronously loading a whole resource.
-pub fn load_whole_resource(resource_task: &ResourceTask, url: Url)
-        -> Result<(Metadata, Vec<u8>), String> {
-    let (start_chan, start_port) = channel();
-    resource_task.send(ControlMsg::Load(LoadData::new(url, start_chan))).unwrap();
-    let response = start_port.recv().unwrap();
-
-    let mut buf = vec!();
-    loop {
-        match response.progress_port.recv().unwrap() {
-            ProgressMsg::Payload(data) => buf.push_all(&data),
-            ProgressMsg::Done(Ok(()))  => return Ok((response.metadata, buf)),
-            ProgressMsg::Done(Err(e))  => return Err(e)
-        }
-    }
-}
-
-/// Handle to a resource task
-pub type ResourceTask = Sender<ControlMsg>;
-
 /// Create a ResourceTask
 pub fn new_resource_task(user_agent: Option<String>) -> ResourceTask {
     let (setup_chan, setup_port) = channel();
@@ -355,36 +223,6 @@ impl ResourceManager {
     }
 }
 
-/// Load a URL asynchronously and iterate over chunks of bytes from the response.
-pub fn load_bytes_iter(resource_task: &ResourceTask, url: Url) -> (Metadata, ProgressMsgPortIterator) {
-    let (input_chan, input_port) = channel();
-    resource_task.send(ControlMsg::Load(LoadData::new(url, input_chan))).unwrap();
-
-    let response = input_port.recv().unwrap();
-    let iter = ProgressMsgPortIterator { progress_port: response.progress_port };
-    (response.metadata, iter)
-}
-
-/// Iterator that reads chunks of bytes from a ProgressMsg port
-pub struct ProgressMsgPortIterator {
-    progress_port: Receiver<ProgressMsg>
-}
-
-impl Iterator for ProgressMsgPortIterator {
-    type Item = Vec<u8>;
-
-    fn next(&mut self) -> Option<Vec<u8>> {
-        match self.progress_port.recv().unwrap() {
-            ProgressMsg::Payload(data) => Some(data),
-            ProgressMsg::Done(Ok(()))  => None,
-            ProgressMsg::Done(Err(e))  => {
-                error!("error receiving bytes: {}", e);
-                None
-            }
-        }
-    }
-}
-
 #[test]
 fn test_exit() {
     let resource_task = new_resource_task(None);