Replace usage of ResponseSenders by LoadConsumer

components/net/about_loader.rs

@@ -2,7 +2,7 @@
  * 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 net_traits::{LoadData, Metadata,ResponseSenders};
+use net_traits::{LoadData, Metadata, LoadConsumer};
 use net_traits::ProgressMsg::Done;
 use mime_classifier::MIMEClassifier;
 use resource_task::start_sending;
@@ -18,7 +18,7 @@ use std::borrow::IntoCow;
 use std::fs::PathExt;
 use std::sync::Arc;
 
-pub fn factory(mut load_data: LoadData, start_chan: ResponseSenders, classifier: Arc<MIMEClassifier>) {
+pub fn factory(mut load_data: LoadData, start_chan: LoadConsumer, classifier: Arc<MIMEClassifier>) {
     match load_data.url.non_relative_scheme_data().unwrap() {
         "blank" => {
             let chan = start_sending(start_chan, Metadata {

components/net/data_loader.rs

@@ -2,7 +2,7 @@
  * 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 net_traits::{LoadData, Metadata, ResponseSenders};
+use net_traits::{LoadData, Metadata, LoadConsumer};
 use net_traits::ProgressMsg::{Payload, Done};
 use mime_classifier::MIMEClassifier;
 use resource_task::start_sending;
@@ -13,7 +13,7 @@ use hyper::mime::Mime;
 use std::sync::Arc;
 use url::{percent_decode, SchemeData};
 
-pub fn factory(load_data: LoadData, senders: ResponseSenders, _classifier: Arc<MIMEClassifier>) {
+pub fn factory(load_data: LoadData, senders: LoadConsumer, _classifier: Arc<MIMEClassifier>) {
     // NB: we don't spawn a new task.
     // Hypothesis: data URLs are too small for parallel base64 etc. to be worth it.
     // Should be tested at some point.
@@ -21,7 +21,7 @@ pub fn factory(load_data: LoadData, senders: ResponseSenders, _classifier: Arc<M
     load(load_data, senders)
 }
 
-pub fn load(load_data: LoadData, start_chan: ResponseSenders) {
+pub fn load(load_data: LoadData, start_chan: LoadConsumer) {
     let url = load_data.url;
     assert!(&*url.scheme == "data");
 

components/net/file_loader.rs

@@ -2,7 +2,7 @@
  * 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 net_traits::{LoadData, Metadata, ResponseSenders};
+use net_traits::{LoadData, Metadata, LoadConsumer};
 use net_traits::ProgressMsg::{Payload, Done};
 use mime_classifier::MIMEClassifier;
 use resource_task::{start_sending, start_sending_sniffed, ProgressSender};
@@ -43,7 +43,7 @@ fn read_all(reader: &mut File, progress_chan: &ProgressSender)
     }
 }
 
-pub fn factory(load_data: LoadData, senders: ResponseSenders, classifier: Arc<MIMEClassifier>) {
+pub fn factory(load_data: LoadData, senders: LoadConsumer, classifier: Arc<MIMEClassifier>) {
     let url = load_data.url;
     assert!(&*url.scheme == "file");
     spawn_named("file_loader".to_owned(), move || {

components/net/http_loader.rs

@@ -2,7 +2,7 @@
  * 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 net_traits::{ControlMsg, CookieSource, LoadData, Metadata, ResponseSenders};
+use net_traits::{ControlMsg, CookieSource, LoadData, Metadata, LoadConsumer};
 use net_traits::ProgressMsg::{Payload, Done};
 use mime_classifier::MIMEClassifier;
 use resource_task::{start_sending_opt, start_sending_sniffed_opt};
@@ -32,13 +32,13 @@ use url::{Url, UrlParser};
 use std::borrow::ToOwned;
 
 pub fn factory(cookies_chan: Sender<ControlMsg>)
-               -> Box<Invoke<(LoadData, ResponseSenders, Arc<MIMEClassifier>)> + Send> {
+               -> Box<Invoke<(LoadData, LoadConsumer, Arc<MIMEClassifier>)> + Send> {
     box move |(load_data, senders, classifier)| {
         spawn_named("http_loader".to_owned(), move || load(load_data, senders, classifier, cookies_chan))
     }
 }
 
-fn send_error(url: Url, err: String, start_chan: ResponseSenders) {
+fn send_error(url: Url, err: String, start_chan: LoadConsumer) {
     let mut metadata: Metadata = Metadata::default(url);
     metadata.status = None;
 
@@ -66,7 +66,7 @@ fn read_block<R: Read>(reader: &mut R) -> Result<ReadResult, ()> {
     }
 }
 
-fn load(mut load_data: LoadData, start_chan: ResponseSenders, classifier: Arc<MIMEClassifier>, cookies_chan: Sender<ControlMsg>) {
+fn load(mut load_data: LoadData, start_chan: LoadConsumer, classifier: Arc<MIMEClassifier>, cookies_chan: Sender<ControlMsg>) {
     // FIXME: At the time of writing this FIXME, servo didn't have any central
     //        location for configuration. If you're reading this and such a
     //        repository DOES exist, please update this constant to use it.
@@ -339,7 +339,7 @@ reason: \"certificate verify failed\" }]";
 }
 
 fn send_data<R: Read>(reader: &mut R,
-                      start_chan: ResponseSenders,
+                      start_chan: LoadConsumer,
                       metadata: Metadata,
                       classifier: Arc<MIMEClassifier>) {
     let (progress_chan, mut chunk) = {

components/net/resource_task.rs

@@ -12,7 +12,7 @@ use cookie_storage::CookieStorage;
 use cookie;
 use mime_classifier::MIMEClassifier;
 
-use net_traits::{ControlMsg, LoadData, LoadResponse, ResponseSenders, LoadConsumer};
+use net_traits::{ControlMsg, LoadData, LoadResponse, LoadConsumer};
 use net_traits::{Metadata, ProgressMsg, ResourceTask, AsyncResponseTarget, ResponseAction};
 use net_traits::ProgressMsg::Done;
 use util::opts;
@@ -81,19 +81,19 @@ impl ProgressSender {
 }
 
 /// For use by loaders in responding to a Load message.
-pub fn start_sending(start_chan: ResponseSenders, metadata: Metadata) -> ProgressSender {
+pub fn start_sending(start_chan: LoadConsumer, metadata: Metadata) -> ProgressSender {
     start_sending_opt(start_chan, metadata).ok().unwrap()
 }
 
 /// For use by loaders in responding to a Load message that allows content sniffing.
-pub fn start_sending_sniffed(start_chan: ResponseSenders, metadata: Metadata,
+pub fn start_sending_sniffed(start_chan: LoadConsumer, metadata: Metadata,
                              classifier: Arc<MIMEClassifier>, partial_body: &Vec<u8>)
                              -> ProgressSender {
     start_sending_sniffed_opt(start_chan, metadata, classifier, partial_body).ok().unwrap()
 }
 
 /// For use by loaders in responding to a Load message that allows content sniffing.
-pub fn start_sending_sniffed_opt(start_chan: ResponseSenders, mut metadata: Metadata,
+pub fn start_sending_sniffed_opt(start_chan: LoadConsumer, mut metadata: Metadata,
                                  classifier: Arc<MIMEClassifier>, partial_body: &Vec<u8>)
                                  -> Result<ProgressSender, ()> {
     if opts::get().sniff_mime_types {
@@ -116,9 +116,9 @@ pub fn start_sending_sniffed_opt(start_chan: ResponseSenders, mut metadata: Meta
 }
 
 /// For use by loaders in responding to a Load message.
-pub fn start_sending_opt(start_chan: ResponseSenders, metadata: Metadata) -> Result<ProgressSender, ()> {
+pub fn start_sending_opt(start_chan: LoadConsumer, metadata: Metadata) -> Result<ProgressSender, ()> {
     match start_chan {
-        ResponseSenders::Channel(start_chan) => {
+        LoadConsumer::Channel(start_chan) => {
             let (progress_chan, progress_port) = channel();
             let result = start_chan.send(LoadResponse {
                 metadata:      metadata,
@@ -129,7 +129,7 @@ pub fn start_sending_opt(start_chan: ResponseSenders, metadata: Metadata) -> Res
                 Err(_) => Err(())
             }
         }
-        ResponseSenders::Listener(target) => {
+        LoadConsumer::Listener(target) => {
             target.invoke_with_listener(ResponseAction::HeadersAvailable(metadata));
             Ok(ProgressSender::Listener(target))
         }
@@ -238,14 +238,13 @@ impl ResourceManager {
 
         self.user_agent.as_ref().map(|ua| load_data.headers.set(UserAgent(ua.clone())));
 
-        fn from_factory(factory: fn(LoadData, ResponseSenders, Arc<MIMEClassifier>))
+        fn from_factory(factory: fn(LoadData, LoadConsumer, Arc<MIMEClassifier>))
-                        -> Box<Invoke<(LoadData, ResponseSenders, Arc<MIMEClassifier>)> + Send> {
+                        -> Box<Invoke<(LoadData, LoadConsumer, Arc<MIMEClassifier>)> + Send> {
             box move |(load_data, senders, classifier)| {
                 factory(load_data, senders, classifier)
             }
         }
 
-        let senders = ResponseSenders::from_consumer(consumer);
         let loader = match &*load_data.url.scheme {
             "file" => from_factory(file_loader::factory),
             "http" | "https" | "view-source" => http_loader::factory(self.resource_task.clone()),
@@ -253,13 +252,13 @@ impl ResourceManager {
             "about" => from_factory(about_loader::factory),
             _ => {
                 debug!("resource_task: no loader for scheme {}", load_data.url.scheme);
-                start_sending(senders, Metadata::default(load_data.url))
+                start_sending(consumer, Metadata::default(load_data.url))
                     .send(ProgressMsg::Done(Err("no loader for scheme".to_string()))).unwrap();
                 return
             }
         };
         debug!("resource_task: loading url: {}", load_data.url.serialize());
 
-        loader.invoke((load_data, senders, self.mime_classifier.clone()));
+        loader.invoke((load_data, consumer, self.mime_classifier.clone()));
     }
 }

components/net_traits/lib.rs

@@ -203,20 +203,6 @@ pub enum CookieSource {
     NonHTTP,
 }
 
-pub enum ResponseSenders {
-    Channel(Sender<LoadResponse>),
-    Listener(Box<AsyncResponseTarget+ Send>),
-}
-
-impl ResponseSenders {
-    pub fn from_consumer(consumer: LoadConsumer) -> ResponseSenders {
-        match consumer {
-            LoadConsumer::Channel(c) => ResponseSenders::Channel(c),
-            LoadConsumer::Listener(l) => ResponseSenders::Listener(l),
-        }
-    }
-}
-
 /// Messages sent in response to a `Load` message
 #[derive(PartialEq,Debug)]
 pub enum ProgressMsg {

tests/unit/net/data_loader.rs

@@ -4,7 +4,7 @@
 
 extern crate hyper;
 
-use net_traits::ResponseSenders::Channel;
+use net_traits::LoadConsumer::Channel;
 use net_traits::LoadData;
 use net_traits::ProgressMsg::{Payload, Done};
 use self::hyper::header::ContentType;

tests/unit/net/image_cache_task.rs

@@ -7,7 +7,7 @@ use net_traits::image_cache_task::ImageResponseMsg::*;
 use net_traits::image_cache_task::Msg::*;
 
 use net::resource_task::{start_sending, ProgressSender};
-use net_traits::{ControlMsg, Metadata, ResourceTask, ResponseSenders};
+use net_traits::{ControlMsg, Metadata, ResourceTask};
 use net_traits::image_cache_task::{ImageCacheTask, ImageCacheTaskClient, ImageResponseMsg, Msg};
 use net_traits::ProgressMsg::{Payload, Done};
 use profile::time;
@@ -111,7 +111,7 @@ fn mock_resource_task<T: Closure + Send + 'static>(on_load: Box<T>) -> ResourceT
         loop {
             match port.recv().unwrap() {
                 ControlMsg::Load(_, consumer) => {
-                    let chan = start_sending(ResponseSenders::from_consumer(consumer), Metadata::default(
+                    let chan = start_sending(consumer, Metadata::default(
                         Url::parse("file:///fake").unwrap()));
                     on_load.invoke(chan);
                 }
@@ -281,7 +281,7 @@ fn should_not_request_image_from_resource_task_if_image_is_already_available() {
         loop {
             match port.recv().unwrap() {
                 ControlMsg::Load(_, consumer) => {
-                    let chan = start_sending(ResponseSenders::from_consumer(consumer), Metadata::default(
+                    let chan = start_sending(consumer, Metadata::default(
                         Url::parse("file:///fake").unwrap()));
                     chan.send(Payload(test_image_bin())).unwrap();
                     chan.send(Done(Ok(()))).unwrap();
@@ -330,7 +330,7 @@ fn should_not_request_image_from_resource_task_if_image_fetch_already_failed() {
         loop {
             match port.recv().unwrap() {
                 ControlMsg::Load(_, consumer) => {
-                    let chan = start_sending(ResponseSenders::from_consumer(consumer), Metadata::default(
+                    let chan = start_sending(consumer, Metadata::default(
                         Url::parse("file:///fake").unwrap()));
                     chan.send(Payload(test_image_bin())).unwrap();
                     chan.send(Done(Err("".to_string()))).unwrap();