Auto merge of servo#9942 - jdm:load_error, r=ms2ger

Moving the error handling out of network loader

Rebase of servo#8851. Fixes servo#8678. Fixes servo#9944.

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="35" align="absmiddle" alt="Review on Reviewable"/>](https://reviewable.io/reviews/servo/servo/9942)
<!-- Reviewable:end -->

Author: bors-servo

components/gfx/font_cache_thread.rs

@@ -183,15 +183,21 @@ impl FontCache {
                             ROUTER.add_route(data_receiver.to_opaque(), box move |message| {
                                 let response: ResponseAction = message.to().unwrap();
                                 match response {
-                                    ResponseAction::HeadersAvailable(metadata) => {
-                                        let is_response_valid =
-                                            metadata.content_type.as_ref().map_or(false, |content_type| {
-                                                let mime = &content_type.0;
-                                                is_supported_font_type(&mime.0, &mime.1)
-                                            });
-                                        info!("{} font with MIME type {:?}",
+                                    ResponseAction::HeadersAvailable(meta_result) => {
+                                        let is_response_valid = match meta_result {
+                                            Ok(ref metadata) => {
+                                                metadata.content_type.as_ref().map_or(false, |content_type| {
+                                                    let mime = &content_type.0;
+                                                    is_supported_font_type(&mime.0, &mime.1)
+                                                })
+                                            }
+                                            Err(_) => false,
+                                        };
+
+                                        info!("{} font with MIME type {}",
                                               if is_response_valid { "Loading" } else { "Ignoring" },
-                                              metadata.content_type);
+                                              meta_result.map(|ref meta| format!("{:?}", meta.content_type))
+                                                         .unwrap_or(format!("<Network Error>")));
                                         *response_valid.lock().unwrap() = is_response_valid;
                                     }
                                     ResponseAction::DataAvailable(new_bytes) => {

components/net/about_loader.rs

@@ -9,12 +9,19 @@ use hyper::mime::{Mime, SubLevel, TopLevel};
 use mime_classifier::MIMEClassifier;
 use net_traits::ProgressMsg::Done;
 use net_traits::response::HttpsState;
-use net_traits::{LoadConsumer, LoadData, Metadata};
+use net_traits::{LoadConsumer, LoadData, Metadata, NetworkError};
 use resource_thread::{CancellationListener, send_error, start_sending_sniffed_opt};
 use std::sync::Arc;
 use url::Url;
 use util::resource_files::resources_dir_path;
 
+fn url_from_non_relative_scheme(load_data: &mut LoadData, filename: &str) {
+    let mut path = resources_dir_path();
+    path.push(filename);
+    assert!(path.exists());
+    load_data.url = Url::from_file_path(&*path).unwrap();
+}
+
 pub fn factory(mut load_data: LoadData,
                start_chan: LoadConsumer,
                classifier: Arc<MIMEClassifier>,
@@ -41,15 +48,11 @@ pub fn factory(mut load_data: LoadData,
             return
         }
         "crash" => panic!("Loading the about:crash URL."),
-        "failure" | "not-found" => {
-            let mut path = resources_dir_path();
-            let file_name = non_relative_scheme_data.to_owned() + ".html";
-            path.push(&file_name);
-            assert!(path.exists());
-            load_data.url = Url::from_file_path(&*path).unwrap();
-        }
+        "failure" | "not-found" =>
+            url_from_non_relative_scheme(&mut load_data, &(non_relative_scheme_data.to_owned() + ".html")),
+        "sslfail" => url_from_non_relative_scheme(&mut load_data, "badcert.html"),
         _ => {
-            send_error(load_data.url, "Unknown about: URL.".to_owned(), start_chan);
+            send_error(load_data.url, NetworkError::Internal("Unknown about: URL.".to_owned()), start_chan);
             return
         }
     };

components/net/chrome_loader.rs

@@ -0,0 +1,47 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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 file_loader;
+use mime_classifier::MIMEClassifier;
+use net_traits::{LoadConsumer, LoadData, NetworkError};
+use resource_thread::{CancellationListener, send_error};
+use std::path::Path;
+use std::sync::Arc;
+use url::Url;
+use util::resource_files::resources_dir_path;
+
+pub fn resolve_chrome_url(url: &Url) -> Result<Url, ()> {
+    assert_eq!(url.scheme, "chrome");
+    // Skip the initial //
+    let non_relative_scheme_data = &url.non_relative_scheme_data().unwrap()[2..];
+    let relative_path = Path::new(non_relative_scheme_data);
+    // Don't allow chrome URLs access to files outside of the resources directory.
+    if non_relative_scheme_data.find("..").is_some() ||
+       relative_path.is_absolute() ||
+       relative_path.has_root() {
+        return Err(());
+    }
+
+    let mut path = resources_dir_path();
+    path.push(non_relative_scheme_data);
+    assert!(path.exists());
+    return Ok(Url::from_file_path(&*path).unwrap());
+}
+
+pub fn factory(mut load_data: LoadData,
+               start_chan: LoadConsumer,
+               classifier: Arc<MIMEClassifier>,
+               cancel_listener: CancellationListener) {
+    let file_url = match resolve_chrome_url(&load_data.url) {
+        Ok(url) => url,
+        Err(_) => {
+            send_error(load_data.url,
+                       NetworkError::Internal("Invalid chrome URL.".to_owned()),
+                       start_chan);
+            return;
+        }
+    };
+    load_data.url = file_url;
+    file_loader::factory(load_data, start_chan, classifier, cancel_listener)
+}

components/net/data_loader.rs

@@ -6,7 +6,7 @@ use hyper::mime::{Mime, TopLevel, SubLevel, Attr, Value};
 use mime_classifier::MIMEClassifier;
 use net_traits::LoadConsumer;
 use net_traits::ProgressMsg::{Payload, Done};
-use net_traits::{LoadData, Metadata};
+use net_traits::{LoadData, Metadata, NetworkError};
 use resource_thread::{CancellationListener, send_error, start_sending_sniffed_opt};
 use rustc_serialize::base64::FromBase64;
 use std::sync::Arc;
@@ -110,7 +110,9 @@ pub fn load(load_data: LoadData,
                 let _ = chan.send(Done(Ok(())));
             }
         },
-        Err(DecodeError::InvalidDataUri) => send_error(url, "invalid data uri".to_owned(), start_chan),
-        Err(DecodeError::NonBase64DataUri) => send_error(url, "non-base64 data uri".to_owned(), start_chan),
+        Err(DecodeError::InvalidDataUri) =>
+            send_error(url, NetworkError::Internal("invalid data uri".to_owned()), start_chan),
+        Err(DecodeError::NonBase64DataUri) =>
+            send_error(url, NetworkError::Internal("non-base64 data uri".to_owned()), start_chan),
     }
 }

components/net/file_loader.rs

@@ -6,7 +6,7 @@ use about_loader;
 use mime_classifier::MIMEClassifier;
 use mime_guess::guess_mime_type;
 use net_traits::ProgressMsg::{Done, Payload};
-use net_traits::{LoadConsumer, LoadData, Metadata};
+use net_traits::{LoadConsumer, LoadData, Metadata, NetworkError};
 use resource_thread::{CancellationListener, ProgressSender};
 use resource_thread::{send_error, start_sending_sniffed_opt};
 use std::borrow::ToOwned;
@@ -50,7 +50,7 @@ fn read_all(reader: &mut File, progress_chan: &ProgressSender, cancel_listener:
             ReadStatus::EOF => return Ok(LoadResult::Finished),
         }
     }
-    let _ = progress_chan.send(Done(Err("load cancelled".to_owned())));
+    let _ = progress_chan.send(Done(Err(NetworkError::Internal("load cancelled".to_owned()))));
     Ok(LoadResult::Cancelled)
 }
 
@@ -72,7 +72,7 @@ pub fn factory(load_data: LoadData,
         let file_path = match load_data.url.to_file_path() {
             Ok(file_path) => file_path,
             Err(_) => {
-                send_error(load_data.url, "Could not parse path".to_owned(), senders);
+                send_error(load_data.url, NetworkError::Internal("Could not parse path".to_owned()), senders);
                 return;
             },
         };
@@ -92,7 +92,7 @@ pub fn factory(load_data: LoadData,
         if cancel_listener.is_cancelled() {
             if let Ok(progress_chan) = get_progress_chan(load_data, file_path,
                                                          senders, classifier, &[]) {
-                let _ = progress_chan.send(Done(Err("load cancelled".to_owned())));
+                let _ = progress_chan.send(Done(Err(NetworkError::Internal("load cancelled".to_owned()))));
             }
             return;
         }
@@ -116,7 +116,7 @@ pub fn factory(load_data: LoadData,
                 }
             }
             Err(e) => {
-                send_error(load_data.url, e, senders);
+                send_error(load_data.url, NetworkError::Internal(e), senders);
             }
         }
     });