diff --git a/components/net/fetch/cors_cache.rs b/components/net/fetch/cors_cache.rs index 70ae8af3faf..23a6a8450e5 100644 --- a/components/net/fetch/cors_cache.rs +++ b/components/net/fetch/cors_cache.rs @@ -9,9 +9,6 @@ //! This library will eventually become the core of the Fetch crate //! with CORSRequest being expanded into FetchRequest (etc) -use self::CORSCacheTaskMsg::*; -use self::HeaderOrMethod::*; - use hyper::method::Method; use std::ascii::AsciiExt; use std::comm::{Sender, Receiver, channel}; @@ -31,14 +28,14 @@ pub enum HeaderOrMethod { impl HeaderOrMethod { fn match_header(&self, header_name: &str) -> bool { match *self { - HeaderData(ref s) => s.as_slice().eq_ignore_ascii_case(header_name), + HeaderOrMethod::HeaderData(ref s) => s.as_slice().eq_ignore_ascii_case(header_name), _ => false } } fn match_method(&self, method: &Method) -> bool { match *self { - MethodData(ref m) => m == method, + HeaderOrMethod::MethodData(ref m) => m == method, _ => false } } @@ -160,7 +157,7 @@ impl CORSCache for BasicCORSCache { Some(_) => true, None => { self.insert(CORSCacheEntry::new(request.origin, request.destination, new_max_age, - request.credentials, HeaderData(header_name.to_string()))); + request.credentials, HeaderOrMethod::HeaderData(header_name.to_string()))); false } } @@ -175,7 +172,7 @@ impl CORSCache for BasicCORSCache { Some(_) => true, None => { self.insert(CORSCacheEntry::new(request.origin, request.destination, new_max_age, - request.credentials, MethodData(method))); + request.credentials, HeaderOrMethod::MethodData(method))); false } } @@ -209,43 +206,43 @@ pub type CORSCacheSender = Sender; impl CORSCache for CORSCacheSender { fn clear (&mut self, request: CacheRequestDetails) { let (tx, rx) = channel(); - self.send(Clear(request, tx)); + self.send(CORSCacheTaskMsg::Clear(request, tx)); let _ = rx.recv_opt(); } fn cleanup(&mut self) { let (tx, rx) = channel(); - self.send(Cleanup(tx)); + self.send(CORSCacheTaskMsg::Cleanup(tx)); let _ = rx.recv_opt(); } fn match_header(&mut self, request: CacheRequestDetails, header_name: &str) -> bool { let (tx, rx) = channel(); - self.send(MatchHeader(request, header_name.to_string(), tx)); + self.send(CORSCacheTaskMsg::MatchHeader(request, header_name.to_string(), tx)); rx.recv_opt().unwrap_or(false) } fn match_header_and_update(&mut self, request: CacheRequestDetails, header_name: &str, new_max_age: uint) -> bool { let (tx, rx) = channel(); - self.send(MatchHeaderUpdate(request, header_name.to_string(), new_max_age, tx)); + self.send(CORSCacheTaskMsg::MatchHeaderUpdate(request, header_name.to_string(), new_max_age, tx)); rx.recv_opt().unwrap_or(false) } fn match_method(&mut self, request: CacheRequestDetails, method: Method) -> bool { let (tx, rx) = channel(); - self.send(MatchMethod(request, method, tx)); + self.send(CORSCacheTaskMsg::MatchMethod(request, method, tx)); rx.recv_opt().unwrap_or(false) } fn match_method_and_update(&mut self, request: CacheRequestDetails, method: Method, new_max_age: uint) -> bool { let (tx, rx) = channel(); - self.send(MatchMethodUpdate(request, method, new_max_age, tx)); + self.send(CORSCacheTaskMsg::MatchMethodUpdate(request, method, new_max_age, tx)); rx.recv_opt().unwrap_or(false) } fn insert(&mut self, entry: CORSCacheEntry) { let (tx, rx) = channel(); - self.send(Insert(entry, tx)); + self.send(CORSCacheTaskMsg::Insert(entry, tx)); let _ = rx.recv_opt(); } } @@ -288,31 +285,31 @@ impl CORSCacheTask { pub fn run(&mut self) { loop { match self.receiver.recv() { - Clear(request, tx) => { + CORSCacheTaskMsg::Clear(request, tx) => { self.cache.clear(request); tx.send(()); }, - Cleanup(tx) => { + CORSCacheTaskMsg::Cleanup(tx) => { self.cache.cleanup(); tx.send(()); }, - MatchHeader(request, header, tx) => { + CORSCacheTaskMsg::MatchHeader(request, header, tx) => { tx.send(self.cache.match_header(request, header.as_slice())); }, - MatchHeaderUpdate(request, header, new_max_age, tx) => { + CORSCacheTaskMsg::MatchHeaderUpdate(request, header, new_max_age, tx) => { tx.send(self.cache.match_header_and_update(request, header.as_slice(), new_max_age)); }, - MatchMethod(request, method, tx) => { + CORSCacheTaskMsg::MatchMethod(request, method, tx) => { tx.send(self.cache.match_method(request, method)); }, - MatchMethodUpdate(request, method, new_max_age, tx) => { + CORSCacheTaskMsg::MatchMethodUpdate(request, method, new_max_age, tx) => { tx.send(self.cache.match_method_and_update(request, method, new_max_age)); }, - Insert(entry, tx) => { + CORSCacheTaskMsg::Insert(entry, tx) => { self.cache.insert(entry); tx.send(()); }, - ExitMsg => break + CORSCacheTaskMsg::ExitMsg => break } } } diff --git a/components/net/fetch/request.rs b/components/net/fetch/request.rs index 9265cc540ee..4e4139f1f7f 100644 --- a/components/net/fetch/request.rs +++ b/components/net/fetch/request.rs @@ -2,12 +2,6 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use self::ContextFrameType::*; -use self::CredentialsMode::*; -use self::Referer::*; -use self::RequestMode::*; -use self::ResponseTainting::*; - use url::Url; use hyper::method::{Get, Method}; use hyper::mime::{Mime, Text, Html, Charset, Utf8}; @@ -101,19 +95,19 @@ impl Request { preserve_content_codings: false, skip_service_worker: false, context: context, - context_frame_type: ContextNone, + context_frame_type: ContextFrameType::ContextNone, origin: None, force_origin_header: false, same_origin_data: false, - referer: Client, + referer: Referer::Client, authentication: false, sync: false, - mode: NoCORS, - credentials_mode: Omit, + mode: RequestMode::NoCORS, + credentials_mode: CredentialsMode::Omit, use_url_credentials: false, manual_redirect: false, redirect_count: 0, - response_tainting: Basic, + response_tainting: ResponseTainting::Basic, cache: None } } diff --git a/components/net/fetch/response.rs b/components/net/fetch/response.rs index ffa32b14356..e194aa9375d 100644 --- a/components/net/fetch/response.rs +++ b/components/net/fetch/response.rs @@ -2,9 +2,6 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use self::ResponseBody::*; -use self::ResponseType::*; - use url::Url; use hyper::status::StatusCode; use hyper::status::Ok as StatusOk; @@ -70,31 +67,31 @@ pub struct Response { impl Response { pub fn new() -> Response { Response { - response_type: Default, + response_type: ResponseType::Default, termination_reason: None, url: None, status: Some(StatusOk), headers: Headers::new(), - body: Empty, + body: ResponseBody::Empty, internal_response: None } } pub fn network_error() -> Response { Response { - response_type: Error, + response_type: ResponseType::Error, termination_reason: None, url: None, status: None, headers: Headers::new(), - body: Empty, + body: ResponseBody::Empty, internal_response: None } } pub fn is_network_error(&self) -> bool { match self.response_type { - Error => true, + ResponseType::Error => true, _ => false } } @@ -102,8 +99,8 @@ impl Response { /// Convert to a filtered response, of type `filter_type`. /// Do not use with type Error or Default pub fn to_filtered(self, filter_type: ResponseType) -> Response { - assert!(filter_type != Error); - assert!(filter_type != Default); + assert!(filter_type != ResponseType::Error); + assert!(filter_type != ResponseType::Default); if self.is_network_error() { return self; } @@ -111,8 +108,8 @@ impl Response { let mut response = self.clone(); response.internal_response = Some(box self); match filter_type { - Default | Error => unreachable!(), - Basic => { + ResponseType::Default | ResponseType::Error => unreachable!(), + ResponseType::Basic => { let headers = old_headers.iter().filter(|header| { match header.name().to_ascii_lower().as_slice() { "set-cookie" | "set-cookie2" => false, @@ -122,7 +119,7 @@ impl Response { response.headers = headers; response.response_type = filter_type; }, - CORS => { + ResponseType::CORS => { let headers = old_headers.iter().filter(|header| { match header.name().to_ascii_lower().as_slice() { "cache-control" | "content-language" | @@ -134,10 +131,10 @@ impl Response { response.headers = headers; response.response_type = filter_type; }, - Opaque => { + ResponseType::Opaque => { response.headers = Headers::new(); response.status = None; - response.body = Empty; + response.body = ResponseBody::Empty; } } response diff --git a/components/net/image/holder.rs b/components/net/image/holder.rs index 7010b0bd245..514b6c22135 100644 --- a/components/net/image/holder.rs +++ b/components/net/image/holder.rs @@ -3,7 +3,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ use image::base::Image; -use image_cache_task::ImageResponseMsg::*; +use image_cache_task::ImageResponseMsg; use local_image_cache::LocalImageCache; use geom::size::Size2D; @@ -86,9 +86,9 @@ impl ImageHolder { local_image_cache.get_image(node_address, &self.url) }; match port.recv() { - ImageReady(image) => self.image = Some(image), - ImageNotReady => debug!("image not ready for {:s}", self.url.serialize()), - ImageFailed => debug!("image decoding failed for {:s}", self.url.serialize()), + ImageResponseMsg::ImageReady(image) => self.image = Some(image), + ImageResponseMsg::ImageNotReady => debug!("image not ready for {:s}", self.url.serialize()), + ImageResponseMsg::ImageFailed => debug!("image decoding failed for {:s}", self.url.serialize()), } } diff --git a/components/net/image_cache_task.rs b/components/net/image_cache_task.rs index 73a6e5c6cb8..0f90bc6a156 100644 --- a/components/net/image_cache_task.rs +++ b/components/net/image_cache_task.rs @@ -2,11 +2,6 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use self::AfterPrefetch::*; -use self::ImageResponseMsg::*; -use self::ImageState::*; -use self::Msg::*; - use image::base::{Image, load_from_memory}; use resource_task; use resource_task::{LoadData, ResourceTask}; @@ -64,11 +59,11 @@ pub enum ImageResponseMsg { impl PartialEq for ImageResponseMsg { fn eq(&self, other: &ImageResponseMsg) -> bool { match (self, other) { - (&ImageReady(..), &ImageReady(..)) => panic!("unimplemented comparison"), - (&ImageNotReady, &ImageNotReady) => true, - (&ImageFailed, &ImageFailed) => true, + (&ImageResponseMsg::ImageReady(..), &ImageResponseMsg::ImageReady(..)) => panic!("unimplemented comparison"), + (&ImageResponseMsg::ImageNotReady, &ImageResponseMsg::ImageNotReady) => true, + (&ImageResponseMsg::ImageFailed, &ImageResponseMsg::ImageFailed) => true, - (&ImageReady(..), _) | (&ImageNotReady, _) | (&ImageFailed, _) => false + (&ImageResponseMsg::ImageReady(..), _) | (&ImageResponseMsg::ImageNotReady, _) | (&ImageResponseMsg::ImageFailed, _) => false } } } @@ -119,11 +114,11 @@ impl ImageCacheTask { let msg: Msg = port.recv(); match msg { - GetImage(url, response) => { - inner_cache.send(WaitForImage(url, response)); + Msg::GetImage(url, response) => { + inner_cache.send(Msg::WaitForImage(url, response)); } - Exit(response) => { - inner_cache.send(Exit(response)); + Msg::Exit(response) => { + inner_cache.send(Msg::Exit(response)); break; } msg => inner_cache.send(msg) @@ -177,8 +172,8 @@ impl ImageCache { let msg = self.port.recv(); match msg { - Prefetch(url) => self.prefetch(url), - StorePrefetchedImageData(url, data) => { + Msg::Prefetch(url) => self.prefetch(url), + Msg::StorePrefetchedImageData(url, data) => { store_prefetched_chan.map(|chan| { chan.send(()); }); @@ -186,8 +181,8 @@ impl ImageCache { self.store_prefetched_image_data(url, data); } - Decode(url) => self.decode(url), - StoreImage(url, image) => { + Msg::Decode(url) => self.decode(url), + Msg::StoreImage(url, image) => { store_chan.map(|chan| { chan.send(()); }); @@ -195,13 +190,13 @@ impl ImageCache { self.store_image(url, image) } - GetImage(url, response) => self.get_image(url, response), - WaitForImage(url, response) => { + Msg::GetImage(url, response) => self.get_image(url, response), + Msg::WaitForImage(url, response) => { self.wait_for_image(url, response) } - WaitForStore(chan) => store_chan = Some(chan), - WaitForStorePrefetched(chan) => store_prefetched_chan = Some(chan), - Exit(response) => { + Msg::WaitForStore(chan) => store_chan = Some(chan), + Msg::WaitForStorePrefetched(chan) => store_prefetched_chan = Some(chan), + Msg::Exit(response) => { assert!(self.need_exit.is_none()); self.need_exit = Some(response); } @@ -216,10 +211,11 @@ impl ImageCache { let mut can_exit = true; for (_, state) in self.state_map.iter() { match *state { - Prefetching(..) => can_exit = false, - Decoding => can_exit = false, + ImageState::Prefetching(..) => can_exit = false, + ImageState::Decoding => can_exit = false, - Init | Prefetched(..) | Decoded(..) | Failed => () + ImageState::Init | ImageState::Prefetched(..) | + ImageState::Decoded(..) | ImageState::Failed => () } } @@ -238,7 +234,7 @@ impl ImageCache { fn get_state(&self, url: &Url) -> ImageState { match self.state_map.get(url) { Some(state) => state.clone(), - None => Init + None => ImageState::Init } } @@ -248,7 +244,7 @@ impl ImageCache { fn prefetch(&mut self, url: Url) { match self.get_state(&url) { - Init => { + ImageState::Init => { let to_cache = self.chan.clone(); let resource_task = self.resource_task.clone(); let url_clone = url.clone(); @@ -258,14 +254,15 @@ impl ImageCache { debug!("image_cache_task: started fetch for {:s}", url.serialize()); let image = load_image_data(url.clone(), resource_task.clone()); - to_cache.send(StorePrefetchedImageData(url.clone(), image)); + to_cache.send(Msg::StorePrefetchedImageData(url.clone(), image)); debug!("image_cache_task: ended fetch for {:s}", url.serialize()); }); - self.set_state(url, Prefetching(DoNotDecode)); + self.set_state(url, ImageState::Prefetching(AfterPrefetch::DoNotDecode)); } - Prefetching(..) | Prefetched(..) | Decoding | Decoded(..) | Failed => { + ImageState::Prefetching(..) | ImageState::Prefetched(..) | + ImageState::Decoding | ImageState::Decoded(..) | ImageState::Failed => { // We've already begun working on this image } } @@ -273,27 +270,27 @@ impl ImageCache { fn store_prefetched_image_data(&mut self, url: Url, data: Result, ()>) { match self.get_state(&url) { - Prefetching(next_step) => { + ImageState::Prefetching(next_step) => { match data { Ok(data) => { - self.set_state(url.clone(), Prefetched(data)); + self.set_state(url.clone(), ImageState::Prefetched(data)); match next_step { - DoDecode => self.decode(url), + AfterPrefetch::DoDecode => self.decode(url), _ => () } } Err(..) => { - self.set_state(url.clone(), Failed); - self.purge_waiters(url, || ImageFailed); + self.set_state(url.clone(), ImageState::Failed); + self.purge_waiters(url, || ImageResponseMsg::ImageFailed); } } } - Init - | Prefetched(..) - | Decoding - | Decoded(..) - | Failed => { + ImageState::Init + | ImageState::Prefetched(..) + | ImageState::Decoding + | ImageState::Decoded(..) + | ImageState::Failed => { panic!("wrong state for storing prefetched image") } } @@ -301,18 +298,18 @@ impl ImageCache { fn decode(&mut self, url: Url) { match self.get_state(&url) { - Init => panic!("decoding image before prefetch"), + ImageState::Init => panic!("decoding image before prefetch"), - Prefetching(DoNotDecode) => { + ImageState::Prefetching(AfterPrefetch::DoNotDecode) => { // We don't have the data yet, queue up the decode - self.set_state(url, Prefetching(DoDecode)) + self.set_state(url, ImageState::Prefetching(AfterPrefetch::DoDecode)) } - Prefetching(DoDecode) => { + ImageState::Prefetching(AfterPrefetch::DoDecode) => { // We don't have the data yet, but the decode request is queued up } - Prefetched(data) => { + ImageState::Prefetched(data) => { let to_cache = self.chan.clone(); let url_clone = url.clone(); @@ -321,14 +318,14 @@ impl ImageCache { debug!("image_cache_task: started image decode for {:s}", url.serialize()); let image = load_from_memory(data.as_slice()); let image = image.map(|image| Arc::new(box image)); - to_cache.send(StoreImage(url.clone(), image)); + to_cache.send(Msg::StoreImage(url.clone(), image)); debug!("image_cache_task: ended image decode for {:s}", url.serialize()); }); - self.set_state(url, Decoding); + self.set_state(url, ImageState::Decoding); } - Decoding | Decoded(..) | Failed => { + ImageState::Decoding | ImageState::Decoded(..) | ImageState::Failed => { // We've already begun decoding } } @@ -337,24 +334,24 @@ impl ImageCache { fn store_image(&mut self, url: Url, image: Option>>) { match self.get_state(&url) { - Decoding => { + ImageState::Decoding => { match image { Some(image) => { - self.set_state(url.clone(), Decoded(image.clone())); - self.purge_waiters(url, || ImageReady(image.clone()) ); + self.set_state(url.clone(), ImageState::Decoded(image.clone())); + self.purge_waiters(url, || ImageResponseMsg::ImageReady(image.clone()) ); } None => { - self.set_state(url.clone(), Failed); - self.purge_waiters(url, || ImageFailed ); + self.set_state(url.clone(), ImageState::Failed); + self.purge_waiters(url, || ImageResponseMsg::ImageFailed ); } } } - Init - | Prefetching(..) - | Prefetched(..) - | Decoded(..) - | Failed => { + ImageState::Init + | ImageState::Prefetching(..) + | ImageState::Prefetched(..) + | ImageState::Decoded(..) + | ImageState::Failed => { panic!("incorrect state in store_image") } } @@ -375,22 +372,22 @@ impl ImageCache { fn get_image(&self, url: Url, response: Sender) { match self.get_state(&url) { - Init => panic!("request for image before prefetch"), - Prefetching(DoDecode) => response.send(ImageNotReady), - Prefetching(DoNotDecode) | Prefetched(..) => panic!("request for image before decode"), - Decoding => response.send(ImageNotReady), - Decoded(image) => response.send(ImageReady(image)), - Failed => response.send(ImageFailed), + ImageState::Init => panic!("request for image before prefetch"), + ImageState::Prefetching(AfterPrefetch::DoDecode) => response.send(ImageResponseMsg::ImageNotReady), + ImageState::Prefetching(AfterPrefetch::DoNotDecode) | ImageState::Prefetched(..) => panic!("request for image before decode"), + ImageState::Decoding => response.send(ImageResponseMsg::ImageNotReady), + ImageState::Decoded(image) => response.send(ImageResponseMsg::ImageReady(image)), + ImageState::Failed => response.send(ImageResponseMsg::ImageFailed), } } fn wait_for_image(&mut self, url: Url, response: Sender) { match self.get_state(&url) { - Init => panic!("request for image before prefetch"), + ImageState::Init => panic!("request for image before prefetch"), - Prefetching(DoNotDecode) | Prefetched(..) => panic!("request for image before decode"), + ImageState::Prefetching(AfterPrefetch::DoNotDecode) | ImageState::Prefetched(..) => panic!("request for image before decode"), - Prefetching(DoDecode) | Decoding => { + ImageState::Prefetching(AfterPrefetch::DoDecode) | ImageState::Decoding => { // We don't have this image yet match self.wait_map.entry(url) { Occupied(mut entry) => { @@ -402,12 +399,12 @@ impl ImageCache { } } - Decoded(image) => { - response.send(ImageReady(image)); + ImageState::Decoded(image) => { + response.send(ImageResponseMsg::ImageReady(image)); } - Failed => { - response.send(ImageFailed); + ImageState::Failed => { + response.send(ImageResponseMsg::ImageFailed); } } } @@ -422,7 +419,7 @@ pub trait ImageCacheTaskClient { impl ImageCacheTaskClient for ImageCacheTask { fn exit(&self) { let (response_chan, response_port) = channel(); - self.send(Exit(response_chan)); + self.send(Msg::Exit(response_chan)); response_port.recv(); } } @@ -435,14 +432,14 @@ impl ImageCacheTask { #[cfg(test)] fn wait_for_store(&self) -> Receiver<()> { let (chan, port) = channel(); - self.send(WaitForStore(chan)); + self.send(Msg::WaitForStore(chan)); port } #[cfg(test)] fn wait_for_store_prefetched(&self) -> Receiver<()> { let (chan, port) = channel(); - self.send(WaitForStorePrefetched(chan)); + self.send(Msg::WaitForStorePrefetched(chan)); port } } @@ -602,7 +599,7 @@ mod tests { let url = Url::parse("file:///").unwrap(); let (chan, port) = channel(); - image_cache_task.send(GetImage(url, chan)); + image_cache_task.send(Msg::GetImage(url, chan)); port.recv(); } @@ -653,8 +650,8 @@ mod tests { image_cache_task.send(Prefetch(url.clone())); image_cache_task.send(Decode(url.clone())); let (response_chan, response_port) = comm::channel(); - image_cache_task.send(GetImage(url, response_chan)); - assert!(response_port.recv() == ImageNotReady); + image_cache_task.send(Msg::GetImage(url, response_chan)); + assert!(response_port.recv() == ImageResponseMsg::ImageNotReady); wait_chan.send(()); image_cache_task.exit(); mock_resource_task.send(resource_task::ControlMsg::Exit); @@ -676,9 +673,9 @@ mod tests { join_port.recv(); let (response_chan, response_port) = comm::channel(); - image_cache_task.send(GetImage(url, response_chan)); + image_cache_task.send(Msg::GetImage(url, response_chan)); match response_port.recv() { - ImageReady(_) => (), + ImageResponseMsg::ImageReady(_) => (), _ => panic!("bleh") } @@ -703,9 +700,9 @@ mod tests { for _ in range(0u32, 2u32) { let (response_chan, response_port) = comm::channel(); - image_cache_task.send(GetImage(url.clone(), response_chan)); + image_cache_task.send(Msg::GetImage(url.clone(), response_chan)); match response_port.recv() { - ImageReady(_) => (), + ImageResponseMsg::ImageReady(_) => (), _ => panic!("bleh") } } @@ -836,9 +833,9 @@ mod tests { join_port.recv(); let (response_chan, response_port) = comm::channel(); - image_cache_task.send(GetImage(url, response_chan)); + image_cache_task.send(Msg::GetImage(url, response_chan)); match response_port.recv() { - ImageFailed => (), + ImageResponseMsg::ImageFailed => (), _ => panic!("bleh") } @@ -862,17 +859,17 @@ mod tests { join_port.recv(); let (response_chan, response_port) = comm::channel(); - image_cache_task.send(GetImage(url.clone(), response_chan)); + image_cache_task.send(Msg::GetImage(url.clone(), response_chan)); match response_port.recv() { - ImageFailed => (), + ImageResponseMsg::ImageFailed => (), _ => panic!("bleh") } // And ask again, we should get the same response let (response_chan, response_port) = comm::channel(); - image_cache_task.send(GetImage(url, response_chan)); + image_cache_task.send(Msg::GetImage(url, response_chan)); match response_port.recv() { - ImageFailed => (), + ImageResponseMsg::ImageFailed => (), _ => panic!("bleh") } @@ -897,10 +894,10 @@ mod tests { // Make the request let (response_chan, response_port) = comm::channel(); - image_cache_task.send(GetImage(url, response_chan)); + image_cache_task.send(Msg::GetImage(url, response_chan)); match response_port.recv() { - ImageFailed => (), + ImageResponseMsg::ImageFailed => (), _ => panic!("bleh") } @@ -924,9 +921,9 @@ mod tests { join_port.recv(); let (response_chan, response_port) = comm::channel(); - image_cache_task.send(WaitForImage(url, response_chan)); + image_cache_task.send(Msg::WaitForImage(url, response_chan)); match response_port.recv() { - ImageReady(..) => (), + ImageResponseMsg::ImageReady(..) => (), _ => panic!("bleh") } @@ -947,12 +944,12 @@ mod tests { image_cache_task.send(Decode(url.clone())); let (response_chan, response_port) = comm::channel(); - image_cache_task.send(WaitForImage(url, response_chan)); + image_cache_task.send(Msg::WaitForImage(url, response_chan)); wait_chan.send(()); match response_port.recv() { - ImageReady(..) => (), + ImageResponseMsg::ImageReady(..) => (), _ => panic!("bleh") } @@ -973,12 +970,12 @@ mod tests { image_cache_task.send(Decode(url.clone())); let (response_chan, response_port) = comm::channel(); - image_cache_task.send(WaitForImage(url, response_chan)); + image_cache_task.send(Msg::WaitForImage(url, response_chan)); wait_chan.send(()); match response_port.recv() { - ImageFailed => (), + ImageResponseMsg::ImageFailed => (), _ => panic!("bleh") } @@ -997,9 +994,9 @@ mod tests { image_cache_task.send(Decode(url.clone())); let (response_chan, response_port) = comm::channel(); - image_cache_task.send(GetImage(url, response_chan)); + image_cache_task.send(Msg::GetImage(url, response_chan)); match response_port.recv() { - ImageReady(_) => (), + ImageResponseMsg::ImageReady(_) => (), _ => panic!("bleh") } diff --git a/components/net/local_image_cache.rs b/components/net/local_image_cache.rs index f1c303d4062..aca13a6d405 100644 --- a/components/net/local_image_cache.rs +++ b/components/net/local_image_cache.rs @@ -8,9 +8,7 @@ extra message traffic, it also avoids waiting on the same image multiple times and thus triggering reflows multiple times. */ -use image_cache_task::{ImageCacheTask, ImageResponseMsg}; -use image_cache_task::ImageResponseMsg::*; -use image_cache_task::Msg::*; +use image_cache_task::{ImageCacheTask, ImageResponseMsg, Msg}; use std::comm::{Receiver, channel}; use std::collections::HashMap; @@ -66,7 +64,7 @@ impl LocalImageCache { state.prefetched = true; } - self.image_cache_task.send(Prefetch((*url).clone())); + self.image_cache_task.send(Msg::Prefetch((*url).clone())); } pub fn decode(&mut self, url: &Url) { @@ -78,7 +76,7 @@ impl LocalImageCache { state.decoded = true; } - self.image_cache_task.send(Decode((*url).clone())); + self.image_cache_task.send(Msg::Decode((*url).clone())); } // FIXME: Should return a Future @@ -93,35 +91,35 @@ impl LocalImageCache { state.last_request_round = round_number; match state.last_response { - ImageReady(ref image) => { + ImageResponseMsg::ImageReady(ref image) => { let (chan, port) = channel(); - chan.send(ImageReady(image.clone())); + chan.send(ImageResponseMsg::ImageReady(image.clone())); return port; } - ImageNotReady => { + ImageResponseMsg::ImageNotReady => { if last_round == round_number { let (chan, port) = channel(); - chan.send(ImageNotReady); + chan.send(ImageResponseMsg::ImageNotReady); return port; } else { // We haven't requested the image from the // remote cache this round } } - ImageFailed => { + ImageResponseMsg::ImageFailed => { let (chan, port) = channel(); - chan.send(ImageFailed); + chan.send(ImageResponseMsg::ImageFailed); return port; } } } let (response_chan, response_port) = channel(); - self.image_cache_task.send(GetImage((*url).clone(), response_chan)); + self.image_cache_task.send(Msg::GetImage((*url).clone(), response_chan)); let response = response_port.recv(); match response { - ImageNotReady => { + ImageResponseMsg::ImageNotReady => { // Need to reflow when the image is available // FIXME: Instead we should be just passing a Future // to the caller, then to the display list. Finally, @@ -134,7 +132,7 @@ impl LocalImageCache { let url = (*url).clone(); spawn_named("LocalImageCache", proc() { let (response_chan, response_port) = channel(); - image_cache_task.send(WaitForImage(url, response_chan)); + image_cache_task.send(Msg::WaitForImage(url, response_chan)); on_image_available(response_port.recv(), node_address); }); } @@ -143,9 +141,9 @@ impl LocalImageCache { // Put a copy of the response in the cache let response_copy = match response { - ImageReady(ref image) => ImageReady(image.clone()), - ImageNotReady => ImageNotReady, - ImageFailed => ImageFailed + ImageResponseMsg::ImageReady(ref image) => ImageResponseMsg::ImageReady(image.clone()), + ImageResponseMsg::ImageNotReady => ImageResponseMsg::ImageNotReady, + ImageResponseMsg::ImageFailed => ImageResponseMsg::ImageFailed }; self.get_state(url).last_response = response_copy; @@ -162,7 +160,7 @@ impl LocalImageCache { prefetched: false, decoded: false, last_request_round: 0, - last_response: ImageNotReady, + last_response: ImageResponseMsg::ImageNotReady, }) } } diff --git a/components/net/resource_task.rs b/components/net/resource_task.rs index 6a0aeb7306f..20d40205dd2 100644 --- a/components/net/resource_task.rs +++ b/components/net/resource_task.rs @@ -4,9 +4,6 @@ //! A task that takes a URL and streams back the binary data. -use self::ControlMsg::*; -use self::ProgressMsg::*; - use about_loader; use data_loader; use file_loader; @@ -166,15 +163,15 @@ pub fn start_sending_opt(senders: ResponseSenders, metadata: Metadata) -> Result pub fn load_whole_resource(resource_task: &ResourceTask, url: Url) -> Result<(Metadata, Vec), String> { let (start_chan, start_port) = channel(); - resource_task.send(Load(LoadData::new(url, start_chan))); + resource_task.send(ControlMsg::Load(LoadData::new(url, start_chan))); let response = start_port.recv(); let mut buf = vec!(); loop { match response.progress_port.recv() { - Payload(data) => buf.push_all(data.as_slice()), - Done(Ok(())) => return Ok((response.metadata, buf)), - Done(Err(e)) => return Err(e) + ProgressMsg::Payload(data) => buf.push_all(data.as_slice()), + ProgressMsg::Done(Ok(())) => return Ok((response.metadata, buf)), + ProgressMsg::Done(Err(e)) => return Err(e) } } } @@ -213,10 +210,10 @@ impl ResourceManager { fn start(&self) { loop { match self.from_client.recv() { - Load(load_data) => { + ControlMsg::Load(load_data) => { self.load(load_data) } - Exit => { + ControlMsg::Exit => { break } } @@ -239,7 +236,7 @@ impl ResourceManager { _ => { debug!("resource_task: no loader for scheme {:s}", load_data.url.scheme); start_sending(senders, Metadata::default(load_data.url)) - .send(Done(Err("no loader for scheme".to_string()))); + .send(ProgressMsg::Done(Err("no loader for scheme".to_string()))); return } }; @@ -252,7 +249,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(Load(LoadData::new(url, input_chan))); + resource_task.send(ControlMsg::Load(LoadData::new(url, input_chan))); let response = input_port.recv(); let iter = ProgressMsgPortIterator { progress_port: response.progress_port }; @@ -267,9 +264,9 @@ pub struct ProgressMsgPortIterator { impl Iterator> for ProgressMsgPortIterator { fn next(&mut self) -> Option> { match self.progress_port.recv() { - Payload(data) => Some(data), - Done(Ok(())) => None, - Done(Err(e)) => { + ProgressMsg::Payload(data) => Some(data), + ProgressMsg::Done(Ok(())) => None, + ProgressMsg::Done(Err(e)) => { error!("error receiving bytes: {}", e); None } @@ -280,7 +277,7 @@ impl Iterator> for ProgressMsgPortIterator { #[test] fn test_exit() { let resource_task = new_resource_task(None); - resource_task.send(Exit); + resource_task.send(ControlMsg::Exit); } #[test] @@ -288,11 +285,11 @@ fn test_bad_scheme() { let resource_task = new_resource_task(None); let (start_chan, start) = channel(); let url = Url::parse("bogus://whatever").unwrap(); - resource_task.send(Load(LoadData::new(url, start_chan))); + resource_task.send(ControlMsg::Load(LoadData::new(url, start_chan))); let response = start.recv(); match response.progress_port.recv() { - Done(result) => { assert!(result.is_err()) } + ProgressMsg::Done(result) => { assert!(result.is_err()) } _ => panic!("bleh") } - resource_task.send(Exit); + resource_task.send(ControlMsg::Exit); } diff --git a/components/net/storage_task.rs b/components/net/storage_task.rs index 85f087bc19a..d83a5c6f43c 100644 --- a/components/net/storage_task.rs +++ b/components/net/storage_task.rs @@ -2,8 +2,6 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -use self::StorageTaskMsg::*; - use std::comm::{channel, Receiver, Sender}; use std::collections::HashMap; use std::collections::TreeMap; @@ -73,25 +71,25 @@ impl StorageManager { fn start(&mut self) { loop { match self.port.recv() { - Length(sender, url) => { + StorageTaskMsg::Length(sender, url) => { self.length(sender, url) } - Key(sender, url, index) => { + StorageTaskMsg::Key(sender, url, index) => { self.key(sender, url, index) } - SetItem(sender, url, name, value) => { + StorageTaskMsg::SetItem(sender, url, name, value) => { self.set_item(sender, url, name, value) } - GetItem(sender, url, name) => { + StorageTaskMsg::GetItem(sender, url, name) => { self.get_item(sender, url, name) } - RemoveItem(sender, url, name) => { + StorageTaskMsg::RemoveItem(sender, url, name) => { self.remove_item(sender, url, name) } - Clear(sender, url) => { + StorageTaskMsg::Clear(sender, url) => { self.clear(sender, url) } - Exit => { + StorageTaskMsg::Exit => { break } }