Remove CoreResourceMsg::Load.

Also remove now-dead code that rustc warns about.

It turns out that we lost support for some of our custom URL schemes; I intend
to reimplement them, but I believe this will be significantly easier to do
once the legacy code is out of the way.

components/net/resource_thread.rs

@@ -3,21 +3,16 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 //! A thread that takes a URL and streams back the binary data.
-use about_loader;
-use blob_loader;
-use chrome_loader;
 use connector::{Connector, create_http_connector};
 use content_blocker::BLOCKED_CONTENT_RULES;
 use cookie;
 use cookie_rs;
 use cookie_storage::CookieStorage;
-use data_loader;
 use devtools_traits::DevtoolsControlMsg;
 use fetch::methods::{FetchContext, fetch};
-use file_loader;
 use filemanager_thread::{FileManager, TFDProvider};
 use hsts::HstsList;
-use http_loader::{self, HttpState};
+use http_loader::HttpState;
 use hyper::client::pool::Pool;
 use hyper::header::{ContentType, Header, SetCookie};
 use hyper::mime::{Mime, SubLevel, TopLevel};
@@ -26,7 +21,7 @@ use ipc_channel::ipc::{self, IpcReceiver, IpcReceiverSet, IpcSender};
 use mime_classifier::{ApacheBugFlag, MimeClassifier, NoSniffFlag};
 use net_traits::{CookieSource, CoreResourceThread, Metadata, ProgressMsg};
 use net_traits::{CoreResourceMsg, FetchResponseMsg, FetchTaskTarget, LoadConsumer};
-use net_traits::{CustomResponseMediator, LoadData, LoadResponse, NetworkError, ResourceId};
+use net_traits::{CustomResponseMediator, LoadResponse, NetworkError, ResourceId};
 use net_traits::{ResourceThreads, WebSocketCommunicate, WebSocketConnectData};
 use net_traits::LoadContext;
 use net_traits::ProgressMsg::Done;
@@ -37,7 +32,6 @@ use rustc_serialize::{Decodable, Encodable};
 use rustc_serialize::json;
 use servo_url::ServoUrl;
 use std::borrow::{Cow, ToOwned};
-use std::boxed::FnBox;
 use std::cell::Cell;
 use std::collections::HashMap;
 use std::error::Error;
@@ -47,7 +41,7 @@ use std::ops::Deref;
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use std::sync::{Arc, RwLock};
-use std::sync::mpsc::{Receiver, Sender, channel};
+use std::sync::mpsc::{Receiver, Sender};
 use storage_thread::StorageThreadFactory;
 use util::prefs::PREFS;
 use util::thread::spawn_named;
@@ -252,10 +246,8 @@ impl ResourceChannelManager {
     fn process_msg(&mut self,
                    msg: CoreResourceMsg,
                    group: &ResourceGroup,
-                   control_sender: &CoreResourceThread) -> bool {
+                   _control_sender: &CoreResourceThread) -> bool {
         match msg {
-            CoreResourceMsg::Load(load_data, consumer, id_sender) =>
-                self.resource_manager.load(load_data, consumer, id_sender, control_sender.clone(), group),
             CoreResourceMsg::Fetch(init, sender) =>
                 self.resource_manager.fetch(init, sender, group),
             CoreResourceMsg::WebsocketConnect(connect, connect_data) =>
@@ -451,28 +443,22 @@ pub struct AuthCache {
 
 pub struct CoreResourceManager {
     user_agent: Cow<'static, str>,
-    mime_classifier: Arc<MimeClassifier>,
     devtools_chan: Option<Sender<DevtoolsControlMsg>>,
     swmanager_chan: Option<IpcSender<CustomResponseMediator>>,
-    profiler_chan: ProfilerChan,
     filemanager: FileManager,
     cancel_load_map: HashMap<ResourceId, Sender<()>>,
-    next_resource_id: ResourceId,
 }
 
 impl CoreResourceManager {
     pub fn new(user_agent: Cow<'static, str>,
                devtools_channel: Option<Sender<DevtoolsControlMsg>>,
-               profiler_chan: ProfilerChan) -> CoreResourceManager {
+               _profiler_chan: ProfilerChan) -> CoreResourceManager {
         CoreResourceManager {
             user_agent: user_agent,
-            mime_classifier: Arc::new(MimeClassifier::new()),
             devtools_chan: devtools_channel,
             swmanager_chan: None,
-            profiler_chan: profiler_chan,
             filemanager: FileManager::new(),
             cancel_load_map: HashMap::new(),
-            next_resource_id: ResourceId(0),
         }
     }
 
@@ -500,66 +486,6 @@ impl CoreResourceManager {
         }
     }
 
-    fn load(&mut self,
-            load_data: LoadData,
-            consumer: LoadConsumer,
-            id_sender: Option<IpcSender<ResourceId>>,
-            resource_thread: CoreResourceThread,
-            resource_grp: &ResourceGroup) {
-        fn from_factory(factory: fn(LoadData, LoadConsumer, Arc<MimeClassifier>, CancellationListener))
-                        -> Box<FnBox(LoadData,
-                                     LoadConsumer,
-                                     Arc<MimeClassifier>,
-                                     CancellationListener) + Send> {
-            box move |load_data, senders, classifier, cancel_listener| {
-                factory(load_data, senders, classifier, cancel_listener)
-            }
-        }
-
-        let cancel_resource = id_sender.map(|sender| {
-            let current_res_id = self.next_resource_id;
-            let _ = sender.send(current_res_id);
-            let (cancel_sender, cancel_receiver) = channel();
-            self.cancel_load_map.insert(current_res_id, cancel_sender);
-            self.next_resource_id.0 += 1;
-            CancellableResource::new(cancel_receiver, current_res_id, resource_thread)
-        });
-
-        let cancel_listener = CancellationListener::new(cancel_resource);
-        let loader = match load_data.url.scheme() {
-            "chrome" => from_factory(chrome_loader::factory),
-            "file" => from_factory(file_loader::factory),
-            "http" | "https" | "view-source" => {
-                let http_state = HttpState {
-                    blocked_content: BLOCKED_CONTENT_RULES.clone(),
-                    hsts_list: resource_grp.hsts_list.clone(),
-                    cookie_jar: resource_grp.cookie_jar.clone(),
-                    auth_cache: resource_grp.auth_cache.clone()
-                };
-                http_loader::factory(self.user_agent.clone(),
-                                     http_state,
-                                     self.devtools_chan.clone(),
-                                     self.profiler_chan.clone(),
-                                     self.swmanager_chan.clone(),
-                                     resource_grp.connector.clone())
-            },
-            "data" => from_factory(data_loader::factory),
-            "about" => from_factory(about_loader::factory),
-            "blob" => blob_loader::factory(self.filemanager.clone()),
-            _ => {
-                debug!("resource_thread: no loader for scheme {}", load_data.url.scheme());
-                send_error(load_data.url, NetworkError::Internal("no loader for scheme".to_owned()), consumer);
-                return
-            }
-        };
-        debug!("loading url: {}", load_data.url);
-
-        loader.call_box((load_data,
-                         consumer,
-                         self.mime_classifier.clone(),
-                         cancel_listener));
-    }
-
     fn fetch(&self,
              init: RequestInit,
              sender: IpcSender<FetchResponseMsg>,