servo: Merge #7984 - Refactor resource loaders to use send_error utility (from eefriedman:net-send-error); r=jdm

No substantial functional change.

Source-Repo: https://github.com/servo/servo
Source-Revision: f35f809938792fbad61fd517187e46c1e009cd16

servo/components/net/about_loader.rs

@@ -9,7 +9,7 @@ use hyper::mime::{Mime, SubLevel, TopLevel};
 use mime_classifier::MIMEClassifier;
 use net_traits::ProgressMsg::Done;
 use net_traits::{LoadConsumer, LoadData, Metadata};
-use resource_task::start_sending;
+use resource_task::{send_error, start_sending};
 use std::fs::PathExt;
 use std::sync::Arc;
 use url::Url;
@@ -36,9 +36,7 @@ pub fn factory(mut load_data: LoadData, start_chan: LoadConsumer, classifier: Ar
             load_data.url = Url::from_file_path(&*path).unwrap();
         }
         _ => {
-            start_sending(start_chan, Metadata::default(load_data.url))
-                .send(Done(Err("Unknown about: URL.".to_owned())))
-                .unwrap();
+            send_error(load_data.url, "Unknown about: URL.".to_owned(), start_chan);
             return
         }
     };

servo/components/net/data_loader.rs

@@ -6,7 +6,7 @@ use hyper::mime::{Mime, TopLevel, SubLevel, Attr, Value};
 use mime_classifier::MIMEClassifier;
 use net_traits::ProgressMsg::{Done, Payload};
 use net_traits::{LoadConsumer, LoadData, Metadata};
-use resource_task::start_sending;
+use resource_task::{send_error, start_sending};
 use rustc_serialize::base64::FromBase64;
 use std::sync::Arc;
 use url::SchemeData;
@@ -24,11 +24,9 @@ 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());
-
     // Split out content type and data.
     let mut scheme_data = match url.scheme_data {
-        SchemeData::NonRelative(scheme_data) => scheme_data,
+        SchemeData::NonRelative(ref scheme_data) => scheme_data.clone(),
         _ => panic!("Expected a non-relative scheme URL.")
     };
     match url.query {
@@ -40,8 +38,7 @@ 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(Err("invalid data uri".to_owned()))).unwrap();
+        send_error(url, "invalid data uri".to_owned(), start_chan);
         return;
     }
 
@@ -65,6 +62,7 @@ pub fn load(load_data: LoadData, start_chan: LoadConsumer) {
         content_type = Some(Mime(TopLevel::Text, SubLevel::Plain,
                                  vec!((Attr::Charset, Value::Ext("US-ASCII".to_owned())))));
     }
+    let mut metadata = Metadata::default(url);
     metadata.set_content_type(content_type.as_ref());
 
     let progress_chan = start_sending(start_chan, metadata);

servo/components/net/file_loader.rs

@@ -5,7 +5,7 @@
 use mime_classifier::MIMEClassifier;
 use net_traits::ProgressMsg::{Done, Payload};
 use net_traits::{LoadConsumer, LoadData, Metadata};
-use resource_task::{ProgressSender, start_sending, start_sending_sniffed};
+use resource_task::{ProgressSender, send_error, start_sending, start_sending_sniffed};
 use std::borrow::ToOwned;
 use std::error::Error;
 use std::fs::File;
@@ -47,12 +47,12 @@ 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.clone());
         let file_path: Result<PathBuf, ()> = url.to_file_path();
         match file_path {
             Ok(file_path) => {
                 match File::open(&file_path) {
                     Ok(ref mut reader) => {
+                        let metadata = Metadata::default(url);
                         let res = read_block(reader);
                         let (res, progress_chan) = match res {
                             Ok(ReadStatus::Partial(buf)) => {
@@ -67,14 +67,12 @@ pub fn factory(load_data: LoadData, senders: LoadConsumer, classifier: Arc<MIMEC
                         progress_chan.send(Done(res)).unwrap();
                     }
                     Err(e) => {
-                        let progress_chan = start_sending(senders, metadata);
-                        progress_chan.send(Done(Err(e.description().to_owned()))).unwrap();
+                        send_error(url, e.description().to_owned(), senders);
                     }
                 }
             }
             Err(_) => {
-                let progress_chan = start_sending(senders, metadata);
-                progress_chan.send(Done(Err(url.to_string()))).unwrap();
+                send_error(url, "Could not parse path".to_owned(), senders);
             }
         }
     });

servo/components/net/http_loader.rs

@@ -26,7 +26,7 @@ use net_traits::ProgressMsg::{Done, Payload};
 use net_traits::hosts::replace_hosts;
 use net_traits::{CookieSource, IncludeSubdomains, LoadConsumer, LoadData, Metadata};
 use openssl::ssl::{SSL_VERIFY_PEER, SslContext, SslMethod};
-use resource_task::{start_sending_opt, start_sending_sniffed_opt};
+use resource_task::{send_error, start_sending_sniffed_opt};
 use std::borrow::ToOwned;
 use std::boxed::FnBox;
 use std::collections::HashSet;
@@ -72,15 +72,6 @@ pub fn factory(user_agent: String,
     }
 }
 
-fn send_error(url: Url, err: String, start_chan: LoadConsumer) {
-    let mut metadata: Metadata = Metadata::default(url);
-    metadata.status = None;
-
-    if let Ok(p) = start_sending_opt(start_chan, metadata) {
-        p.send(Done(Err(err))).unwrap();
-    }
-}
-
 enum ReadResult {
     Payload(Vec<u8>),
     EOF,

servo/components/net/resource_task.rs

@@ -50,6 +50,15 @@ impl ProgressSender {
     }
 }
 
+pub fn send_error(url: Url, err: String, start_chan: LoadConsumer) {
+    let mut metadata: Metadata = Metadata::default(url);
+    metadata.status = None;
+
+    if let Ok(p) = start_sending_opt(start_chan, metadata) {
+        p.send(Done(Err(err))).unwrap();
+    }
+}
+
 /// For use by loaders in responding to a Load message.
 pub fn start_sending(start_chan: LoadConsumer, metadata: Metadata) -> ProgressSender {
     start_sending_opt(start_chan, metadata).ok().unwrap()