Read file in chunks and send chunks to FetchTaskTarget instead of rea…

…d_to_end call
servo · bors-servo · Sep 7, 2018 · Aug 28, 2018 · Sep 4, 2018 · Sep 6, 2018
commit f04c965a9bab46ff6943416baab338032bc526c1
diff --git a/components/net/fetch/methods.rs b/components/net/fetch/methods.rs
@@ -25,14 +25,16 @@ use servo_url::ServoUrl;
 use std::borrow::Cow;
 use std::fmt;
 use std::fs::File;
-use std::io::Read;
+use std::io::{BufReader, BufRead};
 use std::mem;
 use std::str;
 use std::sync::{Arc, Mutex};
 use std::sync::atomic::Ordering;
 use std::sync::mpsc::{Sender, Receiver};
 use subresource_integrity::is_response_integrity_valid;
 
+const FILE_CHUNK_SIZE: usize = 32768; //32 KB
+
 pub type Target<'a> = &'a mut (FetchTaskTarget + Send);
 
 pub enum Data {
@@ -486,8 +488,20 @@ fn scheme_fetch(request: &mut Request,
                     Ok(file_path) => {
                         match File::open(file_path.clone()) {
                             Ok(mut file) => {
-                                let mut bytes = vec![];
-                                let _ = file.read_to_end(&mut bytes);
+                                let mut reader = BufReader::with_capacity(FILE_CHUNK_SIZE, file);
+                                let mut bytes = Vec::new();
+                                loop {
+                                    let length = {
+                                        let mut buffer = reader.fill_buf().unwrap().to_vec();
+                                        let buffer_len = buffer.len();
+                                        bytes.append(&mut buffer);
+                                        target.process_response_chunk(buffer);
 // We're about to spawn a thread to be waited on here 
 let (done_sender, done_receiver) = channel(); 
 *done_chan = Some((done_sender.clone(), done_receiver)); 
 if cancellation_listener.lock().unwrap().cancelled() { 
     *res_body.lock().unwrap() = ResponseBody::Done(vec![]); 
     let _ = done_sender.send(Data::Cancelled); 
     return; 
 } 
 match read_block(&mut res) { 
     Ok(Data::Payload(chunk)) => { 
         if let ResponseBody::Receiving(ref mut body) = *res_body.lock().unwrap() { 
             body.extend_from_slice(&chunk); 
             let _ = done_sender.send(Data::Payload(chunk)); 
         } 
     }, 
     Ok(Data::Done) | Err(_) => { 
         let mut body = res_body.lock().unwrap(); 
         let completed_body = match *body { 
             ResponseBody::Receiving(ref mut body) => { 
                 mem::replace(body, vec![]) 
             }, 
             _ => vec![], 
         }; 
         *body = ResponseBody::Done(completed_body); 
         let _ = done_sender.send(Data::Done); 
         break; 
     } 
     Ok(Data::Cancelled) => unreachable!() // read_block doesn't return Data::Cancelled 
 // We're about to spawn a thread to be waited on here 
 let (done_sender, done_receiver) = channel(); 
 *done_chan = Some((done_sender.clone(), done_receiver)); 
 if cancellation_listener.lock().unwrap().cancelled() { 
     *res_body.lock().unwrap() = ResponseBody::Done(vec![]); 
     let _ = done_sender.send(Data::Cancelled); 
     return; 
 } 
 match read_block(&mut res) { 
     Ok(Data::Payload(chunk)) => { 
         if let ResponseBody::Receiving(ref mut body) = *res_body.lock().unwrap() { 
             body.extend_from_slice(&chunk); 
             let _ = done_sender.send(Data::Payload(chunk)); 
         } 
     }, 
     Ok(Data::Done) | Err(_) => { 
         let mut body = res_body.lock().unwrap(); 
         let completed_body = match *body { 
             ResponseBody::Receiving(ref mut body) => { 
                 mem::replace(body, vec![]) 
             }, 
             _ => vec![], 
         }; 
         *body = ResponseBody::Done(completed_body); 
         let _ = done_sender.send(Data::Done); 
         break; 
     } 
     Ok(Data::Cancelled) => unreachable!() // read_block doesn't return Data::Cancelled 
+                                        buffer_len
+                                    };
+                                    if length == 0 { break; }
+                                    reader.consume(length);
+                                }
+
                                 let mime = guess_mime_type(file_path);
 
                                 let mut response = Response::new(url);