Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-09-30 00:29:14 +01:00
Code Issues Projects Releases Packages Wiki Activity

add unwrap to send/recv calls

Browse source
This commit is contained in:
Alexandru Cojocaru 2015-01-29 22:11:03 +01:00 • committed by Ms2ger
parent 3da41c2b16
commit 685fee02a0
30 changed files with 100 additions and 100 deletions
Download patch file Download diff file Expand all files Collapse all files

4
components/net/about_loader.rs
View file

@ -28,7 +28,7 @@ pub fn factory(mut load_data: LoadData, start_chan: Sender<TargetedLoadResponse>
headers: None,
status: Some(RawStatus(200, "OK".to_owned()))
});
chan.send(Done(Ok(())));
chan.send(Done(Ok(()))).unwrap();
return
}
"crash" => panic!("Loading the about:crash URL."),
@ -40,7 +40,7 @@ pub fn factory(mut load_data: LoadData, start_chan: Sender<TargetedLoadResponse>
}
_ => {
start_sending(senders, Metadata::default(load_data.url))
.send(Done(Err("Unknown about: URL.".to_string())));
.send(Done(Err("Unknown about: URL.".to_string()))).unwrap();
return
}
};

12
components/net/data_loader.rs
View file

@ -45,7 +45,7 @@ fn load(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
}
let parts: Vec<&str> = scheme_data.as_slice().splitn(1, ',').collect();
if parts.len() != 2 {
start_sending(senders, metadata).send(Done(Err("invalid data uri".to_string())));
start_sending(senders, metadata).send(Done(Err("invalid data uri".to_string()))).unwrap();
return;
}
@ -72,16 +72,16 @@ fn load(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
let bytes = bytes.into_iter().filter(|&b| b != ' ' as u8).collect::<Vec<u8>>();
match bytes.as_slice().from_base64() {
Err(..) => {
progress_chan.send(Done(Err("non-base64 data uri".to_string())));
progress_chan.send(Done(Err("non-base64 data uri".to_string()))).unwrap();
}
Ok(data) => {
progress_chan.send(Payload(data));
progress_chan.send(Done(Ok(())));
progress_chan.send(Payload(data)).unwrap();
progress_chan.send(Done(Ok(()))).unwrap();
}
}
} else {
progress_chan.send(Payload(bytes));
progress_chan.send(Done(Ok(())));
progress_chan.send(Payload(bytes)).unwrap();
progress_chan.send(Done(Ok(()))).unwrap();
}
}

6
components/net/file_loader.rs
View file

@ -47,15 +47,15 @@ pub fn factory(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
match File::open_mode(&Path::new(file_path), io::Open, io::Read) {
Ok(ref mut reader) => {
let res = read_all(reader as &mut io::Stream, &progress_chan);
progress_chan.send(Done(res));
progress_chan.send(Done(res)).unwrap();
}
Err(e) => {
progress_chan.send(Done(Err(e.desc.to_string())));
progress_chan.send(Done(Err(e.desc.to_string()))).unwrap();
}
}
}
Err(_) => {
progress_chan.send(Done(Err(url.to_string())));
progress_chan.send(Done(Err(url.to_string()))).unwrap();
}
}
});

22
components/net/image_cache_task.rs
View file

@ -166,7 +166,7 @@ impl ImageCache {
Msg::Prefetch(url) => self.prefetch(url),
Msg::StorePrefetchedImageData(url, data) => {
store_prefetched_chan.map(|chan| {
chan.send(());
chan.send(()).unwrap();
});
store_prefetched_chan = None;
@ -175,7 +175,7 @@ impl ImageCache {
Msg::Decode(url) => self.decode(url),
Msg::StoreImage(url, image) => {
store_chan.map(|chan| {
chan.send(());
chan.send(()).unwrap();
});
store_chan = None;
@ -211,7 +211,7 @@ impl ImageCache {
}
if can_exit {
response.send(());
response.send(()).unwrap();
break;
} else {
self.need_exit = Some(response);
@ -245,7 +245,7 @@ impl ImageCache {
debug!("image_cache_task: started fetch for {}", url.serialize());
let image = load_image_data(url.clone(), resource_task.clone());
to_cache.send(Msg::StorePrefetchedImageData(url.clone(), image));
to_cache.send(Msg::StorePrefetchedImageData(url.clone(), image)).unwrap();
debug!("image_cache_task: ended fetch for {}", url.serialize());
});
@ -309,7 +309,7 @@ impl ImageCache {
debug!("image_cache_task: started image decode for {}", url.serialize());
let image = load_from_memory(data.as_slice());
let image = image.map(|image| Arc::new(box image));
to_cache.send(Msg::StoreImage(url.clone(), image));
to_cache.send(Msg::StoreImage(url.clone(), image)).unwrap();
debug!("image_cache_task: ended image decode for {}", url.serialize());
});
@ -354,7 +354,7 @@ impl ImageCache {
Some(waiters) => {
let items = waiters.lock().unwrap();
for response in items.iter() {
response.send(f());
response.send(f()).unwrap();
}
}
None => ()
@ -391,11 +391,11 @@ impl ImageCache {
}
ImageState::Decoded(image) => {
response.send(ImageResponseMsg::ImageReady(image));
response.send(ImageResponseMsg::ImageReady(image)).unwrap();
}
ImageState::Failed => {
response.send(ImageResponseMsg::ImageFailed);
response.send(ImageResponseMsg::ImageFailed).unwrap();
}
}
}
@ -417,7 +417,7 @@ impl ImageCacheTaskClient for ImageCacheTask {
impl ImageCacheTask {
pub fn send(&self, msg: Msg) {
self.chan.send(msg);
self.chan.send(msg).unwrap();
}
#[cfg(test)]
@ -437,7 +437,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)));
resource_task.send(resource_task::ControlMsg::Load(LoadData::new(url, response_chan))).unwrap();
let mut image_data = vec!();
@ -466,7 +466,7 @@ pub fn spawn_listener<F, A>(f: F) -> Sender<A>
spawn_named("ImageCacheTask (listener)".to_owned(), move || {
let (chan, port) = channel();
setup_chan.send(chan);
setup_chan.send(chan).unwrap();
f(port);
});
setup_port.recv().unwrap()

8
components/net/local_image_cache.rs
View file

@ -94,13 +94,13 @@ impl<NodeAddress: Send> LocalImageCache<NodeAddress> {
match state.last_response {
ImageResponseMsg::ImageReady(ref image) => {
let (chan, port) = channel();
chan.send(ImageResponseMsg::ImageReady(image.clone()));
chan.send(ImageResponseMsg::ImageReady(image.clone())).unwrap();
return port;
}
ImageResponseMsg::ImageNotReady => {
if last_round == round_number {
let (chan, port) = channel();
chan.send(ImageResponseMsg::ImageNotReady);
chan.send(ImageResponseMsg::ImageNotReady).unwrap();
return port;
} else {
// We haven't requested the image from the
@ -109,7 +109,7 @@ impl<NodeAddress: Send> LocalImageCache<NodeAddress> {
}
ImageResponseMsg::ImageFailed => {
let (chan, port) = channel();
chan.send(ImageResponseMsg::ImageFailed);
chan.send(ImageResponseMsg::ImageFailed).unwrap();
return port;
}
}
@ -149,7 +149,7 @@ impl<NodeAddress: Send> LocalImageCache<NodeAddress> {
self.get_state(url).last_response = response_copy;
let (chan, port) = channel();
chan.send(response);
chan.send(response).unwrap();
return port;
}

6
components/net/resource_task.rs
View file

@ -164,7 +164,7 @@ pub fn start_sending_opt(senders: ResponseSenders, metadata: Metadata) -> Result
pub fn load_whole_resource(resource_task: &ResourceTask, url: Url)
-> Result<(Metadata, Vec<u8>), String> {
let (start_chan, start_port) = channel();
resource_task.send(ControlMsg::Load(LoadData::new(url, start_chan)));
resource_task.send(ControlMsg::Load(LoadData::new(url, start_chan))).unwrap();
let response = start_port.recv().unwrap();
let mut buf = vec!();
@ -238,7 +238,7 @@ impl ResourceManager {
_ => {
debug!("resource_task: no loader for scheme {}", load_data.url.scheme);
start_sending(senders, Metadata::default(load_data.url))
.send(ProgressMsg::Done(Err("no loader for scheme".to_string())));
.send(ProgressMsg::Done(Err("no loader for scheme".to_string()))).unwrap();
return
}
}
@ -248,7 +248,7 @@ impl ResourceManager {
/// Load a URL asynchronously and iterate over chunks of bytes from the response.
pub fn load_bytes_iter(resource_task: &ResourceTask, url: Url) -> (Metadata, ProgressMsgPortIterator) {
let (input_chan, input_port) = channel();
resource_task.send(ControlMsg::Load(LoadData::new(url, input_chan)));
resource_task.send(ControlMsg::Load(LoadData::new(url, input_chan))).unwrap();
let response = input_port.recv().unwrap();
let iter = ProgressMsgPortIterator { progress_port: response.progress_port };

12
components/net/storage_task.rs
View file

@ -99,14 +99,14 @@ impl StorageManager {
fn length(&self, sender: Sender<u32>, url: Url) {
let origin = self.get_origin_as_string(url);
sender.send(self.data.get(&origin).map_or(0u, |entry| entry.len()) as u32);
sender.send(self.data.get(&origin).map_or(0u, |entry| entry.len()) as u32).unwrap();
}
fn key(&self, sender: Sender<Option<DOMString>>, url: Url, index: u32) {
let origin = self.get_origin_as_string(url);
sender.send(self.data.get(&origin)
.and_then(|entry| entry.keys().nth(index as uint))
.map(|key| key.clone()));
.map(|key| key.clone())).unwrap();
}
fn set_item(&mut self, sender: Sender<bool>, url: Url, name: DOMString, value: DOMString) {
@ -124,20 +124,20 @@ impl StorageManager {
}
}).unwrap();
sender.send(updated);
sender.send(updated).unwrap();
}
fn get_item(&self, sender: Sender<Option<DOMString>>, url: Url, name: DOMString) {
let origin = self.get_origin_as_string(url);
sender.send(self.data.get(&origin)
.and_then(|entry| entry.get(&name))
.map(|value| value.to_string()));
.map(|value| value.to_string())).unwrap();
}
fn remove_item(&mut self, sender: Sender<bool>, url: Url, name: DOMString) {
let origin = self.get_origin_as_string(url);
sender.send(self.data.get_mut(&origin)
.map_or(false, |entry| entry.remove(&name).is_some()));
.map_or(false, |entry| entry.remove(&name).is_some())).unwrap();
}
fn clear(&mut self, sender: Sender<bool>, url: Url) {
@ -149,7 +149,7 @@ impl StorageManager {
true
} else {
false
}}));
}})).unwrap();
}
fn get_origin_as_string(&self, url: Url) -> String {