auto merge of #2355 : glennw/servo/http-fail-errors, r=jdm

...during task failure.

src/components/net/data_loader.rs

@@ -27,7 +27,7 @@ fn load(url: Url, start_chan: Sender<LoadResponse>) {
     // Split out content type and data.
     let parts: ~[&str] = url.path.splitn(',', 1).collect();
     if parts.len() != 2 {
-        start_sending(start_chan, metadata).send(Done(Err(())));
+        start_sending(start_chan, metadata).send(Done(Err("invalid data uri".to_owned())));
         return;
     }
 
@@ -50,7 +50,7 @@ fn load(url: Url, start_chan: Sender<LoadResponse>) {
     if is_base64 {
         match parts[1].from_base64() {
             Err(..) => {
-                progress_chan.send(Done(Err(())));
+                progress_chan.send(Done(Err("non-base64 data uri".to_owned())));
             }
             Ok(data) => {
                 let data: ~[u8] = data;
@@ -86,7 +86,7 @@ fn assert_parse(url:          &'static str,
 
     match data {
         None => {
-            assert_eq!(progress, Done(Err(())));
+            assert_eq!(progress, Done(Err("invalid data uri".to_owned())));
         }
         Some(dat) => {
             assert_eq!(progress, Payload(dat));

src/components/net/file_loader.rs

@@ -12,14 +12,14 @@ use servo_util::task::spawn_named;
 static READ_SIZE: uint = 1;
 
 fn read_all(reader: &mut io::Stream, progress_chan: &Sender<ProgressMsg>)
-        -> Result<(), ()> {
+        -> Result<(), ~str> {
     loop {
         let mut buf = vec!();
         match reader.push_exact(&mut buf, READ_SIZE) {
             Ok(_) => progress_chan.send(Payload(buf)),
             Err(e) => match e.kind {
                 io::EndOfFile => return Ok(()),
-                _ => return Err(()),
+                _ => return Err(e.desc.to_owned()),
             }
         }
     }
@@ -35,8 +35,8 @@ pub fn factory() -> LoaderTask {
                     let res = read_all(reader as &mut io::Stream, &progress_chan);
                     progress_chan.send(Done(res));
                 }
-                Err(_) => {
-                    progress_chan.send(Done(Err(())));
+                Err(e) => {
+                    progress_chan.send(Done(Err(e.desc.to_owned())));
                 }
             };
         });

src/components/net/http_loader.rs

@@ -20,8 +20,8 @@ pub fn factory() -> LoaderTask {
     f
 }
 
-fn send_error(url: Url, start_chan: Sender<LoadResponse>) {
-    start_sending(start_chan, Metadata::default(url)).send(Done(Err(())));
+fn send_error(url: Url, err: ~str, start_chan: Sender<LoadResponse>) {
+    start_sending(start_chan, Metadata::default(url)).send(Done(Err(err)));
 }
 
 fn load(mut url: Url, start_chan: Sender<LoadResponse>) {
@@ -38,22 +38,20 @@ fn load(mut url: Url, start_chan: Sender<LoadResponse>) {
         iters = iters + 1;
 
         if iters > max_redirects {
-            info!("too many redirects");
-            send_error(url, start_chan);
+            send_error(url, "too many redirects".to_owned(), start_chan);
             return;
         }
 
         if redirected_to.contains(&url) {
-            info!("redirect loop");
-            send_error(url, start_chan);
+            send_error(url, "redirect loop".to_owned(), start_chan);
             return;
         }
 
         redirected_to.insert(url.clone());
 
         if "http" != url.scheme {
-            info!("{:s} request, but we don't support that scheme", url.scheme);
-            send_error(url, start_chan);
+            let s = format!("{:s} request, but we don't support that scheme", url.scheme);
+            send_error(url, s, start_chan);
             return;
         }
 
@@ -62,15 +60,15 @@ fn load(mut url: Url, start_chan: Sender<LoadResponse>) {
         let request = RequestWriter::<NetworkStream>::new(Get, url.clone());
         let writer = match request {
             Ok(w) => ~w,
-            Err(_) => {
-                send_error(url, start_chan);
+            Err(e) => {
+                send_error(url, e.desc.to_owned(), start_chan);
                 return;
             }
         };
         let mut response = match writer.read_response() {
             Ok(r) => r,
-            Err(_) => {
-                send_error(url, start_chan);
+            Err((_, e)) => {
+                send_error(url, e.desc.to_owned(), start_chan);
                 return;
             }
         };

src/components/net/image_cache_task.rs

@@ -563,7 +563,7 @@ mod tests {
     impl Closure for SendTestImageErr {
         fn invoke(&self, response: Sender<resource_task::ProgressMsg>) {
             response.send(resource_task::Payload(test_image_bin()));
-            response.send(resource_task::Done(Err(())));
+            response.send(resource_task::Done(Err("".to_owned())));
         }
     }
 
@@ -589,7 +589,7 @@ mod tests {
             // the image
             self.wait_port.recv();
             response.send(resource_task::Payload(test_image_bin()));
-            response.send(resource_task::Done(Err(())));
+            response.send(resource_task::Done(Err("".to_owned())));
         }
     }
 
@@ -797,7 +797,7 @@ mod tests {
                     resource_task::Load(_, response) => {
                         let chan = start_sending(response, Metadata::default(parse_url("file:///fake", None)));
                         chan.send(resource_task::Payload(test_image_bin()));
-                        chan.send(resource_task::Done(Err(())));
+                        chan.send(resource_task::Done(Err("".to_owned())));
                         image_bin_sent_chan.send(());
                     }
                     resource_task::Exit => {

src/components/net/resource_task.rs

@@ -80,7 +80,7 @@ pub enum ProgressMsg {
     /// Binary data - there may be multiple of these
     Payload(Vec<u8>),
     /// Indicates loading is complete, either successfully or not
-    Done(Result<(), ()>)
+    Done(Result<(), ~str>)
 }
 
 /// For use by loaders in responding to a Load message.
@@ -96,7 +96,7 @@ pub fn start_sending(start_chan: Sender<LoadResponse>,
 
 /// Convenience function for synchronously loading a whole resource.
 pub fn load_whole_resource(resource_task: &ResourceTask, url: Url)
-        -> Result<(Metadata, Vec<u8>), ()> {
+        -> Result<(Metadata, Vec<u8>), ~str> {
     let (start_chan, start_port) = channel();
     resource_task.send(Load(url, start_chan));
     let response = start_port.recv();
@@ -183,7 +183,7 @@ impl ResourceManager {
             }
             None => {
                 debug!("resource_task: no loader for scheme {:s}", url.scheme);
-                start_sending(start_chan, Metadata::default(url)).send(Done(Err(())));
+                start_sending(start_chan, Metadata::default(url)).send(Done(Err("no loader for scheme".to_owned())));
             }
         }
     }

src/components/script/html/hubbub_html_parser.rs

@@ -510,8 +510,8 @@ pub fn parse_html(page: &Page,
                 debug!("received data");
                 parser.parse_chunk(data.as_slice());
             }
-            Done(Err(..)) => {
-                fail!("Failed to load page URL {:s}", url.to_str());
+            Done(Err(err)) => {
+                fail!("Failed to load page URL {:s}, error: {:s}", url.to_str(), err);
             }
             Done(..) => {
                 break;