script: Make the resource task communication use IPC channels.

components/compositing/Cargo.toml

@@ -66,10 +66,13 @@ git = "https://github.com/pcwalton/ipc-channel"
 git = "https://github.com/ecoal95/rust-offscreen-rendering-context"
 features = ["texture_surface"]
 
+[dependencies.url]
+version = "0.2"
+features = [ "serde_serialization" ]
+
 [dependencies]
 log = "0.3"
 num = "0.1.24"
-url = "0.2.36"
 time = "0.1.17"
 libc = "0.1"
 gleam = "0.1"
@@ -80,3 +83,4 @@ core-graphics = "0.1"
 
 [target.x86_64-apple-darwin.dependencies.core-text]
 git = "https://github.com/servo/core-text-rs"
+

components/gfx/Cargo.toml

@@ -47,10 +47,13 @@ path = "../script_traits"
 [dependencies.ipc-channel]
 git = "https://github.com/pcwalton/ipc-channel"
 
+[dependencies.url]
+version = "0.2"
+features = [ "serde_serialization" ]
+
 [dependencies]
 log = "0.3"
 fnv = "1.0"
-url = "0.2.36"
 time = "0.1.12"
 bitflags = "0.3"
 rustc-serialize = "0.3"

components/layout/Cargo.toml

@@ -62,11 +62,14 @@ features = [ "serde-serialization" ]
 [dependencies.ipc-channel]
 git = "https://github.com/pcwalton/ipc-channel"
 
+[dependencies.url]
+version = "0.2"
+features = [ "serde_serialization" ]
+
 [dependencies]
 log = "0.3"
 encoding = "0.2"
 fnv = "1.0"
-url = "0.2.36"
 bitflags = "0.3"
 rustc-serialize = "0.3"
 libc = "0.1"

components/layout/layout_task.rs

@@ -718,7 +718,7 @@ impl LayoutTask {
         // TODO we don't really even need to load this if mq does not match
         let (metadata, iter) = load_bytes_iter(pending);
         let protocol_encoding_label = metadata.charset.as_ref().map(|s| &**s);
-        let final_url = metadata.final_url.0;
+        let final_url = metadata.final_url;
 
         let sheet = Stylesheet::from_bytes_iter(iter,
                                                 final_url,

components/layout_traits/Cargo.toml

@@ -28,8 +28,11 @@ path = "../util"
 [dependencies.ipc-channel]
 git = "https://github.com/pcwalton/ipc-channel"
 
+[dependencies.url]
+version = "0.2"
+features = [ "serde_serialization" ]
+
 [dependencies]
-url = "0.2.36"
 euclid = "0.1"
 serde = "0.4"
 serde_macros = "0.4"

components/net/Cargo.toml

@@ -27,9 +27,12 @@ features = [ "serde-serialization" ]
 [dependencies.ipc-channel]
 git = "https://github.com/pcwalton/ipc-channel"
 
+[dependencies.url]
+version = "0.2"
+features = [ "serde_serialization" ]
+
 [dependencies]
 log = "0.3"
-url = "0.2.36"
 time = "0.1.17"
 openssl="0.6.1"
 rustc-serialize = "0.3"
@@ -39,3 +42,4 @@ regex_macros = "0.1.8"
 flate2 = "0.2.0"
 uuid = "0.1.16"
 euclid = "0.1"
+

components/net/about_loader.rs

@@ -2,8 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use net_traits::{LoadData, Metadata, LoadConsumer, SerializableContentType, SerializableRawStatus};
-use net_traits::{SerializableStringResult, SerializableUrl};
+use net_traits::{LoadData, Metadata, LoadConsumer};
 use net_traits::ProgressMsg::Done;
 use mime_classifier::MIMEClassifier;
 use resource_task::start_sending;
@@ -23,26 +22,24 @@ pub fn factory(mut load_data: LoadData, start_chan: LoadConsumer, classifier: Ar
         "blank" => {
             let chan = start_sending(start_chan, Metadata {
                 final_url: load_data.url,
-                content_type: Some(SerializableContentType(ContentType(Mime(TopLevel::Text,
-                                                                            SubLevel::Html,
-                                                                            vec![])))),
+                content_type: Some(ContentType(Mime(TopLevel::Text, SubLevel::Html, vec![]))),
                 charset: Some("utf-8".to_string()),
                 headers: None,
-                status: Some(SerializableRawStatus(RawStatus(200, "OK".into()))),
+                status: Some(RawStatus(200, "OK".into())),
             });
-            chan.send(Done(SerializableStringResult(Ok(())))).unwrap();
+            chan.send(Done(Ok(()))).unwrap();
             return
         }
         "crash" => panic!("Loading the about:crash URL."),
         "failure" => {
             let mut path = resources_dir_path();
             path.push("failure.html");
             assert!(path.exists());
-            load_data.url = SerializableUrl(Url::from_file_path(&*path).unwrap());
+            load_data.url = Url::from_file_path(&*path).unwrap();
         }
         _ => {
-            start_sending(start_chan, Metadata::default(load_data.url.0))
-                .send(Done(SerializableStringResult(Err("Unknown about: URL.".to_string()))))
+            start_sending(start_chan, Metadata::default(load_data.url))
+                .send(Done(Err("Unknown about: URL.".to_string())))
                 .unwrap();
             return
         }

components/net/data_loader.rs

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use net_traits::{LoadData, Metadata, LoadConsumer, SerializableStringResult};
+use net_traits::{LoadData, Metadata, LoadConsumer};
 use net_traits::ProgressMsg::{Payload, Done};
 use mime_classifier::MIMEClassifier;
 use resource_task::start_sending;
@@ -26,11 +26,11 @@ pub fn load(load_data: LoadData, start_chan: LoadConsumer) {
     let url = load_data.url;
     assert!(&*url.scheme == "data");
 
-    let mut metadata = Metadata::default((*url).clone());
+    let mut metadata = Metadata::default(url.clone());
 
     // Split out content type and data.
     let mut scheme_data = match url.scheme_data {
-        SchemeData::NonRelative(ref scheme_data) => (*scheme_data).clone(),
+        SchemeData::NonRelative(scheme_data) => scheme_data,
         _ => panic!("Expected a non-relative scheme URL.")
     };
     match url.query {
@@ -42,8 +42,8 @@ pub fn load(load_data: LoadData, start_chan: LoadConsumer) {
     }
     let parts: Vec<&str> = scheme_data.splitn(2, ',').collect();
     if parts.len() != 2 {
-        start_sending(start_chan, metadata).send(Done(SerializableStringResult(Err(
-                        "invalid data uri".to_string())))).unwrap();
+        start_sending(start_chan,
+                      metadata).send(Done(Err("invalid data uri".to_string()))).unwrap();
         return;
     }
 
@@ -70,16 +70,15 @@ pub fn load(load_data: LoadData, start_chan: LoadConsumer) {
         let bytes = bytes.into_iter().filter(|&b| b != ' ' as u8).collect::<Vec<u8>>();
         match bytes.from_base64() {
             Err(..) => {
-                progress_chan.send(Done(SerializableStringResult(Err(
-                                "non-base64 data uri".to_string())))).unwrap();
+                progress_chan.send(Done(Err("non-base64 data uri".to_string()))).unwrap();
             }
             Ok(data) => {
                 progress_chan.send(Payload(data)).unwrap();
-                progress_chan.send(Done(SerializableStringResult(Ok(())))).unwrap();
+                progress_chan.send(Done(Ok(()))).unwrap();
             }
         }
     } else {
         progress_chan.send(Payload(bytes)).unwrap();
-        progress_chan.send(Done(SerializableStringResult(Ok(())))).unwrap();
+        progress_chan.send(Done(Ok(()))).unwrap();
     }
 }

components/net/file_loader.rs

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use net_traits::{LoadData, Metadata, LoadConsumer, SerializableStringResult};
+use net_traits::{LoadData, Metadata, LoadConsumer};
 use net_traits::ProgressMsg::{Payload, Done};
 use mime_classifier::MIMEClassifier;
 use resource_task::{start_sending, start_sending_sniffed, ProgressSender};
@@ -48,7 +48,7 @@ pub fn factory(load_data: LoadData, senders: LoadConsumer, classifier: Arc<MIMEC
     let url = load_data.url;
     assert!(&*url.scheme == "file");
     spawn_named("file_loader".to_owned(), move || {
-        let metadata = Metadata::default(url.0.clone());
+        let metadata = Metadata::default(url.clone());
         let file_path: Result<PathBuf, ()> = url.to_file_path();
         match file_path {
             Ok(file_path) => {
@@ -65,19 +65,17 @@ pub fn factory(load_data: LoadData, senders: LoadConsumer, classifier: Arc<MIMEC
                             Ok(ReadStatus::EOF) | Err(_) =>
                                 (res.map(|_| ()), start_sending(senders, metadata)),
                         };
-                        progress_chan.send(Done(SerializableStringResult(res))).unwrap();
+                        progress_chan.send(Done(res)).unwrap();
                     }
                     Err(e) => {
                         let progress_chan = start_sending(senders, metadata);
-                        progress_chan.send(Done(SerializableStringResult(Err(e.description()
-                                                                              .to_string()))))
-                                     .unwrap();
+                        progress_chan.send(Done(Err(e.description().to_string()))).unwrap();
                     }
                 }
             }
             Err(_) => {
                 let progress_chan = start_sending(senders, metadata);
-                progress_chan.send(Done(SerializableStringResult(Err(url.to_string())))).unwrap();
+                progress_chan.send(Done(Err(url.to_string()))).unwrap();
             }
         }
     });

components/net/http_loader.rs

@@ -2,15 +2,14 @@
  * 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 net_traits::{ControlMsg, CookieSource, LoadData, Metadata, LoadConsumer, SerializableMethod};
-use net_traits::{SerializableHeaders, SerializableRawStatus, SerializableStringResult};
-use net_traits::{SerializableUrl};
+use net_traits::{ControlMsg, CookieSource, LoadData, Metadata, LoadConsumer};
 use net_traits::ProgressMsg::{Payload, Done};
 use devtools_traits::{ChromeToDevtoolsControlMsg, DevtoolsControlMsg, NetworkEvent};
 use mime_classifier::MIMEClassifier;
 use resource_task::{start_sending_opt, start_sending_sniffed_opt};
 use hsts::{HSTSList, secure_url};
 
+use ipc_channel::ipc::{self, IpcSender};
 use log;
 use std::collections::HashSet;
 use file_loader;
@@ -38,7 +37,7 @@ use uuid;
 use std::borrow::ToOwned;
 use std::boxed::FnBox;
 
-pub fn factory(cookies_chan: Sender<ControlMsg>,
+pub fn factory(cookies_chan: IpcSender<ControlMsg>,
                devtools_chan: Option<Sender<DevtoolsControlMsg>>,
                hsts_list: Arc<Mutex<HSTSList>>)
                -> Box<FnBox(LoadData, LoadConsumer, Arc<MIMEClassifier>) + Send> {
@@ -53,7 +52,7 @@ fn send_error(url: Url, err: String, start_chan: LoadConsumer) {
     metadata.status = None;
 
     match start_sending_opt(start_chan, metadata) {
-        Ok(p) => p.send(Done(SerializableStringResult(Err(err)))).unwrap(),
+        Ok(p) => p.send(Done(Err(err))).unwrap(),
         _ => {}
     };
 }
@@ -88,15 +87,15 @@ fn request_must_be_secured(hsts_list: &HSTSList, url: &Url) -> bool {
 fn load(mut load_data: LoadData,
         start_chan: LoadConsumer,
         classifier: Arc<MIMEClassifier>,
-        cookies_chan: Sender<ControlMsg>,
+        cookies_chan: IpcSender<ControlMsg>,
         devtools_chan: Option<Sender<DevtoolsControlMsg>>,
         hsts_list: Arc<Mutex<HSTSList>>) {
     // FIXME: At the time of writing this FIXME, servo didn't have any central
     //        location for configuration. If you're reading this and such a
     //        repository DOES exist, please update this constant to use it.
     let max_redirects = 50;
     let mut iters = 0;
-    let mut url = load_data.url.0.clone();
+    let mut url = load_data.url.clone();
     let mut redirected_to = HashSet::new();
 
     // If the URL is a view-source scheme then the scheme data contains the
@@ -156,9 +155,7 @@ reason: \"certificate verify failed\" }]))";
                 &HttpsConnector::new(Openssl { context: Arc::new(context) }))
         };
 
-        let mut req = match Request::with_connector(load_data.method.0.clone(),
-                                                    url.clone(),
-                                                    &mut connector) {
+        let mut req = match req {
             Ok(req) => req,
             Err(HttpError::Io(ref io_error)) if (
                 io_error.kind() == io::ErrorKind::Other &&
@@ -187,11 +184,11 @@ reason: \"certificate verify failed\" }]))";
         // https://bugzilla.mozilla.org/show_bug.cgi?id=216828 .
         // Only preserve ones which have been explicitly marked as such.
         if iters == 1 {
-            let mut combined_headers = (*load_data.headers).clone();
+            let mut combined_headers = load_data.headers.clone();
             combined_headers.extend(load_data.preserved_headers.iter());
             *req.headers_mut() = combined_headers;
         } else {
-            *req.headers_mut() = (*load_data.preserved_headers).clone();
+            *req.headers_mut() = load_data.preserved_headers.clone();
         }
 
         req.headers_mut().set(host);
@@ -206,8 +203,8 @@ reason: \"certificate verify failed\" }]))";
             req.headers_mut().set(accept);
         }
 
-        let (tx, rx) = channel();
-        cookies_chan.send(ControlMsg::GetCookiesForUrl(SerializableUrl(url.clone()),
+        let (tx, rx) = ipc::channel().unwrap();
+        cookies_chan.send(ControlMsg::GetCookiesForUrl(url.clone(),
                                                        tx,
                                                        CookieSource::HTTP)).unwrap();
         if let Some(cookie_list) = rx.recv().unwrap() {
@@ -220,7 +217,7 @@ reason: \"certificate verify failed\" }]))";
             req.headers_mut().set_raw("Accept-Encoding".to_owned(), vec![b"gzip, deflate".to_vec()]);
         }
         if log_enabled!(log::LogLevel::Info) {
-            info!("{}", load_data.method.0);
+            info!("{}", load_data.method);
             for header in req.headers().iter() {
                 info!(" - {}", header);
             }
@@ -248,7 +245,7 @@ reason: \"certificate verify failed\" }]))";
                 writer
             },
             _ => {
-                match *load_data.method {
+                match load_data.method {
                     Method::Get | Method::Head => (),
                     _ => req.headers_mut().set(ContentLength(0))
                 }
@@ -266,9 +263,9 @@ reason: \"certificate verify failed\" }]))";
         // TODO: Do this only if load_data has some pipeline_id, and send the pipeline_id in the message
         let request_id = uuid::Uuid::new_v4().to_simple_string();
         if let Some(ref chan) = devtools_chan {
-            let net_event = NetworkEvent::HttpRequest((*load_data.url).clone(),
-                                                      (*load_data.method).clone(),
-                                                      (*load_data.headers).clone(),
+            let net_event = NetworkEvent::HttpRequest(load_data.url.clone(),
+                                                      load_data.method.clone(),
+                                                      load_data.headers.clone(),
                                                       load_data.data.clone());
             chan.send(DevtoolsControlMsg::FromChrome(
                     ChromeToDevtoolsControlMsg::NetworkEventMessage(request_id.clone(),
@@ -294,7 +291,7 @@ reason: \"certificate verify failed\" }]))";
         if let Some(cookies) = response.headers.get_raw("set-cookie") {
             for cookie in cookies.iter() {
                 if let Ok(cookies) = String::from_utf8(cookie.clone()) {
-                    cookies_chan.send(ControlMsg::SetCookiesForUrl(SerializableUrl(url.clone()),
+                    cookies_chan.send(ControlMsg::SetCookiesForUrl(url.clone(),
                                                                    cookies,
                                                                    CookieSource::HTTP)).unwrap();
                 }
@@ -332,10 +329,10 @@ reason: \"certificate verify failed\" }]))";
 
                     // According to https://tools.ietf.org/html/rfc7231#section-6.4.2,
                     // historically UAs have rewritten POST->GET on 301 and 302 responses.
-                    if *load_data.method == Method::Post &&
+                    if load_data.method == Method::Post &&
                         (response.status == StatusCode::MovedPermanently ||
                          response.status == StatusCode::Found) {
-                        load_data.method = SerializableMethod(Method::Get);
+                        load_data.method = Method::Get;
                     }
 
                     if redirected_to.contains(&url) {
@@ -359,8 +356,8 @@ reason: \"certificate verify failed\" }]))";
             Some(&ContentType(ref mime)) => Some(mime),
             None => None
         });
-        metadata.headers = Some(SerializableHeaders(adjusted_headers));
-        metadata.status = Some(SerializableRawStatus(response.status_raw().clone()));
+        metadata.headers = Some(adjusted_headers);
+        metadata.status = Some(response.status_raw().clone());
 
         let mut encoding_str: Option<String> = None;
         //FIXME: Implement Content-Encoding Header https://github.com/hyperium/hyper/issues/391
@@ -396,7 +393,7 @@ reason: \"certificate verify failed\" }]))";
                             send_data(&mut response_decoding, start_chan, metadata, classifier);
                         }
                         Err(err) => {
-                            send_error((*metadata.final_url).clone(), err.to_string(), start_chan);
+                            send_error(metadata.final_url, err.to_string(), start_chan);
                             return;
                         }
                     }
@@ -445,5 +442,5 @@ fn send_data<R: Read>(reader: &mut R,
         };
     }
 
-    let _ = progress_chan.send(Done(SerializableStringResult(Ok(()))));
+    let _ = progress_chan.send(Done(Ok(())));
 }