Remove the unused CancellationListener arguments in filemanager_thread.

components/net/blob_loader.rs

@@ -31,7 +31,7 @@ pub fn load_blob_sync
 
     let (sender, receiver) = ipc::channel().unwrap();
     let check_url_validity = true;
-    filemanager.read_file(sender, id, check_url_validity, origin, None);
+    filemanager.read_file(sender, id, check_url_validity, origin);
 
     let blob_buf = match receiver.recv().unwrap() {
         Ok(ReadFileProgress::Meta(blob_buf)) => blob_buf,

components/net/filemanager_thread.rs

@@ -7,7 +7,6 @@ use mime_guess::guess_mime_type_opt;
 use net_traits::blob_url_store::{BlobBuf, BlobURLStoreError};
 use net_traits::filemanager_thread::{FileManagerResult, FileManagerThreadMsg, FileOrigin, FilterPattern};
 use net_traits::filemanager_thread::{FileManagerThreadError, ReadFileProgress, RelativePos, SelectedFile};
-use resource_thread::CancellationListener;
 use std::collections::HashMap;
 use std::fs::File;
 use std::io::{Read, Seek, SeekFrom};
@@ -128,12 +127,11 @@ impl FileManager {
                      sender: IpcSender<FileManagerResult<ReadFileProgress>>,
                      id: Uuid,
                      check_url_validity: bool,
-                     origin: FileOrigin,
-                     cancel_listener: Option<CancellationListener>) {
+                     origin: FileOrigin) {
         let store = self.store.clone();
         spawn_named("read file".to_owned(), move || {
             if let Err(e) = store.try_read_file(&sender, id, check_url_validity,
-                                                origin, cancel_listener) {
+                                                origin) {
                 let _ = sender.send(Err(FileManagerThreadError::BlobURLStoreError(e)));
             }
         })
@@ -153,7 +151,6 @@ impl FileManager {
     /// Message handler
     pub fn handle<UI>(&self,
                       msg: FileManagerThreadMsg,
-                      cancel_listener: Option<CancellationListener>,
                       ui: &'static UI)
         where UI: UIProvider + 'static,
     {
@@ -171,7 +168,7 @@ impl FileManager {
                 })
             }
             FileManagerThreadMsg::ReadFile(sender, id, check_url_validity, origin) => {
-                self.read_file(sender, id, check_url_validity, origin, cancel_listener);
+                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);
@@ -393,8 +390,7 @@ impl FileManagerStore {
 
     fn get_blob_buf(&self, sender: &IpcSender<FileManagerResult<ReadFileProgress>>,
                     id: &Uuid, origin_in: &FileOrigin, rel_pos: RelativePos,
-                    check_url_validity: bool,
-                    cancel_listener: Option<CancellationListener>) -> Result<(), BlobURLStoreError> {
+                    check_url_validity: bool) -> Result<(), BlobURLStoreError> {
         let file_impl = try!(self.get_impl(id, origin_in, check_url_validity));
         match file_impl {
             FileImpl::Memory(buf) => {
@@ -437,7 +433,7 @@ impl FileManagerStore {
                     };
 
                     chunked_read(sender, &mut file, range.len(), opt_filename,
-                                 type_string, cancel_listener);
+                                 type_string);
                     Ok(())
                 } else {
                     Err(BlobURLStoreError::InvalidEntry)
@@ -447,17 +443,16 @@ impl FileManagerStore {
                 // Next time we don't need to check validity since
                 // we have already done that for requesting URL if necessary
                 self.get_blob_buf(sender, &parent_id, origin_in,
-                                  rel_pos.slice_inner(&inner_rel_pos), false,
-                                  cancel_listener)
+                                  rel_pos.slice_inner(&inner_rel_pos), false)
             }
         }
     }
 
     // Convenient wrapper over get_blob_buf
     fn try_read_file(&self, sender: &IpcSender<FileManagerResult<ReadFileProgress>>,
-                     id: Uuid, check_url_validity: bool, origin_in: FileOrigin,
-                     cancel_listener: Option<CancellationListener>) -> Result<(), BlobURLStoreError> {
-        self.get_blob_buf(sender, &id, &origin_in, RelativePos::full_range(), check_url_validity, cancel_listener)
+                     id: Uuid, check_url_validity: bool, origin_in: FileOrigin)
+                     -> Result<(), BlobURLStoreError> {
+        self.get_blob_buf(sender, &id, &origin_in, RelativePos::full_range(), check_url_validity)
     }
 
     fn dec_ref(&self, id: &Uuid, origin_in: &FileOrigin) -> Result<(), BlobURLStoreError> {
@@ -569,7 +564,7 @@ const CHUNK_SIZE: usize = 8192;
 
 fn chunked_read(sender: &IpcSender<FileManagerResult<ReadFileProgress>>,
                 file: &mut File, size: usize, opt_filename: Option<String>,
-                type_string: String, cancel_listener: Option<CancellationListener>) {
+                type_string: String) {
     // First chunk
     let mut buf = vec![0; CHUNK_SIZE];
     match file.read(&mut buf) {
@@ -591,12 +586,6 @@ fn chunked_read(sender: &IpcSender<FileManagerResult<ReadFileProgress>>,
 
     // Send the remaining chunks
     loop {
-        if let Some(ref listener) = cancel_listener.as_ref() {
-            if listener.is_cancelled() {
-                break;
-            }
-        }
-
         let mut buf = vec![0; CHUNK_SIZE];
         match file.read(&mut buf) {
             Ok(0) => {

components/net/resource_thread.rs

@@ -277,7 +277,7 @@ impl ResourceChannelManager {
             CoreResourceMsg::Synchronize(sender) => {
                 let _ = sender.send(());
             }
-            CoreResourceMsg::ToFileManager(msg) => self.resource_manager.filemanager.handle(msg, None, TFD_PROVIDER),
+            CoreResourceMsg::ToFileManager(msg) => self.resource_manager.filemanager.handle(msg, TFD_PROVIDER),
             CoreResourceMsg::Exit(sender) => {
                 if let Some(ref config_dir) = self.config_dir {
                     match group.auth_cache.read() {

tests/unit/net/filemanager_thread.rs

@@ -42,7 +42,7 @@ fn test_filemanager() {
         // Try to select a dummy file "tests/unit/net/test.jpeg"
         let (tx, rx) = ipc::channel().unwrap();
         filemanager.handle(FileManagerThreadMsg::SelectFile(patterns.clone(), tx, origin.clone(), None),
-                           None, TEST_PROVIDER);
+                           TEST_PROVIDER);
         let selected = rx.recv().expect("Broken channel")
                                 .expect("The file manager failed to find test.jpeg");
 
@@ -54,7 +54,7 @@ fn test_filemanager() {
         {
             let (tx2, rx2) = ipc::channel().unwrap();
             filemanager.handle(FileManagerThreadMsg::ReadFile(tx2, selected.id.clone(), false, origin.clone()),
-                               None, TEST_PROVIDER);
+                               TEST_PROVIDER);
 
             let msg = rx2.recv().expect("Broken channel");
 
@@ -85,7 +85,7 @@ fn test_filemanager() {
         {
             let (tx2, rx2) = ipc::channel().unwrap();
             filemanager.handle(FileManagerThreadMsg::DecRef(selected.id.clone(), origin.clone(), tx2),
-                               None, TEST_PROVIDER);
+                               TEST_PROVIDER);
 
             let ret = rx2.recv().expect("Broken channel");
             assert!(ret.is_ok(), "DecRef is not okay");
@@ -95,7 +95,7 @@ fn test_filemanager() {
         {
             let (tx2, rx2) = ipc::channel().unwrap();
             filemanager.handle(FileManagerThreadMsg::ReadFile(tx2, selected.id.clone(), false, origin.clone()),
-                               None, TEST_PROVIDER);
+                               TEST_PROVIDER);
 
             let msg = rx2.recv().expect("Broken channel");