1 files changed, 23 insertions, 23 deletions

diff --git a/components/net/resource_task.rs b/components/net/resource_task.rs
index b33665ba6c8..3093df5e56a 100644
--- a/components/net/resource_task.rs
+++ b/components/net/resource_task.rs
@@ -21,7 +21,7 @@ use hyper::mime::{Mime, Attr};
 use url::Url;
 
 use std::borrow::ToOwned;
-use std::comm::{channel, Receiver, Sender};
+use std::sync::mpsc::{channel, Receiver, Sender};
 
 pub enum ControlMsg {
     /// Request the data associated with a particular URL
@@ -29,7 +29,7 @@ pub enum ControlMsg {
     Exit
 }
 
-#[deriving(Clone)]
+#[derive(Clone)]
 pub struct LoadData {
     pub url: Url,
     pub method: Method,
@@ -52,7 +52,7 @@ impl LoadData {
     }
 }
 
-#[deriving(Clone)]
+#[derive(Clone)]
 pub struct ResourceCORSData {
     /// CORS Preflight flag
     pub preflight: bool,
@@ -131,7 +131,7 @@ pub struct ResponseSenders {
 }
 
 /// Messages sent in response to a `Load` message
-#[deriving(PartialEq,Show)]
+#[derive(PartialEq,Show)]
 pub enum ProgressMsg {
     /// Binary data - there may be multiple of these
     Payload(Vec<u8>),
@@ -147,7 +147,7 @@ pub fn start_sending(senders: ResponseSenders, metadata: Metadata) -> Sender<Pro
 /// For use by loaders in responding to a Load message.
 pub fn start_sending_opt(senders: ResponseSenders, metadata: Metadata) -> Result<Sender<ProgressMsg>, ()> {
     let (progress_chan, progress_port) = channel();
-    let result = senders.immediate_consumer.send_opt(TargetedLoadResponse {
+    let result = senders.immediate_consumer.send(TargetedLoadResponse {
         load_response: LoadResponse {
             metadata:      metadata,
             progress_port: progress_port,
@@ -165,11 +165,11 @@ pub fn load_whole_resource(resource_task: &ResourceTask, url: Url)
         -> Result<(Metadata, Vec<u8>), String> {
     let (start_chan, start_port) = channel();
     resource_task.send(ControlMsg::Load(LoadData::new(url, start_chan)));
-    let response = start_port.recv();
+    let response = start_port.recv().unwrap();
 
     let mut buf = vec!();
     loop {
-        match response.progress_port.recv() {
+        match response.progress_port.recv().unwrap() {
             ProgressMsg::Payload(data) => buf.push_all(data.as_slice()),
             ProgressMsg::Done(Ok(()))  => return Ok((response.metadata, buf)),
             ProgressMsg::Done(Err(e))  => return Err(e)
@@ -184,7 +184,7 @@ pub type ResourceTask = Sender<ControlMsg>;
 pub fn new_resource_task(user_agent: Option<String>) -> ResourceTask {
     let (setup_chan, setup_port) = channel();
     let sniffer_task = sniffer_task::new_sniffer_task();
-    spawn_named("ResourceManager".to_owned(), proc() {
+    spawn_named("ResourceManager".to_owned(), move || {
         ResourceManager::new(setup_port, user_agent, sniffer_task).start();
     });
     setup_chan
@@ -210,7 +210,7 @@ impl ResourceManager {
 impl ResourceManager {
     fn start(&self) {
         loop {
-            match self.from_client.recv() {
+            match self.from_client.recv().unwrap() {
               ControlMsg::Load(load_data) => {
                 self.load(load_data)
               }
@@ -229,21 +229,19 @@ impl ResourceManager {
             eventual_consumer: load_data.consumer.clone(),
         };
 
-        let loader = match load_data.url.scheme.as_slice() {
-            "file" => file_loader::factory,
-            "http" | "https" => http_loader::factory,
-            "data" => data_loader::factory,
-            "about" => about_loader::factory,
+        debug!("resource_task: loading url: {}", load_data.url.serialize());
+        match load_data.url.scheme.as_slice() {
+            "file" => file_loader::factory(load_data, self.sniffer_task.clone()),
+            "http" | "https" => http_loader::factory(load_data, self.sniffer_task.clone()),
+            "data" => data_loader::factory(load_data, self.sniffer_task.clone()),
+            "about" => about_loader::factory(load_data, self.sniffer_task.clone()),
             _ => {
                 debug!("resource_task: no loader for scheme {}", load_data.url.scheme);
                 start_sending(senders, Metadata::default(load_data.url))
                     .send(ProgressMsg::Done(Err("no loader for scheme".to_string())));
                 return
             }
-        };
-        debug!("resource_task: loading url: {}", load_data.url.serialize());
-
-        loader(load_data, self.sniffer_task.clone());
+        }
     }
 }
 
@@ -252,7 +250,7 @@ pub fn load_bytes_iter(resource_task: &ResourceTask, url: Url) -> (Metadata, Pro
     let (input_chan, input_port) = channel();
     resource_task.send(ControlMsg::Load(LoadData::new(url, input_chan)));
 
-    let response = input_port.recv();
+    let response = input_port.recv().unwrap();
     let iter = ProgressMsgPortIterator { progress_port: response.progress_port };
     (response.metadata, iter)
 }
@@ -262,9 +260,11 @@ pub struct ProgressMsgPortIterator {
     progress_port: Receiver<ProgressMsg>
 }
 
-impl Iterator<Vec<u8>> for ProgressMsgPortIterator {
+impl Iterator for ProgressMsgPortIterator {
+    type Item = Vec<u8>;
+
     fn next(&mut self) -> Option<Vec<u8>> {
-        match self.progress_port.recv() {
+        match self.progress_port.recv().unwrap() {
             ProgressMsg::Payload(data) => Some(data),
             ProgressMsg::Done(Ok(()))  => None,
             ProgressMsg::Done(Err(e))  => {
@@ -287,8 +287,8 @@ fn test_bad_scheme() {
     let (start_chan, start) = channel();
     let url = Url::parse("bogus://whatever").unwrap();
     resource_task.send(ControlMsg::Load(LoadData::new(url, start_chan)));
-    let response = start.recv();
-    match response.progress_port.recv() {
+    let response = start.recv().unwrap();
+    match response.progress_port.recv().unwrap() {
       ProgressMsg::Done(result) => { assert!(result.is_err()) }
       _ => panic!("bleh")
     }