create uuid before sending PromoteMemory message

components/net/filemanager_thread.rs

@@ -126,20 +126,8 @@ impl FileManager {
         )
     }
 
-    pub fn promote_memory(
-        &self,
-        blob_buf: BlobBuf,
-        set_valid: bool,
-        sender: IpcSender<Result<Uuid, BlobURLStoreError>>,
-        origin: FileOrigin,
-    ) {
-        let store = self.store.clone();
-        thread::Builder::new()
-            .name("transfer memory".to_owned())
-            .spawn(move || {
-                store.promote_memory(blob_buf, set_valid, sender, origin);
-            })
-            .expect("Thread spawning failed");
+    pub fn promote_memory(&self, id: Uuid, blob_buf: BlobBuf, set_valid: bool, origin: FileOrigin) {
+        self.store.promote_memory(id, blob_buf, set_valid, origin);
     }
 
     /// Message handler
@@ -168,8 +156,8 @@ impl FileManager {
             FileManagerThreadMsg::ReadFile(sender, id, check_url_validity, origin) => {
                 self.read_file(sender, id, check_url_validity, origin);
             },
-            FileManagerThreadMsg::PromoteMemory(blob_buf, set_valid, sender, origin) => {
-                self.promote_memory(blob_buf, set_valid, sender, origin);
+            FileManagerThreadMsg::PromoteMemory(id, blob_buf, set_valid, origin) => {
+                self.promote_memory(id, blob_buf, set_valid, origin);
             },
             FileManagerThreadMsg::AddSlicedURLEntry(id, rel_pos, sender, origin) => {
                 self.store.add_sliced_url_entry(id, rel_pos, sender, origin);
@@ -667,17 +655,10 @@ impl FileManagerStore {
         Ok(())
     }
 
-    fn promote_memory(
-        &self,
-        blob_buf: BlobBuf,
-        set_valid: bool,
-        sender: IpcSender<Result<Uuid, BlobURLStoreError>>,
-        origin: FileOrigin,
-    ) {
+    fn promote_memory(&self, id: Uuid, blob_buf: BlobBuf, set_valid: bool, origin: FileOrigin) {
         match Url::parse(&origin) {
             // parse to check sanity
             Ok(_) => {
-                let id = Uuid::new_v4();
                 self.insert(
                     id,
                     FileStoreEntry {
@@ -687,12 +668,8 @@ impl FileManagerStore {
                         is_valid_url: AtomicBool::new(set_valid),
                     },
                 );
-
-                let _ = sender.send(Ok(id));
-            },
-            Err(_) => {
-                let _ = sender.send(Err(BlobURLStoreError::InvalidOrigin));
             },
+            Err(_) => {},
         }
     }
 

components/net/tests/fetch.rs

@@ -47,6 +47,7 @@ use std::path::Path;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, SystemTime};
+use uuid::Uuid;
 
 // TODO write a struct that impls Handler for storing test values
 
@@ -125,7 +126,6 @@ fn test_fetch_aboutblank() {
 
 #[test]
 fn test_fetch_blob() {
-    use ipc_channel::ipc;
     use net_traits::blob_url_store::BlobBuf;
 
     struct FetchResponseCollector {
@@ -160,11 +160,10 @@ fn test_fetch_blob() {
 
     let origin = ServoUrl::parse("http://www.example.org/").unwrap();
 
-    let (sender, receiver) = ipc::channel().unwrap();
+    let id = Uuid::new_v4();
     context
         .filemanager
-        .promote_memory(blob_buf, true, sender, "http://www.example.org".into());
-    let id = receiver.recv().unwrap().unwrap();
+        .promote_memory(id.clone(), blob_buf, true, "http://www.example.org".into());
     let url = ServoUrl::parse(&format!("blob:{}{}", origin.as_str(), id.to_simple())).unwrap();
 
     let mut request = Request::new(url, Some(Origin::Origin(origin.origin())), None);

components/net_traits/filemanager_thread.rs

@@ -137,14 +137,8 @@ pub enum FileManagerThreadMsg {
         FileOrigin,
     ),
 
-    /// Add an entry as promoted memory-based blob and send back the associated FileID
-    /// as part of a valid/invalid Blob URL depending on the boolean flag
-    PromoteMemory(
-        BlobBuf,
-        bool,
-        IpcSender<Result<Uuid, BlobURLStoreError>>,
-        FileOrigin,
-    ),
+    /// Add an entry as promoted memory-based blob
+    PromoteMemory(Uuid, BlobBuf, bool, FileOrigin),
 
     /// Add a sliced entry pointing to the parent FileID, and send back the associated FileID
     /// as part of a valid Blob URL

components/script/dom/blob.rs

@@ -238,23 +238,17 @@ impl Blob {
             bytes: bytes.to_vec(),
         };
 
-        let (tx, rx) = ipc::channel(self.global().time_profiler_chan().clone()).unwrap();
-        let msg = FileManagerThreadMsg::PromoteMemory(blob_buf, set_valid, tx, origin.clone());
+        let id = Uuid::new_v4();
+        let msg = FileManagerThreadMsg::PromoteMemory(id, blob_buf, set_valid, origin.clone());
         self.send_to_file_manager(msg);
 
-        match rx.recv().unwrap() {
-            Ok(id) => {
-                *self.blob_impl.borrow_mut() = BlobImpl::File(FileBlob {
-                    id: id.clone(),
-                    name: None,
-                    cache: DomRefCell::new(Some(bytes.to_vec())),
-                    size: bytes.len() as u64,
-                });
-                id
-            },
-            // Dummy id
-            Err(_) => Uuid::new_v4(),
-        }
+        *self.blob_impl.borrow_mut() = BlobImpl::File(FileBlob {
+            id: id.clone(),
+            name: None,
+            cache: DomRefCell::new(Some(bytes.to_vec())),
+            size: bytes.len() as u64,
+        });
+        id
     }
 
     /// Get a FileID representing sliced parent-blob content