Initial implementation of asynchronous blob url fetching

components/net/blob_loader.rs

@@ -3,6 +3,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 use crate::filemanager_thread::FileManager;
+use fetch::methods::DoneChannel;
 use headers_core::HeaderMapExt;
 use headers_ext::{ContentLength, ContentType};
 use http::header::{self, HeaderValue};
@@ -11,18 +12,21 @@ use ipc_channel::ipc;
 use mime::{self, Mime};
 use net_traits::blob_url_store::parse_blob_url;
 use net_traits::filemanager_thread::ReadFileProgress;
+use net_traits::response::{Response, ResponseBody};
 use net_traits::{http_percent_encode, NetworkError};
 use servo_url::ServoUrl;
+use std::sync::mpsc::channel;
 
 // TODO: Check on GET
 // https://w3c.github.io/FileAPI/#requestResponseModel
 
 /// https://fetch.spec.whatwg.org/#concept-basic-fetch (partial)
-// TODO: make async.
-pub fn load_blob_sync(
+pub fn load_blob_async(
     url: ServoUrl,
     filemanager: FileManager,
-) -> Result<(HeaderMap, Vec<u8>), NetworkError> {
+    response: &Response,
+    done_chan: &mut DoneChannel
+) -> Result<(), NetworkError> {
     let (id, origin) = match parse_blob_url(&url) {
         Ok((id, origin)) => (id, origin),
         Err(()) => {
@@ -31,78 +35,11 @@ pub fn load_blob_sync(
         },
     };
 
-    let (sender, receiver) = ipc::channel().unwrap();
+    let (sender, receiver) = channel();
+    *done_chan = Some((sender.clone(), receiver));
+    *response.body.lock().unwrap() = ResponseBody::Receiving(vec![]);
     let check_url_validity = true;
-    filemanager.read_file(sender, id, check_url_validity, origin);
+    filemanager.fetch_file(sender, id, check_url_validity, origin, response);
 
-    let blob_buf = match receiver.recv().unwrap() {
-        Ok(ReadFileProgress::Meta(blob_buf)) => blob_buf,
-        Ok(_) => {
-            return Err(NetworkError::Internal(
-                "Invalid filemanager reply".to_string(),
-            ));
-        },
-        Err(e) => {
-            return Err(NetworkError::Internal(format!("{:?}", e)));
-        },
-    };
-
-    let content_type: Mime = blob_buf.type_string.parse().unwrap_or(mime::TEXT_PLAIN);
-    let charset = content_type.get_param(mime::CHARSET);
-
-    let mut headers = HeaderMap::new();
-
-    if let Some(name) = blob_buf.filename {
-        let charset = charset
-            .map(|c| c.as_ref().into())
-            .unwrap_or("us-ascii".to_owned());
-        // TODO(eijebong): Replace this once the typed header is there
-        headers.insert(
-            header::CONTENT_DISPOSITION,
-            HeaderValue::from_bytes(
-                format!(
-                    "inline; {}",
-                    if charset.to_lowercase() == "utf-8" {
-                        format!(
-                            "filename=\"{}\"",
-                            String::from_utf8(name.as_bytes().into()).unwrap()
-                        )
-                    } else {
-                        format!(
-                            "filename*=\"{}\"''{}",
-                            charset,
-                            http_percent_encode(name.as_bytes())
-                        )
-                    }
-                )
-                .as_bytes(),
-            )
-            .unwrap(),
-        );
-    }
-
-    // Basic fetch, Step 4.
-    headers.typed_insert(ContentLength(blob_buf.size as u64));
-    // Basic fetch, Step 5.
-    headers.typed_insert(ContentType::from(content_type.clone()));
-
-    let mut bytes = blob_buf.bytes;
-    loop {
-        match receiver.recv().unwrap() {
-            Ok(ReadFileProgress::Partial(ref mut new_bytes)) => {
-                bytes.append(new_bytes);
-            },
-            Ok(ReadFileProgress::EOF) => {
-                return Ok((headers, bytes));
-            },
-            Ok(_) => {
-                return Err(NetworkError::Internal(
-                    "Invalid filemanager reply".to_string(),
-                ));
-            },
-            Err(e) => {
-                return Err(NetworkError::Internal(format!("{:?}", e)));
-            },
-        }
-    }
+    Ok(())
 }