Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-22 23:03:42 +01:00
Code Issues Projects Releases Packages Wiki Activity

net: Remove glob imports added in #4405

Browse source
This commit is contained in:
Tetsuharu OHZEKI 2014-12-18 20:36:20 +09:00
parent d7f38a8973
commit 07b1c0e652
8 changed files with 172 additions and 194 deletions
Download patch file Download diff file Expand all files Collapse all files

41
components/net/fetch/cors_cache.rs
View file

@ -9,9 +9,6 @@
//! This library will eventually become the core of the Fetch crate //! This library will eventually become the core of the Fetch crate
//! with CORSRequest being expanded into FetchRequest (etc) //! with CORSRequest being expanded into FetchRequest (etc)
use self::CORSCacheTaskMsg::*;
use self::HeaderOrMethod::*;
use hyper::method::Method; use hyper::method::Method;
use std::ascii::AsciiExt; use std::ascii::AsciiExt;
use std::comm::{Sender, Receiver, channel}; use std::comm::{Sender, Receiver, channel};
@ -31,14 +28,14 @@ pub enum HeaderOrMethod {
impl HeaderOrMethod { impl HeaderOrMethod {
fn match_header(&self, header_name: &str) -> bool { fn match_header(&self, header_name: &str) -> bool {
match *self { 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 _ => false
} }
} }
fn match_method(&self, method: &Method) -> bool { fn match_method(&self, method: &Method) -> bool {
match *self { match *self {
MethodData(ref m) => m == method, HeaderOrMethod::MethodData(ref m) => m == method,
_ => false _ => false
} }
} }
@ -160,7 +157,7 @@ impl CORSCache for BasicCORSCache {
Some(_) => true, Some(_) => true,
None => { None => {
self.insert(CORSCacheEntry::new(request.origin, request.destination, new_max_age, 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 false
} }
} }
@ -175,7 +172,7 @@ impl CORSCache for BasicCORSCache {
Some(_) => true, Some(_) => true,
None => { None => {
self.insert(CORSCacheEntry::new(request.origin, request.destination, new_max_age, self.insert(CORSCacheEntry::new(request.origin, request.destination, new_max_age,
request.credentials, MethodData(method))); request.credentials, HeaderOrMethod::MethodData(method)));
false false
} }
} }
@ -209,43 +206,43 @@ pub type CORSCacheSender = Sender<CORSCacheTaskMsg>;
impl CORSCache for CORSCacheSender { impl CORSCache for CORSCacheSender {
fn clear (&mut self, request: CacheRequestDetails) { fn clear (&mut self, request: CacheRequestDetails) {
let (tx, rx) = channel(); let (tx, rx) = channel();
self.send(Clear(request, tx)); self.send(CORSCacheTaskMsg::Clear(request, tx));
let _ = rx.recv_opt(); let _ = rx.recv_opt();
} }
fn cleanup(&mut self) { fn cleanup(&mut self) {
let (tx, rx) = channel(); let (tx, rx) = channel();
self.send(Cleanup(tx)); self.send(CORSCacheTaskMsg::Cleanup(tx));
let _ = rx.recv_opt(); let _ = rx.recv_opt();
} }
fn match_header(&mut self, request: CacheRequestDetails, header_name: &str) -> bool { fn match_header(&mut self, request: CacheRequestDetails, header_name: &str) -> bool {
let (tx, rx) = channel(); 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) rx.recv_opt().unwrap_or(false)
} }
fn match_header_and_update(&mut self, request: CacheRequestDetails, header_name: &str, new_max_age: uint) -> bool { fn match_header_and_update(&mut self, request: CacheRequestDetails, header_name: &str, new_max_age: uint) -> bool {
let (tx, rx) = channel(); 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) rx.recv_opt().unwrap_or(false)
} }
fn match_method(&mut self, request: CacheRequestDetails, method: Method) -> bool { fn match_method(&mut self, request: CacheRequestDetails, method: Method) -> bool {
let (tx, rx) = channel(); let (tx, rx) = channel();
self.send(MatchMethod(request, method, tx)); self.send(CORSCacheTaskMsg::MatchMethod(request, method, tx));
rx.recv_opt().unwrap_or(false) rx.recv_opt().unwrap_or(false)
} }
fn match_method_and_update(&mut self, request: CacheRequestDetails, method: Method, new_max_age: uint) -> bool { fn match_method_and_update(&mut self, request: CacheRequestDetails, method: Method, new_max_age: uint) -> bool {
let (tx, rx) = channel(); 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) rx.recv_opt().unwrap_or(false)
} }
fn insert(&mut self, entry: CORSCacheEntry) { fn insert(&mut self, entry: CORSCacheEntry) {
let (tx, rx) = channel(); let (tx, rx) = channel();
self.send(Insert(entry, tx)); self.send(CORSCacheTaskMsg::Insert(entry, tx));
let _ = rx.recv_opt(); let _ = rx.recv_opt();
} }
} }
@ -288,31 +285,31 @@ impl CORSCacheTask {
pub fn run(&mut self) { pub fn run(&mut self) {
loop { loop {
match self.receiver.recv() { match self.receiver.recv() {
Clear(request, tx) => { CORSCacheTaskMsg::Clear(request, tx) => {
self.cache.clear(request); self.cache.clear(request);
tx.send(()); tx.send(());
}, },
Cleanup(tx) => { CORSCacheTaskMsg::Cleanup(tx) => {
self.cache.cleanup(); self.cache.cleanup();
tx.send(()); tx.send(());
}, },
MatchHeader(request, header, tx) => { CORSCacheTaskMsg::MatchHeader(request, header, tx) => {
tx.send(self.cache.match_header(request, header.as_slice())); 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)); 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)); 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)); tx.send(self.cache.match_method_and_update(request, method, new_max_age));
}, },
Insert(entry, tx) => { CORSCacheTaskMsg::Insert(entry, tx) => {
self.cache.insert(entry); self.cache.insert(entry);
tx.send(()); tx.send(());
}, },
ExitMsg => break CORSCacheTaskMsg::ExitMsg => break
} }
} }
} }

16
components/net/fetch/request.rs
View file

@ -2,12 +2,6 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * 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/. */ * 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 url::Url;
use hyper::method::{Get, Method}; use hyper::method::{Get, Method};
use hyper::mime::{Mime, Text, Html, Charset, Utf8}; use hyper::mime::{Mime, Text, Html, Charset, Utf8};
@ -101,19 +95,19 @@ impl Request {
preserve_content_codings: false, preserve_content_codings: false,
skip_service_worker: false, skip_service_worker: false,
context: context, context: context,
context_frame_type: ContextNone, context_frame_type: ContextFrameType::ContextNone,
origin: None, origin: None,
force_origin_header: false, force_origin_header: false,
same_origin_data: false, same_origin_data: false,
referer: Client, referer: Referer::Client,
authentication: false, authentication: false,
sync: false, sync: false,
mode: NoCORS, mode: RequestMode::NoCORS,
credentials_mode: Omit, credentials_mode: CredentialsMode::Omit,
use_url_credentials: false, use_url_credentials: false,
manual_redirect: false, manual_redirect: false,
redirect_count: 0, redirect_count: 0,
response_tainting: Basic, response_tainting: ResponseTainting::Basic,
cache: None cache: None
} }
} }

27
components/net/fetch/response.rs
View file

@ -2,9 +2,6 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * 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/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use self::ResponseBody::*;
use self::ResponseType::*;
use url::Url; use url::Url;
use hyper::status::StatusCode; use hyper::status::StatusCode;
use hyper::status::Ok as StatusOk; use hyper::status::Ok as StatusOk;
@ -70,31 +67,31 @@ pub struct Response {
impl Response { impl Response {
pub fn new() -> Response { pub fn new() -> Response {
Response { Response {
response_type: Default, response_type: ResponseType::Default,
termination_reason: None, termination_reason: None,
url: None, url: None,
status: Some(StatusOk), status: Some(StatusOk),
headers: Headers::new(), headers: Headers::new(),
body: Empty, body: ResponseBody::Empty,
internal_response: None internal_response: None
} }
} }
pub fn network_error() -> Response { pub fn network_error() -> Response {
Response { Response {
response_type: Error, response_type: ResponseType::Error,
termination_reason: None, termination_reason: None,
url: None, url: None,
status: None, status: None,
headers: Headers::new(), headers: Headers::new(),
body: Empty, body: ResponseBody::Empty,
internal_response: None internal_response: None
} }
} }
pub fn is_network_error(&self) -> bool { pub fn is_network_error(&self) -> bool {
match self.response_type { match self.response_type {
Error => true, ResponseType::Error => true,
_ => false _ => false
} }
} }
@ -102,8 +99,8 @@ impl Response {
/// Convert to a filtered response, of type `filter_type`. /// Convert to a filtered response, of type `filter_type`.
/// Do not use with type Error or Default /// Do not use with type Error or Default
pub fn to_filtered(self, filter_type: ResponseType) -> Response { pub fn to_filtered(self, filter_type: ResponseType) -> Response {
assert!(filter_type != Error); assert!(filter_type != ResponseType::Error);
assert!(filter_type != Default); assert!(filter_type != ResponseType::Default);
if self.is_network_error() { if self.is_network_error() {
return self; return self;
} }
@ -111,8 +108,8 @@ impl Response {
let mut response = self.clone(); let mut response = self.clone();
response.internal_response = Some(box self); response.internal_response = Some(box self);
match filter_type { match filter_type {
Default | Error => unreachable!(), ResponseType::Default | ResponseType::Error => unreachable!(),
Basic => { ResponseType::Basic => {
let headers = old_headers.iter().filter(|header| { let headers = old_headers.iter().filter(|header| {
match header.name().to_ascii_lower().as_slice() { match header.name().to_ascii_lower().as_slice() {
"set-cookie" | "set-cookie2" => false, "set-cookie" | "set-cookie2" => false,
@ -122,7 +119,7 @@ impl Response {
response.headers = headers; response.headers = headers;
response.response_type = filter_type; response.response_type = filter_type;
}, },
CORS => { ResponseType::CORS => {
let headers = old_headers.iter().filter(|header| { let headers = old_headers.iter().filter(|header| {
match header.name().to_ascii_lower().as_slice() { match header.name().to_ascii_lower().as_slice() {
"cache-control" | "content-language" | "cache-control" | "content-language" |
@ -134,10 +131,10 @@ impl Response {
response.headers = headers; response.headers = headers;
response.response_type = filter_type; response.response_type = filter_type;
}, },
Opaque => { ResponseType::Opaque => {
response.headers = Headers::new(); response.headers = Headers::new();
response.status = None; response.status = None;
response.body = Empty; response.body = ResponseBody::Empty;
} }
} }
response response

8
components/net/image/holder.rs
View file

@ -3,7 +3,7 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use image::base::Image; use image::base::Image;
use image_cache_task::ImageResponseMsg::*; use image_cache_task::ImageResponseMsg;
use local_image_cache::LocalImageCache; use local_image_cache::LocalImageCache;
use geom::size::Size2D; use geom::size::Size2D;
@ -86,9 +86,9 @@ impl<NodeAddress: Send> ImageHolder<NodeAddress> {
local_image_cache.get_image(node_address, &self.url) local_image_cache.get_image(node_address, &self.url)
}; };
match port.recv() { match port.recv() {
ImageReady(image) => self.image = Some(image), ImageResponseMsg::ImageReady(image) => self.image = Some(image),
ImageNotReady => debug!("image not ready for {:s}", self.url.serialize()), ImageResponseMsg::ImageNotReady => debug!("image not ready for {:s}", self.url.serialize()),
ImageFailed => debug!("image decoding failed for {:s}", self.url.serialize()), ImageResponseMsg::ImageFailed => debug!("image decoding failed for {:s}", self.url.serialize()),
} }
} }

191
components/net/image_cache_task.rs
View file

@ -2,11 +2,6 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * 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/. */ * 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 image::base::{Image, load_from_memory};
use resource_task; use resource_task;
use resource_task::{LoadData, ResourceTask}; use resource_task::{LoadData, ResourceTask};
@ -64,11 +59,11 @@ pub enum ImageResponseMsg {
impl PartialEq for ImageResponseMsg { impl PartialEq for ImageResponseMsg {
fn eq(&self, other: &ImageResponseMsg) -> bool { fn eq(&self, other: &ImageResponseMsg) -> bool {
match (self, other) { match (self, other) {
(&ImageReady(..), &ImageReady(..)) => panic!("unimplemented comparison"), (&ImageResponseMsg::ImageReady(..), &ImageResponseMsg::ImageReady(..)) => panic!("unimplemented comparison"),
(&ImageNotReady, &ImageNotReady) => true, (&ImageResponseMsg::ImageNotReady, &ImageResponseMsg::ImageNotReady) => true,
(&ImageFailed, &ImageFailed) => 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(); let msg: Msg = port.recv();
match msg { match msg {
GetImage(url, response) => { Msg::GetImage(url, response) => {
inner_cache.send(WaitForImage(url, response)); inner_cache.send(Msg::WaitForImage(url, response));
} }
Exit(response) => { Msg::Exit(response) => {
inner_cache.send(Exit(response)); inner_cache.send(Msg::Exit(response));
break; break;
} }
msg => inner_cache.send(msg) msg => inner_cache.send(msg)
@ -177,8 +172,8 @@ impl ImageCache {
let msg = self.port.recv(); let msg = self.port.recv();
match msg { match msg {
Prefetch(url) => self.prefetch(url), Msg::Prefetch(url) => self.prefetch(url),
StorePrefetchedImageData(url, data) => { Msg::StorePrefetchedImageData(url, data) => {
store_prefetched_chan.map(|chan| { store_prefetched_chan.map(|chan| {
chan.send(()); chan.send(());
}); });
@ -186,8 +181,8 @@ impl ImageCache {
self.store_prefetched_image_data(url, data); self.store_prefetched_image_data(url, data);
} }
Decode(url) => self.decode(url), Msg::Decode(url) => self.decode(url),
StoreImage(url, image) => { Msg::StoreImage(url, image) => {
store_chan.map(|chan| { store_chan.map(|chan| {
chan.send(()); chan.send(());
}); });
@ -195,13 +190,13 @@ impl ImageCache {
self.store_image(url, image) self.store_image(url, image)
} }
GetImage(url, response) => self.get_image(url, response), Msg::GetImage(url, response) => self.get_image(url, response),
WaitForImage(url, response) => { Msg::WaitForImage(url, response) => {
self.wait_for_image(url, response) self.wait_for_image(url, response)
} }
WaitForStore(chan) => store_chan = Some(chan), Msg::WaitForStore(chan) => store_chan = Some(chan),
WaitForStorePrefetched(chan) => store_prefetched_chan = Some(chan), Msg::WaitForStorePrefetched(chan) => store_prefetched_chan = Some(chan),
Exit(response) => { Msg::Exit(response) => {
assert!(self.need_exit.is_none()); assert!(self.need_exit.is_none());
self.need_exit = Some(response); self.need_exit = Some(response);
} }
@ -216,10 +211,11 @@ impl ImageCache {
let mut can_exit = true; let mut can_exit = true;
for (_, state) in self.state_map.iter() { for (_, state) in self.state_map.iter() {
match *state { match *state {
Prefetching(..) => can_exit = false, ImageState::Prefetching(..) => can_exit = false,
Decoding => 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 { fn get_state(&self, url: &Url) -> ImageState {
match self.state_map.get(url) { match self.state_map.get(url) {
Some(state) => state.clone(), Some(state) => state.clone(),
None => Init None => ImageState::Init
} }
} }
@ -248,7 +244,7 @@ impl ImageCache {
fn prefetch(&mut self, url: Url) { fn prefetch(&mut self, url: Url) {
match self.get_state(&url) { match self.get_state(&url) {
Init => { ImageState::Init => {
let to_cache = self.chan.clone(); let to_cache = self.chan.clone();
let resource_task = self.resource_task.clone(); let resource_task = self.resource_task.clone();
let url_clone = url.clone(); let url_clone = url.clone();
@ -258,14 +254,15 @@ impl ImageCache {
debug!("image_cache_task: started fetch for {:s}", url.serialize()); debug!("image_cache_task: started fetch for {:s}", url.serialize());
let image = load_image_data(url.clone(), resource_task.clone()); 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()); 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 // 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<Vec<u8>, ()>) { fn store_prefetched_image_data(&mut self, url: Url, data: Result<Vec<u8>, ()>) {
match self.get_state(&url) { match self.get_state(&url) {
Prefetching(next_step) => { ImageState::Prefetching(next_step) => {
match data { match data {
Ok(data) => { Ok(data) => {
self.set_state(url.clone(), Prefetched(data)); self.set_state(url.clone(), ImageState::Prefetched(data));
match next_step { match next_step {
DoDecode => self.decode(url), AfterPrefetch::DoDecode => self.decode(url),
_ => () _ => ()
} }
} }
Err(..) => { Err(..) => {
self.set_state(url.clone(), Failed); self.set_state(url.clone(), ImageState::Failed);
self.purge_waiters(url, || ImageFailed); self.purge_waiters(url, || ImageResponseMsg::ImageFailed);
} }
} }
} }
Init ImageState::Init
| Prefetched(..) | ImageState::Prefetched(..)
| Decoding | ImageState::Decoding
| Decoded(..) | ImageState::Decoded(..)
| Failed => { | ImageState::Failed => {
panic!("wrong state for storing prefetched image") panic!("wrong state for storing prefetched image")
} }
} }
@ -301,18 +298,18 @@ impl ImageCache {
fn decode(&mut self, url: Url) { fn decode(&mut self, url: Url) {
match self.get_state(&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 // 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 // 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 to_cache = self.chan.clone();
let url_clone = url.clone(); let url_clone = url.clone();
@ -321,14 +318,14 @@ impl ImageCache {
debug!("image_cache_task: started image decode for {:s}", url.serialize()); debug!("image_cache_task: started image decode for {:s}", url.serialize());
let image = load_from_memory(data.as_slice()); let image = load_from_memory(data.as_slice());
let image = image.map(|image| Arc::new(box image)); 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()); 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 // We've already begun decoding
} }
} }
@ -337,24 +334,24 @@ impl ImageCache {
fn store_image(&mut self, url: Url, image: Option<Arc<Box<Image>>>) { fn store_image(&mut self, url: Url, image: Option<Arc<Box<Image>>>) {
match self.get_state(&url) { match self.get_state(&url) {
Decoding => { ImageState::Decoding => {
match image { match image {
Some(image) => { Some(image) => {
self.set_state(url.clone(), Decoded(image.clone())); self.set_state(url.clone(), ImageState::Decoded(image.clone()));
self.purge_waiters(url, || ImageReady(image.clone()) ); self.purge_waiters(url, || ImageResponseMsg::ImageReady(image.clone()) );
} }
None => { None => {
self.set_state(url.clone(), Failed); self.set_state(url.clone(), ImageState::Failed);
self.purge_waiters(url, || ImageFailed ); self.purge_waiters(url, || ImageResponseMsg::ImageFailed );
} }
} }
} }
Init ImageState::Init
| Prefetching(..) | ImageState::Prefetching(..)
| Prefetched(..) | ImageState::Prefetched(..)
| Decoded(..) | ImageState::Decoded(..)
| Failed => { | ImageState::Failed => {
panic!("incorrect state in store_image") panic!("incorrect state in store_image")
} }
} }
@ -375,22 +372,22 @@ impl ImageCache {
fn get_image(&self, url: Url, response: Sender<ImageResponseMsg>) { fn get_image(&self, url: Url, response: Sender<ImageResponseMsg>) {
match self.get_state(&url) { match self.get_state(&url) {
Init => panic!("request for image before prefetch"), ImageState::Init => panic!("request for image before prefetch"),
Prefetching(DoDecode) => response.send(ImageNotReady), ImageState::Prefetching(AfterPrefetch::DoDecode) => response.send(ImageResponseMsg::ImageNotReady),
Prefetching(DoNotDecode) | Prefetched(..) => panic!("request for image before decode"), ImageState::Prefetching(AfterPrefetch::DoNotDecode) | ImageState::Prefetched(..) => panic!("request for image before decode"),
Decoding => response.send(ImageNotReady), ImageState::Decoding => response.send(ImageResponseMsg::ImageNotReady),
Decoded(image) => response.send(ImageReady(image)), ImageState::Decoded(image) => response.send(ImageResponseMsg::ImageReady(image)),
Failed => response.send(ImageFailed), ImageState::Failed => response.send(ImageResponseMsg::ImageFailed),
} }
} }
fn wait_for_image(&mut self, url: Url, response: Sender<ImageResponseMsg>) { fn wait_for_image(&mut self, url: Url, response: Sender<ImageResponseMsg>) {
match self.get_state(&url) { 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 // We don't have this image yet
match self.wait_map.entry(url) { match self.wait_map.entry(url) {
Occupied(mut entry) => { Occupied(mut entry) => {
@ -402,12 +399,12 @@ impl ImageCache {
} }
} }
Decoded(image) => { ImageState::Decoded(image) => {
response.send(ImageReady(image)); response.send(ImageResponseMsg::ImageReady(image));
} }
Failed => { ImageState::Failed => {
response.send(ImageFailed); response.send(ImageResponseMsg::ImageFailed);
} }
} }
} }
@ -422,7 +419,7 @@ pub trait ImageCacheTaskClient {
impl ImageCacheTaskClient for ImageCacheTask { impl ImageCacheTaskClient for ImageCacheTask {
fn exit(&self) { fn exit(&self) {
let (response_chan, response_port) = channel(); let (response_chan, response_port) = channel();
self.send(Exit(response_chan)); self.send(Msg::Exit(response_chan));
response_port.recv(); response_port.recv();
} }
} }
@ -435,14 +432,14 @@ impl ImageCacheTask {
#[cfg(test)] #[cfg(test)]
fn wait_for_store(&self) -> Receiver<()> { fn wait_for_store(&self) -> Receiver<()> {
let (chan, port) = channel(); let (chan, port) = channel();
self.send(WaitForStore(chan)); self.send(Msg::WaitForStore(chan));
port port
} }
#[cfg(test)] #[cfg(test)]
fn wait_for_store_prefetched(&self) -> Receiver<()> { fn wait_for_store_prefetched(&self) -> Receiver<()> {
let (chan, port) = channel(); let (chan, port) = channel();
self.send(WaitForStorePrefetched(chan)); self.send(Msg::WaitForStorePrefetched(chan));
port port
} }
} }
@ -602,7 +599,7 @@ mod tests {
let url = Url::parse("file:///").unwrap(); let url = Url::parse("file:///").unwrap();
let (chan, port) = channel(); let (chan, port) = channel();
image_cache_task.send(GetImage(url, chan)); image_cache_task.send(Msg::GetImage(url, chan));
port.recv(); port.recv();
} }
@ -653,8 +650,8 @@ mod tests {
image_cache_task.send(Prefetch(url.clone())); image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone())); image_cache_task.send(Decode(url.clone()));
let (response_chan, response_port) = comm::channel(); let (response_chan, response_port) = comm::channel();
image_cache_task.send(GetImage(url, response_chan)); image_cache_task.send(Msg::GetImage(url, response_chan));
assert!(response_port.recv() == ImageNotReady); assert!(response_port.recv() == ImageResponseMsg::ImageNotReady);
wait_chan.send(()); wait_chan.send(());
image_cache_task.exit(); image_cache_task.exit();
mock_resource_task.send(resource_task::ControlMsg::Exit); mock_resource_task.send(resource_task::ControlMsg::Exit);
@ -676,9 +673,9 @@ mod tests {
join_port.recv(); join_port.recv();
let (response_chan, response_port) = comm::channel(); 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() { match response_port.recv() {
ImageReady(_) => (), ImageResponseMsg::ImageReady(_) => (),
_ => panic!("bleh") _ => panic!("bleh")
} }
@ -703,9 +700,9 @@ mod tests {
for _ in range(0u32, 2u32) { for _ in range(0u32, 2u32) {
let (response_chan, response_port) = comm::channel(); 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() { match response_port.recv() {
ImageReady(_) => (), ImageResponseMsg::ImageReady(_) => (),
_ => panic!("bleh") _ => panic!("bleh")
} }
} }
@ -836,9 +833,9 @@ mod tests {
join_port.recv(); join_port.recv();
let (response_chan, response_port) = comm::channel(); 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() { match response_port.recv() {
ImageFailed => (), ImageResponseMsg::ImageFailed => (),
_ => panic!("bleh") _ => panic!("bleh")
} }
@ -862,17 +859,17 @@ mod tests {
join_port.recv(); join_port.recv();
let (response_chan, response_port) = comm::channel(); 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() { match response_port.recv() {
ImageFailed => (), ImageResponseMsg::ImageFailed => (),
_ => panic!("bleh") _ => panic!("bleh")
} }
// And ask again, we should get the same response // And ask again, we should get the same response
let (response_chan, response_port) = comm::channel(); 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() { match response_port.recv() {
ImageFailed => (), ImageResponseMsg::ImageFailed => (),
_ => panic!("bleh") _ => panic!("bleh")
} }
@ -897,10 +894,10 @@ mod tests {
// Make the request // Make the request
let (response_chan, response_port) = comm::channel(); 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() { match response_port.recv() {
ImageFailed => (), ImageResponseMsg::ImageFailed => (),
_ => panic!("bleh") _ => panic!("bleh")
} }
@ -924,9 +921,9 @@ mod tests {
join_port.recv(); join_port.recv();
let (response_chan, response_port) = comm::channel(); 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() { match response_port.recv() {
ImageReady(..) => (), ImageResponseMsg::ImageReady(..) => (),
_ => panic!("bleh") _ => panic!("bleh")
} }
@ -947,12 +944,12 @@ mod tests {
image_cache_task.send(Decode(url.clone())); image_cache_task.send(Decode(url.clone()));
let (response_chan, response_port) = comm::channel(); 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(()); wait_chan.send(());
match response_port.recv() { match response_port.recv() {
ImageReady(..) => (), ImageResponseMsg::ImageReady(..) => (),
_ => panic!("bleh") _ => panic!("bleh")
} }
@ -973,12 +970,12 @@ mod tests {
image_cache_task.send(Decode(url.clone())); image_cache_task.send(Decode(url.clone()));
let (response_chan, response_port) = comm::channel(); 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(()); wait_chan.send(());
match response_port.recv() { match response_port.recv() {
ImageFailed => (), ImageResponseMsg::ImageFailed => (),
_ => panic!("bleh") _ => panic!("bleh")
} }
@ -997,9 +994,9 @@ mod tests {
image_cache_task.send(Decode(url.clone())); image_cache_task.send(Decode(url.clone()));
let (response_chan, response_port) = comm::channel(); 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() { match response_port.recv() {
ImageReady(_) => (), ImageResponseMsg::ImageReady(_) => (),
_ => panic!("bleh") _ => panic!("bleh")
} }

34
components/net/local_image_cache.rs
View file

@ -8,9 +8,7 @@ extra message traffic, it also avoids waiting on the same image
multiple times and thus triggering reflows multiple times. multiple times and thus triggering reflows multiple times.
*/ */
use image_cache_task::{ImageCacheTask, ImageResponseMsg}; use image_cache_task::{ImageCacheTask, ImageResponseMsg, Msg};
use image_cache_task::ImageResponseMsg::*;
use image_cache_task::Msg::*;
use std::comm::{Receiver, channel}; use std::comm::{Receiver, channel};
use std::collections::HashMap; use std::collections::HashMap;
@ -66,7 +64,7 @@ impl<NodeAddress: Send> LocalImageCache<NodeAddress> {
state.prefetched = true; 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) { pub fn decode(&mut self, url: &Url) {
@ -78,7 +76,7 @@ impl<NodeAddress: Send> LocalImageCache<NodeAddress> {
state.decoded = true; 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 // FIXME: Should return a Future
@ -93,35 +91,35 @@ impl<NodeAddress: Send> LocalImageCache<NodeAddress> {
state.last_request_round = round_number; state.last_request_round = round_number;
match state.last_response { match state.last_response {
ImageReady(ref image) => { ImageResponseMsg::ImageReady(ref image) => {
let (chan, port) = channel(); let (chan, port) = channel();
chan.send(ImageReady(image.clone())); chan.send(ImageResponseMsg::ImageReady(image.clone()));
return port; return port;
} }
ImageNotReady => { ImageResponseMsg::ImageNotReady => {
if last_round == round_number { if last_round == round_number {
let (chan, port) = channel(); let (chan, port) = channel();
chan.send(ImageNotReady); chan.send(ImageResponseMsg::ImageNotReady);
return port; return port;
} else { } else {
// We haven't requested the image from the // We haven't requested the image from the
// remote cache this round // remote cache this round
} }
} }
ImageFailed => { ImageResponseMsg::ImageFailed => {
let (chan, port) = channel(); let (chan, port) = channel();
chan.send(ImageFailed); chan.send(ImageResponseMsg::ImageFailed);
return port; return port;
} }
} }
} }
let (response_chan, response_port) = channel(); 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(); let response = response_port.recv();
match response { match response {
ImageNotReady => { ImageResponseMsg::ImageNotReady => {
// Need to reflow when the image is available // Need to reflow when the image is available
// FIXME: Instead we should be just passing a Future // FIXME: Instead we should be just passing a Future
// to the caller, then to the display list. Finally, // to the caller, then to the display list. Finally,
@ -134,7 +132,7 @@ impl<NodeAddress: Send> LocalImageCache<NodeAddress> {
let url = (*url).clone(); let url = (*url).clone();
spawn_named("LocalImageCache", proc() { spawn_named("LocalImageCache", proc() {
let (response_chan, response_port) = channel(); 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); on_image_available(response_port.recv(), node_address);
}); });
} }
@ -143,9 +141,9 @@ impl<NodeAddress: Send> LocalImageCache<NodeAddress> {
// Put a copy of the response in the cache // Put a copy of the response in the cache
let response_copy = match response { let response_copy = match response {
ImageReady(ref image) => ImageReady(image.clone()), ImageResponseMsg::ImageReady(ref image) => ImageResponseMsg::ImageReady(image.clone()),
ImageNotReady => ImageNotReady, ImageResponseMsg::ImageNotReady => ImageResponseMsg::ImageNotReady,
ImageFailed => ImageFailed ImageResponseMsg::ImageFailed => ImageResponseMsg::ImageFailed
}; };
self.get_state(url).last_response = response_copy; self.get_state(url).last_response = response_copy;
@ -162,7 +160,7 @@ impl<NodeAddress: Send> LocalImageCache<NodeAddress> {
prefetched: false, prefetched: false,
decoded: false, decoded: false,
last_request_round: 0, last_request_round: 0,
last_response: ImageNotReady, last_response: ImageResponseMsg::ImageNotReady,
}) })
} }
} }

33
components/net/resource_task.rs
View file

@ -4,9 +4,6 @@
//! A task that takes a URL and streams back the binary data. //! A task that takes a URL and streams back the binary data.
use self::ControlMsg::*;
use self::ProgressMsg::*;
use about_loader; use about_loader;
use data_loader; use data_loader;
use file_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) pub fn load_whole_resource(resource_task: &ResourceTask, url: Url)
-> Result<(Metadata, Vec<u8>), String> { -> Result<(Metadata, Vec<u8>), String> {
let (start_chan, start_port) = channel(); 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 response = start_port.recv();
let mut buf = vec!(); let mut buf = vec!();
loop { loop {
match response.progress_port.recv() { match response.progress_port.recv() {
Payload(data) => buf.push_all(data.as_slice()), ProgressMsg::Payload(data) => buf.push_all(data.as_slice()),
Done(Ok(())) => return Ok((response.metadata, buf)), ProgressMsg::Done(Ok(())) => return Ok((response.metadata, buf)),
Done(Err(e)) => return Err(e) ProgressMsg::Done(Err(e)) => return Err(e)
} }
} }
} }
@ -213,10 +210,10 @@ impl ResourceManager {
fn start(&self) { fn start(&self) {
loop { loop {
match self.from_client.recv() { match self.from_client.recv() {
Load(load_data) => { ControlMsg::Load(load_data) => {
self.load(load_data) self.load(load_data)
} }
Exit => { ControlMsg::Exit => {
break break
} }
} }
@ -239,7 +236,7 @@ impl ResourceManager {
_ => { _ => {
debug!("resource_task: no loader for scheme {:s}", load_data.url.scheme); debug!("resource_task: no loader for scheme {:s}", load_data.url.scheme);
start_sending(senders, Metadata::default(load_data.url)) 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 return
} }
}; };
@ -252,7 +249,7 @@ impl ResourceManager {
/// Load a URL asynchronously and iterate over chunks of bytes from the response. /// 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) { pub fn load_bytes_iter(resource_task: &ResourceTask, url: Url) -> (Metadata, ProgressMsgPortIterator) {
let (input_chan, input_port) = channel(); 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 response = input_port.recv();
let iter = ProgressMsgPortIterator { progress_port: response.progress_port }; let iter = ProgressMsgPortIterator { progress_port: response.progress_port };
@ -267,9 +264,9 @@ pub struct ProgressMsgPortIterator {
impl Iterator<Vec<u8>> for ProgressMsgPortIterator { impl Iterator<Vec<u8>> for ProgressMsgPortIterator {
fn next(&mut self) -> Option<Vec<u8>> { fn next(&mut self) -> Option<Vec<u8>> {
match self.progress_port.recv() { match self.progress_port.recv() {
Payload(data) => Some(data), ProgressMsg::Payload(data) => Some(data),
Done(Ok(())) => None, ProgressMsg::Done(Ok(())) => None,
Done(Err(e)) => { ProgressMsg::Done(Err(e)) => {
error!("error receiving bytes: {}", e); error!("error receiving bytes: {}", e);
None None
} }
@ -280,7 +277,7 @@ impl Iterator<Vec<u8>> for ProgressMsgPortIterator {
#[test] #[test]
fn test_exit() { fn test_exit() {
let resource_task = new_resource_task(None); let resource_task = new_resource_task(None);
resource_task.send(Exit); resource_task.send(ControlMsg::Exit);
} }
#[test] #[test]
@ -288,11 +285,11 @@ fn test_bad_scheme() {
let resource_task = new_resource_task(None); let resource_task = new_resource_task(None);
let (start_chan, start) = channel(); let (start_chan, start) = channel();
let url = Url::parse("bogus://whatever").unwrap(); 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(); let response = start.recv();
match response.progress_port.recv() { match response.progress_port.recv() {
Done(result) => { assert!(result.is_err()) } ProgressMsg::Done(result) => { assert!(result.is_err()) }
_ => panic!("bleh") _ => panic!("bleh")
} }
resource_task.send(Exit); resource_task.send(ControlMsg::Exit);
} }

16
components/net/storage_task.rs
View file

@ -2,8 +2,6 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * 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/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use self::StorageTaskMsg::*;
use std::comm::{channel, Receiver, Sender}; use std::comm::{channel, Receiver, Sender};
use std::collections::HashMap; use std::collections::HashMap;
use std::collections::TreeMap; use std::collections::TreeMap;
@ -73,25 +71,25 @@ impl StorageManager {
fn start(&mut self) { fn start(&mut self) {
loop { loop {
match self.port.recv() { match self.port.recv() {
Length(sender, url) => { StorageTaskMsg::Length(sender, url) => {
self.length(sender, url) self.length(sender, url)
} }
Key(sender, url, index) => { StorageTaskMsg::Key(sender, url, index) => {
self.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) self.set_item(sender, url, name, value)
} }
GetItem(sender, url, name) => { StorageTaskMsg::GetItem(sender, url, name) => {
self.get_item(sender, url, name) self.get_item(sender, url, name)
} }
RemoveItem(sender, url, name) => { StorageTaskMsg::RemoveItem(sender, url, name) => {
self.remove_item(sender, url, name) self.remove_item(sender, url, name)
} }
Clear(sender, url) => { StorageTaskMsg::Clear(sender, url) => {
self.clear(sender, url) self.clear(sender, url)
} }
Exit => { StorageTaskMsg::Exit => {
break break
} }
} }