Implement async fetching of extenal script sources via interruptible parsing.

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 resource_task::{TargetedLoadResponse, Metadata, LoadData, start_sending, ResponseSenders};
+use resource_task::{Metadata, LoadData, start_sending, ResponseSenders};
 use resource_task::ProgressMsg::Done;
 use file_loader;
 
@@ -12,13 +12,8 @@ use util::resource_files::resources_dir_path;
 
 use std::borrow::IntoCow;
 use std::old_io::fs::PathExtensions;
-use std::sync::mpsc::Sender;
 
-pub fn factory(mut load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
-    let senders = ResponseSenders {
-        immediate_consumer: start_chan.clone(),
-        eventual_consumer: load_data.consumer.clone(),
-    };
+pub fn factory(mut load_data: LoadData, senders: ResponseSenders) {
     match load_data.url.non_relative_scheme_data().unwrap() {
         "blank" => {
             let chan = start_sending(senders, Metadata {
@@ -44,5 +39,5 @@ pub fn factory(mut load_data: LoadData, start_chan: Sender<TargetedLoadResponse>
             return
         }
     };
-    file_loader::factory(load_data, start_chan)
+    file_loader::factory(load_data, senders)
 }

components/net/data_loader.rs

@@ -2,35 +2,28 @@
  * 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 resource_task::{Metadata, LoadData, TargetedLoadResponse, start_sending, ResponseSenders};
+use resource_task::{Metadata, LoadData, start_sending, ResponseSenders};
 use resource_task::ProgressMsg::{Payload, Done};
 
 use rustc_serialize::base64::FromBase64;
 
 use hyper::mime::Mime;
 use url::{percent_decode, SchemeData};
 
-use std::sync::mpsc::Sender;
-
-pub fn factory(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
+pub fn factory(load_data: LoadData, senders: ResponseSenders) {
     // 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.
     // Left in separate function to allow easy moving to a task, if desired.
-    load(load_data, start_chan)
+    load(load_data, senders)
 }
 
-fn load(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
+fn load(load_data: LoadData, senders: ResponseSenders) {
     let url = load_data.url;
     assert!("data" == url.scheme.as_slice());
 
     let mut metadata = Metadata::default(url.clone());
 
-    let senders = ResponseSenders {
-        immediate_consumer: start_chan,
-        eventual_consumer: load_data.consumer,
-    };
-
     // Split out content type and data.
     let mut scheme_data = match url.scheme_data {
         SchemeData::NonRelative(scheme_data) => scheme_data,
@@ -93,10 +86,11 @@ fn assert_parse(url:          &'static str,
     use std::sync::mpsc::channel;
     use url::Url;
     use sniffer_task;
+    use resource_task::LoadConsumer::Channel;
 
     let (start_chan, start_port) = channel();
     let sniffer_task = sniffer_task::new_sniffer_task();
-    load(LoadData::new(Url::parse(url).unwrap(), start_chan), sniffer_task);
+    load(LoadData::new(Url::parse(url).unwrap(), Channel(start_chan)), sniffer_task);
 
     let response = start_port.recv().unwrap();
     assert_eq!(&response.metadata.content_type, &content_type);

components/net/file_loader.rs

@@ -2,18 +2,18 @@
  * 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 resource_task::{ProgressMsg, Metadata, LoadData, start_sending, TargetedLoadResponse, ResponseSenders};
+use resource_task::{Metadata, LoadData, start_sending};
+use resource_task::{ResponseSenders, ProgressSender};
 use resource_task::ProgressMsg::{Payload, Done};
 
 use std::borrow::ToOwned;
 use std::old_io as io;
 use std::old_io::File;
-use std::sync::mpsc::Sender;
 use util::task::spawn_named;
 
 static READ_SIZE: uint = 8192;
 
-fn read_all(reader: &mut io::Stream, progress_chan: &Sender<ProgressMsg>)
+fn read_all(reader: &mut io::Stream, progress_chan: &ProgressSender)
         -> Result<(), String> {
     loop {
         let mut buf = vec!();
@@ -32,13 +32,9 @@ fn read_all(reader: &mut io::Stream, progress_chan: &Sender<ProgressMsg>)
     }
 }
 
-pub fn factory(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
+pub fn factory(load_data: LoadData, senders: ResponseSenders) {
     let url = load_data.url;
     assert!("file" == url.scheme.as_slice());
-    let senders = ResponseSenders {
-        immediate_consumer: start_chan,
-        eventual_consumer: load_data.consumer,
-    };
     let progress_chan = start_sending(senders, Metadata::default(url.clone()));
     spawn_named("file_loader".to_owned(), move || {
         let file_path: Result<Path, ()> = url.to_file_path();

components/net/http_loader.rs

@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use cookie_storage::CookieSource;
-use resource_task::{Metadata, TargetedLoadResponse, LoadData, start_sending_opt, ResponseSenders};
+use resource_task::{Metadata, LoadData, start_sending_opt, ResponseSenders};
 use resource_task::ControlMsg;
 use resource_task::ProgressMsg::{Payload, Done};
 
@@ -28,9 +28,9 @@ use url::{Url, UrlParser};
 use std::borrow::ToOwned;
 
 pub fn factory(cookies_chan: Sender<ControlMsg>)
-               -> Box<Invoke<(LoadData, Sender<TargetedLoadResponse>)> + Send> {
-    box move |(load_data, start_chan)| {
-        spawn_named("http_loader".to_owned(), move || load(load_data, start_chan, cookies_chan))
+               -> Box<Invoke<(LoadData, ResponseSenders)> + Send> {
+    box move |(load_data, senders)| {
+        spawn_named("http_loader".to_owned(), move || load(load_data, senders, cookies_chan))
     }
 }
 
@@ -44,7 +44,7 @@ fn send_error(url: Url, err: String, senders: ResponseSenders) {
     };
 }
 
-fn load(mut load_data: LoadData, start_chan: Sender<TargetedLoadResponse>, cookies_chan: Sender<ControlMsg>) {
+fn load(mut load_data: LoadData, senders: ResponseSenders, 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.
@@ -53,11 +53,6 @@ fn load(mut load_data: LoadData, start_chan: Sender<TargetedLoadResponse>, cooki
     let mut url = load_data.url.clone();
     let mut redirected_to = HashSet::new();
 
-    let senders = ResponseSenders {
-        immediate_consumer: start_chan,
-        eventual_consumer: load_data.consumer
-    };
-
     // Loop to handle redirects.
     loop {
         iters = iters + 1;
@@ -97,8 +92,8 @@ reason: \"certificate verify failed\" }]";
                                                 detail: Some(ref det)})) if det.as_slice() == ssl_err_string => {
                 let mut image = resources_dir_path();
                 image.push("badcert.html");
-                let load_data = LoadData::new(Url::from_file_path(&image).unwrap(), senders.eventual_consumer);
-                file_loader::factory(load_data, senders.immediate_consumer);
+                let load_data = LoadData::new(Url::from_file_path(&image).unwrap());
+                file_loader::factory(load_data, senders);
                 return;
             },
             Err(e) => {

components/net/image_cache_task.rs

@@ -6,6 +6,7 @@ use image::base::{Image, load_from_memory};
 use resource_task;
 use resource_task::{LoadData, ResourceTask};
 use resource_task::ProgressMsg::{Payload, Done};
+use resource_task::LoadConsumer::Channel;
 
 use util::task::spawn_named;
 use util::taskpool::TaskPool;
@@ -448,7 +449,7 @@ impl ImageCacheTask {
 
 fn load_image_data(url: Url, resource_task: ResourceTask) -> Result<Vec<u8>, ()> {
     let (response_chan, response_port) = channel();
-    resource_task.send(resource_task::ControlMsg::Load(LoadData::new(url, response_chan))).unwrap();
+    resource_task.send(resource_task::ControlMsg::Load(LoadData::new(url), Channel(response_chan))).unwrap();
 
     let mut image_data = vec!();