Use Result instead of panicking when the resource dir can't be found

components/net/about_loader.rs

@@ -11,15 +11,17 @@ use net_traits::ProgressMsg::Done;
 use net_traits::response::HttpsState;
 use net_traits::{LoadConsumer, LoadData, Metadata, NetworkError};
 use resource_thread::{CancellationListener, send_error, start_sending_sniffed_opt};
+use std::io;
 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();
+fn url_from_non_relative_scheme(load_data: &mut LoadData, filename: &str) -> io::Result<()> {
+    let mut path = try!(resources_dir_path());
     path.push(filename);
     assert!(path.exists());
     load_data.url = Url::from_file_path(&*path).unwrap();
+    Ok(())
 }
 
 pub fn factory(mut load_data: LoadData,
@@ -27,7 +29,7 @@ pub fn factory(mut load_data: LoadData,
                classifier: Arc<MimeClassifier>,
                cancel_listener: CancellationListener) {
     let url = load_data.url.clone();
-    match url.path() {
+    let res = match url.path() {
         "blank" => {
             let metadata = Metadata {
                 final_url: load_data.url,
@@ -56,5 +58,9 @@ pub fn factory(mut load_data: LoadData,
             return
         }
     };
-    file_loader::factory(load_data, start_chan, classifier, cancel_listener)
+    if res.is_ok() {
+        file_loader::factory(load_data, start_chan, classifier, cancel_listener)
+    } else {
+        send_error(load_data.url, NetworkError::Internal("Could not access resource folder".to_owned()), start_chan);
+    }
 }

components/net/chrome_loader.rs

@@ -17,7 +17,7 @@ pub fn resolve_chrome_url(url: &Url) -> Result<Url, ()> {
     if url.host_str() != Some("resources") {
         return Err(())
     }
-    let resources = canonicalize(resources_dir_path())
+    let resources = canonicalize(resources_dir_path().expect("Error finding resource folder"))
         .expect("Error canonicalizing path to the resources directory");
     let mut path = resources.clone();
     for segment in url.path_segments().unwrap() {

components/net/connector.rs

@@ -29,7 +29,9 @@ const DEFAULT_CIPHERS: &'static str = concat!(
 
 pub fn create_http_connector() -> Arc<Pool<Connector>> {
     let mut context = SslContext::new(SslMethod::Sslv23).unwrap();
-    context.set_CA_file(&resources_dir_path().join("certs")).unwrap();
+    context.set_CA_file(&resources_dir_path()
+                        .expect("Need certificate file to make network requests")
+                        .join("certs")).unwrap();
     context.set_cipher_list(DEFAULT_CIPHERS).unwrap();
     context.set_options(SSL_OP_NO_SSLV2 | SSL_OP_NO_SSLV3 | SSL_OP_NO_COMPRESSION);
     let connector = HttpsConnector::new(ServoSslClient {

components/net/image_cache_thread.rs

@@ -16,7 +16,7 @@ use std::borrow::ToOwned;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::fs::File;
-use std::io::Read;
+use std::io::{self, Read};
 use std::mem;
 use std::sync::Arc;
 use std::sync::mpsc::{Sender, Receiver, channel};
@@ -318,29 +318,27 @@ impl LoadOrigin for ImageCacheOrigin {
     }
 }
 
-
+fn get_placeholder_image(webrender_api: &Option<webrender_traits::RenderApi>) -> io::Result<Arc<Image>> {
+    let mut placeholder_path = try!(resources_dir_path());
+    placeholder_path.push("rippy.png");
+    let mut file = try!(File::open(&placeholder_path));
+    let mut image_data = vec![];
+    try!(file.read_to_end(&mut image_data));
+    let mut image = load_from_memory(&image_data).unwrap();
+    if let Some(ref webrender_api) = *webrender_api {
+        let format = convert_format(image.format);
+        let mut bytes = Vec::new();
+        bytes.extend_from_slice(&*image.bytes);
+        image.id = Some(webrender_api.add_image(image.width, image.height, format, bytes));
+    }
+    Ok(Arc::new(image))
+}
 impl ImageCache {
     fn run(core_resource_thread: CoreResourceThread,
            webrender_api: Option<webrender_traits::RenderApi>,
            ipc_command_receiver: IpcReceiver<ImageCacheCommand>) {
         // Preload the placeholder image, used when images fail to load.
-        let mut placeholder_path = resources_dir_path();
-        placeholder_path.push("rippy.png");
-
-        let mut image_data = vec![];
-        let result = File::open(&placeholder_path).and_then(|mut file| {
-            file.read_to_end(&mut image_data)
-        });
-        let placeholder_image = result.ok().map(|_| {
-            let mut image = load_from_memory(&image_data).unwrap();
-            if let Some(ref webrender_api) = webrender_api {
-                let format = convert_format(image.format);
-                let mut bytes = Vec::new();
-                bytes.extend_from_slice(&*image.bytes);
-                image.id = Some(webrender_api.add_image(image.width, image.height, format, bytes));
-            }
-            Arc::new(image)
-        });
+        let placeholder_image = get_placeholder_image(&webrender_api).ok();
 
         // Ask the router to proxy messages received over IPC to us.
         let cmd_receiver = ROUTER.route_ipc_receiver_to_new_mpsc_receiver(ipc_command_receiver);