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

Update rustc to 00b112c45a604fa6f4b59af2a40c9deeadfdb7c6/rustc-1.0.0-dev.

Browse source
This commit is contained in:
Josh Matthews 2015-01-15 13:26:44 -05:00 • committed by Glenn Watson
parent ff8cbff810
commit 95fc29fa0d
255 changed files with 3550 additions and 3362 deletions
Download patch file Download diff file Expand all files Collapse all files

8
components/net/Cargo.toml
View file

@ -23,8 +23,6 @@ git = "https://github.com/servo/rust-png"
[dependencies.stb_image]
git = "https://github.com/servo/rust-stb-image"
[dependencies.url]
git = "https://github.com/servo/rust-url"
[dependencies.time]
git = "https://github.com/rust-lang/time"
[dependencies]
url = "*"
time = "*"

1
components/net/about_loader.rs
View file

@ -12,6 +12,7 @@ use servo_util::resource_files::resources_dir_path;
use std::borrow::ToOwned;
use std::io::fs::PathExtensions;
use std::sync::mpsc::Sender;
pub fn factory(mut load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
let senders = ResponseSenders {

13
components/net/data_loader.rs
View file

@ -10,6 +10,7 @@ use serialize::base64::FromBase64;
use hyper::mime::Mime;
use url::{percent_decode, SchemeData};
use std::sync::mpsc::Sender;
pub fn factory(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
// NB: we don't spawn a new task.
@ -59,7 +60,7 @@ fn load(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
// Parse the content type using rust-http.
// FIXME: this can go into an infinite loop! (rust-http #25)
let content_type: Option<Mime> = from_str(ct_str);
let content_type: Option<Mime> = ct_str.parse();
metadata.set_content_type(content_type.as_ref());
let progress_chan = start_sending(senders, metadata);
@ -89,19 +90,19 @@ fn assert_parse(url: &'static str,
content_type: Option<(String, String)>,
charset: Option<String>,
data: Option<Vec<u8>>) {
use std::comm;
use std::sync::mpsc::channel;
use url::Url;
use sniffer_task;
let (start_chan, start_port) = comm::channel();
let (start_chan, start_port) = channel();
let sniffer_task = sniffer_task::new_sniffer_task();
load(LoadData::new(Url::parse(url).unwrap(), start_chan), sniffer_task);
let response = start_port.recv();
let response = start_port.recv().unwrap();
assert_eq!(&response.metadata.content_type, &content_type);
assert_eq!(&response.metadata.charset, &charset);
let progress = response.progress_port.recv();
let progress = response.progress_port.recv().unwrap();
match data {
None => {
@ -109,7 +110,7 @@ fn assert_parse(url: &'static str,
}
Some(dat) => {
assert_eq!(progress, Payload(dat));
assert_eq!(response.progress_port.recv(), Done(Ok(())));
assert_eq!(response.progress_port.recv().unwrap(), Done(Ok(())));
}
}
}

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

@ -11,7 +11,7 @@
use hyper::method::Method;
use std::ascii::AsciiExt;
use std::comm::{Sender, Receiver, channel};
use std::sync::mpsc::{Sender, Receiver, channel};
use time;
use time::{now, Timespec};
use url::Url;
@ -19,7 +19,7 @@ use url::Url;
/// Union type for CORS cache entries
///
/// Each entry might pertain to a header or method
#[deriving(Clone)]
#[derive(Clone)]
pub enum HeaderOrMethod {
HeaderData(String),
MethodData(Method)
@ -42,7 +42,7 @@ impl HeaderOrMethod {
}
/// An entry in the CORS cache
#[deriving(Clone)]
#[derive(Clone)]
pub struct CORSCacheEntry {
pub origin: Url,
pub url: Url,
@ -100,7 +100,7 @@ pub trait CORSCache {
}
/// A simple, vector-based CORS Cache
#[deriving(Clone)]
#[derive(Clone)]
#[unstable = "This might later be replaced with a HashMap-like entity, though that requires a separate Origin struct"]
pub struct BasicCORSCache(Vec<CORSCacheEntry>);
@ -207,43 +207,43 @@ impl CORSCache for CORSCacheSender {
fn clear (&mut self, request: CacheRequestDetails) {
let (tx, rx) = channel();
self.send(CORSCacheTaskMsg::Clear(request, tx));
let _ = rx.recv_opt();
let _ = rx.recv();
}
fn cleanup(&mut self) {
let (tx, rx) = channel();
self.send(CORSCacheTaskMsg::Cleanup(tx));
let _ = rx.recv_opt();
let _ = rx.recv();
}
fn match_header(&mut self, request: CacheRequestDetails, header_name: &str) -> bool {
let (tx, rx) = channel();
self.send(CORSCacheTaskMsg::MatchHeader(request, header_name.to_string(), tx));
rx.recv_opt().unwrap_or(false)
rx.recv().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(CORSCacheTaskMsg::MatchHeaderUpdate(request, header_name.to_string(), new_max_age, tx));
rx.recv_opt().unwrap_or(false)
rx.recv().unwrap_or(false)
}
fn match_method(&mut self, request: CacheRequestDetails, method: Method) -> bool {
let (tx, rx) = channel();
self.send(CORSCacheTaskMsg::MatchMethod(request, method, tx));
rx.recv_opt().unwrap_or(false)
rx.recv().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(CORSCacheTaskMsg::MatchMethodUpdate(request, method, new_max_age, tx));
rx.recv_opt().unwrap_or(false)
rx.recv().unwrap_or(false)
}
fn insert(&mut self, entry: CORSCacheEntry) {
let (tx, rx) = channel();
self.send(CORSCacheTaskMsg::Insert(entry, tx));
let _ = rx.recv_opt();
let _ = rx.recv();
}
}
@ -254,7 +254,7 @@ impl CORSCache for CORSCacheSender {
/// let task = CORSCacheTask::new();
/// let builder = TaskBuilder::new().named("XHRTask");
/// let mut sender = task.get_sender();
/// builder.spawn(proc() { task.run() });
/// builder.spawn(move || { task.run() });
/// sender.insert(CORSCacheEntry::new(/* parameters here */));
/// ```
pub struct CORSCacheTask {
@ -284,7 +284,7 @@ impl CORSCacheTask {
/// Send ExitMsg to the associated Sender to exit
pub fn run(&mut self) {
loop {
match self.receiver.recv() {
match self.receiver.recv().unwrap() {
CORSCacheTaskMsg::Clear(request, tx) => {
self.cache.clear(request);
tx.send(());

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

@ -11,7 +11,7 @@ use fetch::cors_cache::CORSCache;
use fetch::response::Response;
/// A [request context](http://fetch.spec.whatwg.org/#concept-request-context)
#[deriving(Copy)]
#[derive(Copy)]
pub enum Context {
Audio, Beacon, CSPreport, Download, Embed, Eventsource,
Favicon, Fetch, Font, Form, Frame, Hyperlink, IFrame, Image,
@ -21,7 +21,7 @@ pub enum Context {
}
/// A [request context frame type](http://fetch.spec.whatwg.org/#concept-request-context-frame-type)
#[deriving(Copy)]
#[derive(Copy)]
pub enum ContextFrameType {
Auxiliary,
TopLevel,
@ -37,7 +37,7 @@ pub enum Referer {
}
/// A [request mode](http://fetch.spec.whatwg.org/#concept-request-mode)
#[deriving(Copy)]
#[derive(Copy)]
pub enum RequestMode {
SameOrigin,
NoCORS,
@ -46,7 +46,7 @@ pub enum RequestMode {
}
/// Request [credentials mode](http://fetch.spec.whatwg.org/#concept-request-credentials-mode)
#[deriving(Copy)]
#[derive(Copy)]
pub enum CredentialsMode {
Omit,
CredentialsSameOrigin,
@ -54,7 +54,7 @@ pub enum CredentialsMode {
}
/// [Response tainting](http://fetch.spec.whatwg.org/#concept-request-response-tainting)
#[deriving(Copy)]
#[derive(Copy)]
pub enum ResponseTainting {
Basic,
CORSTainting,

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

@ -6,10 +6,10 @@ use url::Url;
use hyper::status::StatusCode;
use hyper::header::Headers;
use std::ascii::AsciiExt;
use std::comm::Receiver;
use std::sync::mpsc::Receiver;
/// [Response type](http://fetch.spec.whatwg.org/#concept-response-type)
#[deriving(Clone, PartialEq, Copy)]
#[derive(Clone, PartialEq, Copy)]
pub enum ResponseType {
Basic,
CORS,
@ -19,7 +19,7 @@ pub enum ResponseType {
}
/// [Response termination reason](http://fetch.spec.whatwg.org/#concept-response-termination-reason)
#[deriving(Clone, Copy)]
#[derive(Clone, Copy)]
pub enum TerminationReason {
EndUserAbort,
Fatal,
@ -29,7 +29,7 @@ pub enum TerminationReason {
/// The response body can still be pushed to after fetch
/// This provides a way to store unfinished response bodies
#[unstable = "I haven't yet decided exactly how the interface for this will be"]
#[deriving(Clone)]
#[derive(Clone)]
pub enum ResponseBody {
Empty, // XXXManishearth is this necessary, or is Done(vec![]) enough?
Receiving(Vec<u8>),
@ -50,7 +50,7 @@ pub struct ResponseLoader {
}
/// A [Response](http://fetch.spec.whatwg.org/#concept-response) as defined by the Fetch spec
#[deriving(Clone)]
#[derive(Clone)]
pub struct Response {
pub response_type: ResponseType,
pub termination_reason: Option<TerminationReason>,
@ -110,7 +110,7 @@ impl Response {
ResponseType::Default | ResponseType::Error => unreachable!(),
ResponseType::Basic => {
let headers = old_headers.iter().filter(|header| {
match header.name().to_ascii_lower().as_slice() {
match header.name().to_ascii_lowercase().as_slice() {
"set-cookie" | "set-cookie2" => false,
_ => true
}
@ -120,7 +120,7 @@ impl Response {
},
ResponseType::CORS => {
let headers = old_headers.iter().filter(|header| {
match header.name().to_ascii_lower().as_slice() {
match header.name().to_ascii_lowercase().as_slice() {
"cache-control" | "content-language" |
"content-type" | "expires" | "last-modified" | "Pragma" => false,
// XXXManishearth handle Access-Control-Expose-Headers

7
components/net/file_loader.rs
View file

@ -8,6 +8,7 @@ use resource_task::ProgressMsg::{Payload, Done};
use std::borrow::ToOwned;
use std::io;
use std::io::File;
use std::sync::mpsc::Sender;
use servo_util::task::spawn_named;
static READ_SIZE: uint = 8192;
@ -17,11 +18,11 @@ fn read_all(reader: &mut io::Stream, progress_chan: &Sender<ProgressMsg>)
loop {
let mut buf = vec!();
match reader.push_at_least(READ_SIZE, READ_SIZE, &mut buf) {
Ok(_) => progress_chan.send(Payload(buf)),
Ok(_) => progress_chan.send(Payload(buf)).unwrap(),
Err(e) => match e.kind {
io::EndOfFile => {
if buf.len() > 0 {
progress_chan.send(Payload(buf));
progress_chan.send(Payload(buf)).unwrap();
}
return Ok(());
}
@ -39,7 +40,7 @@ pub fn factory(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
eventual_consumer: load_data.consumer,
};
let progress_chan = start_sending(senders, Metadata::default(url.clone()));
spawn_named("file_loader".to_owned(), proc() {
spawn_named("file_loader".to_owned(), move || {
let file_path: Result<Path, ()> = url.to_file_path();
match file_path {
Ok(file_path) => {

20
components/net/http_loader.rs
View file

@ -11,14 +11,16 @@ use hyper::client::Request;
use hyper::header::common::{ContentLength, ContentType, Host, Location};
use hyper::method::Method;
use hyper::status::StatusClass;
use std::error::Error;
use std::io::Reader;
use std::sync::mpsc::Sender;
use servo_util::task::spawn_named;
use url::{Url, UrlParser};
use std::borrow::ToOwned;
pub fn factory(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
spawn_named("http_loader".to_owned(), proc() load(load_data, start_chan))
spawn_named("http_loader".to_owned(), move || load(load_data, start_chan))
}
fn send_error(url: Url, err: String, senders: ResponseSenders) {
@ -26,7 +28,7 @@ fn send_error(url: Url, err: String, senders: ResponseSenders) {
metadata.status = None;
match start_sending_opt(senders, metadata) {
Ok(p) => p.send(Done(Err(err))),
Ok(p) => p.send(Done(Err(err))).unwrap(),
_ => {}
};
}
@ -75,7 +77,7 @@ fn load(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
let mut req = match Request::new(load_data.method.clone(), url.clone()) {
Ok(req) => req,
Err(e) => {
send_error(url, e.to_string(), senders);
send_error(url, e.description().to_string(), senders);
return;
}
};
@ -91,11 +93,11 @@ fn load(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
//}
let writer = match load_data.data {
Some(ref data) => {
req.headers_mut().set(ContentLength(data.len()));
req.headers_mut().set(ContentLength(data.len() as u64));
let mut writer = match req.start() {
Ok(w) => w,
Err(e) => {
send_error(url, e.to_string(), senders);
send_error(url, e.description().to_string(), senders);
return;
}
};
@ -116,7 +118,7 @@ fn load(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
match req.start() {
Ok(w) => w,
Err(e) => {
send_error(url, e.to_string(), senders);
send_error(url, e.description().to_string(), senders);
return;
}
}
@ -125,7 +127,7 @@ fn load(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
let mut response = match writer.send() {
Ok(r) => r,
Err(e) => {
send_error(url, e.to_string(), senders);
send_error(url, e.description().to_string(), senders);
return;
}
};
@ -189,7 +191,7 @@ fn load(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
match response.read(buf.as_mut_slice()) {
Ok(len) => {
unsafe { buf.set_len(len); }
if progress_chan.send_opt(Payload(buf)).is_err() {
if progress_chan.send(Payload(buf)).is_err() {
// The send errors when the receiver is out of scope,
// which will happen if the fetch has timed out (or has been aborted)
// so we don't need to continue with the loading of the file here.
@ -197,7 +199,7 @@ fn load(load_data: LoadData, start_chan: Sender<TargetedLoadResponse>) {
}
}
Err(_) => {
let _ = progress_chan.send_opt(Done(Ok(())));
let _ = progress_chan.send(Done(Ok(())));
break;
}
}

2
components/net/image/base.rs
View file

@ -11,7 +11,7 @@ use png;
pub type Image = png::Image;
static TEST_IMAGE: &'static [u8] = include_bin!("test.jpeg");
static TEST_IMAGE: &'static [u8] = include_bytes!("test.jpeg");
pub fn test_image_bin() -> Vec<u8> {
TEST_IMAGE.iter().map(|&x| x).collect()

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

@ -16,7 +16,7 @@ use url::Url;
/// A struct to store image data. The image will be loaded once the first time it is requested,
/// and an Arc will be stored. Clones of this Arc are given out on demand.
#[deriving(Clone)]
#[derive(Clone)]
pub struct ImageHolder<NodeAddress> {
url: Url,
image: Option<Arc<Box<Image>>>,
@ -41,7 +41,7 @@ impl<NodeAddress: Send> ImageHolder<NodeAddress> {
// should be done as early as possible and decode only once we
// are sure that the image will be used.
{
let val = holder.local_image_cache.lock();
let val = holder.local_image_cache.lock().unwrap();
let mut local_image_cache = val;
local_image_cache.prefetch(&holder.url);
local_image_cache.decode(&holder.url);
@ -81,11 +81,11 @@ impl<NodeAddress: Send> ImageHolder<NodeAddress> {
// the image and store it for the future
if self.image.is_none() {
let port = {
let val = self.local_image_cache.lock();
let val = self.local_image_cache.lock().unwrap();
let mut local_image_cache = val;
local_image_cache.get_image(node_address, &self.url)
};
match port.recv() {
match port.recv().unwrap() {
ImageResponseMsg::ImageReady(image) => self.image = Some(image),
ImageResponseMsg::ImageNotReady => debug!("image not ready for {}", self.url.serialize()),
ImageResponseMsg::ImageFailed => debug!("image decoding failed for {}", self.url.serialize()),

168
components/net/image_cache_task.rs
View file

@ -10,12 +10,11 @@ use resource_task::ProgressMsg::{Payload, Done};
use servo_util::task::spawn_named;
use servo_util::taskpool::TaskPool;
use std::borrow::ToOwned;
use std::comm::{channel, Receiver, Sender};
use std::collections::HashMap;
use std::collections::hash_map::{Occupied, Vacant};
use std::collections::hash_map::Entry::{Occupied, Vacant};
use std::mem::replace;
use std::sync::{Arc, Mutex};
use serialize::{Encoder, Encodable};
use std::sync::mpsc::{channel, Receiver, Sender};
use url::Url;
pub enum Msg {
@ -49,7 +48,7 @@ pub enum Msg {
WaitForStorePrefetched(Sender<()>),
}
#[deriving(Clone)]
#[derive(Clone)]
pub enum ImageResponseMsg {
ImageReady(Arc<Box<Image>>),
ImageNotReady,
@ -68,25 +67,17 @@ impl PartialEq for ImageResponseMsg {
}
}
#[deriving(Clone)]
#[derive(Clone)]
pub struct ImageCacheTask {
chan: Sender<Msg>,
}
impl<E, S: Encoder<E>> Encodable<S, E> for ImageCacheTask {
fn encode(&self, _: &mut S) -> Result<(), E> {
Ok(())
}
}
type DecoderFactory = fn() -> (proc(&[u8]) : 'static -> Option<Image>);
impl ImageCacheTask {
pub fn new(resource_task: ResourceTask, task_pool: TaskPool) -> ImageCacheTask {
let (chan, port) = channel();
let chan_clone = chan.clone();
spawn_named("ImageCacheTask".to_owned(), proc() {
spawn_named("ImageCacheTask".to_owned(), move || {
let mut cache = ImageCache {
resource_task: resource_task,
port: port,
@ -107,11 +98,11 @@ impl ImageCacheTask {
pub fn new_sync(resource_task: ResourceTask, task_pool: TaskPool) -> ImageCacheTask {
let (chan, port) = channel();
spawn_named("ImageCacheTask (sync)".to_owned(), proc() {
spawn_named("ImageCacheTask (sync)".to_owned(), move || {
let inner_cache = ImageCacheTask::new(resource_task, task_pool);
loop {
let msg: Msg = port.recv();
let msg: Msg = port.recv().unwrap();
match msg {
Msg::GetImage(url, response) => {
@ -147,7 +138,7 @@ struct ImageCache {
task_pool: TaskPool,
}
#[deriving(Clone)]
#[derive(Clone)]
enum ImageState {
Init,
Prefetching(AfterPrefetch),
@ -157,7 +148,7 @@ enum ImageState {
Failed
}
#[deriving(Clone)]
#[derive(Clone)]
enum AfterPrefetch {
DoDecode,
DoNotDecode
@ -169,7 +160,7 @@ impl ImageCache {
let mut store_prefetched_chan: Option<Sender<()>> = None;
loop {
let msg = self.port.recv();
let msg = self.port.recv().unwrap();
match msg {
Msg::Prefetch(url) => self.prefetch(url),
@ -249,7 +240,7 @@ impl ImageCache {
let resource_task = self.resource_task.clone();
let url_clone = url.clone();
spawn_named("ImageCacheTask (prefetch)".to_owned(), proc() {
spawn_named("ImageCacheTask (prefetch)".to_owned(), move || {
let url = url_clone;
debug!("image_cache_task: started fetch for {}", url.serialize());
@ -313,7 +304,7 @@ impl ImageCache {
let to_cache = self.chan.clone();
let url_clone = url.clone();
self.task_pool.execute(proc() {
self.task_pool.execute(move || {
let url = url_clone;
debug!("image_cache_task: started image decode for {}", url.serialize());
let image = load_from_memory(data.as_slice());
@ -358,10 +349,10 @@ impl ImageCache {
}
fn purge_waiters(&mut self, url: Url, f: || -> ImageResponseMsg) {
fn purge_waiters<F>(&mut self, url: Url, f: F) where F: Fn() -> ImageResponseMsg {
match self.wait_map.remove(&url) {
Some(waiters) => {
let items = waiters.lock();
let items = waiters.lock().unwrap();
for response in items.iter() {
response.send(f());
}
@ -373,11 +364,11 @@ impl ImageCache {
fn get_image(&self, url: Url, response: Sender<ImageResponseMsg>) {
match self.get_state(&url) {
ImageState::Init => panic!("request for image before prefetch"),
ImageState::Prefetching(AfterPrefetch::DoDecode) => response.send(ImageResponseMsg::ImageNotReady),
ImageState::Prefetching(AfterPrefetch::DoDecode) => response.send(ImageResponseMsg::ImageNotReady).unwrap(),
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),
ImageState::Decoding => response.send(ImageResponseMsg::ImageNotReady).unwrap(),
ImageState::Decoded(image) => response.send(ImageResponseMsg::ImageReady(image)).unwrap(),
ImageState::Failed => response.send(ImageResponseMsg::ImageFailed).unwrap(),
}
}
@ -391,10 +382,10 @@ impl ImageCache {
// We don't have this image yet
match self.wait_map.entry(url) {
Occupied(mut entry) => {
entry.get_mut().lock().push(response);
entry.get_mut().lock().unwrap().push(response);
}
Vacant(entry) => {
entry.set(Arc::new(Mutex::new(vec!(response))));
entry.insert(Arc::new(Mutex::new(vec!(response))));
}
}
}
@ -420,7 +411,7 @@ impl ImageCacheTaskClient for ImageCacheTask {
fn exit(&self) {
let (response_chan, response_port) = channel();
self.send(Msg::Exit(response_chan));
response_port.recv();
response_port.recv().unwrap();
}
}
@ -450,9 +441,9 @@ fn load_image_data(url: Url, resource_task: ResourceTask) -> Result<Vec<u8>, ()>
let mut image_data = vec!();
let progress_port = response_port.recv().progress_port;
let progress_port = response_port.recv().unwrap().progress_port;
loop {
match progress_port.recv() {
match progress_port.recv().unwrap() {
Payload(data) => {
image_data.push_all(data.as_slice());
}
@ -467,15 +458,18 @@ fn load_image_data(url: Url, resource_task: ResourceTask) -> Result<Vec<u8>, ()>
}
pub fn spawn_listener<A: Send>(f: proc(Receiver<A>):Send) -> Sender<A> {
pub fn spawn_listener<F, A>(f: F) -> Sender<A>
where F: FnOnce(Receiver<A>) + Send,
A: Send
{
let (setup_chan, setup_port) = channel();
spawn_named("ImageCacheTask (listener)".to_owned(), proc() {
spawn_named("ImageCacheTask (listener)".to_owned(), move || {
let (chan, port) = channel();
setup_chan.send(chan);
f(port);
});
setup_port.recv()
setup_port.recv().unwrap()
}
@ -491,7 +485,7 @@ mod tests {
use sniffer_task;
use image::base::test_image_bin;
use servo_util::taskpool::TaskPool;
use std::comm;
use std::sync::mpsc::{Sender, channel, Receiver};
use url::Url;
trait Closure {
@ -541,7 +535,7 @@ mod tests {
fn invoke(&self, response: Sender<resource_task::ProgressMsg>) {
// Don't send the data until after the client requests
// the image
self.wait_port.recv();
self.wait_port.recv().unwrap();
response.send(Payload(test_image_bin()));
response.send(Done(Ok(())));
}
@ -554,16 +548,16 @@ mod tests {
fn invoke(&self, response: Sender<resource_task::ProgressMsg>) {
// Don't send the data until after the client requests
// the image
self.wait_port.recv();
self.wait_port.recv().unwrap();
response.send(Payload(test_image_bin()));
response.send(Done(Err("".to_string())));
}
}
fn mock_resource_task<T: Closure+Send>(on_load: Box<T>) -> ResourceTask {
spawn_listener(proc(port: Receiver<resource_task::ControlMsg>) {
spawn_listener(move |port: Receiver<resource_task::ControlMsg>| {
loop {
match port.recv() {
match port.recv().unwrap() {
resource_task::ControlMsg::Load(response) => {
let sniffer_task = sniffer_task::new_sniffer_task();
let senders = ResponseSenders {
@ -600,7 +594,7 @@ mod tests {
let (chan, port) = channel();
image_cache_task.send(Msg::GetImage(url, chan));
port.recv();
port.recv().unwrap();
}
#[test]
@ -613,14 +607,14 @@ mod tests {
let url = Url::parse("file:///").unwrap();
image_cache_task.send(Prefetch(url));
url_requested.recv();
url_requested.recv().unwrap();
image_cache_task.exit();
mock_resource_task.send(resource_task::ControlMsg::Exit);
}
#[test]
fn should_not_request_url_from_resource_task_on_multiple_prefetches() {
let (url_requested_chan, url_requested) = comm::channel();
let (url_requested_chan, url_requested) = channel();
let mock_resource_task = mock_resource_task(box JustSendOK { url_requested_chan: url_requested_chan});
@ -629,7 +623,7 @@ mod tests {
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Prefetch(url));
url_requested.recv();
url_requested.recv().unwrap();
image_cache_task.exit();
mock_resource_task.send(resource_task::ControlMsg::Exit);
match url_requested.try_recv() {
@ -640,7 +634,7 @@ mod tests {
#[test]
fn should_return_image_not_ready_if_data_has_not_arrived() {
let (wait_chan, wait_port) = comm::channel();
let (wait_chan, wait_port) = channel();
let mock_resource_task = mock_resource_task(box WaitSendTestImage{wait_port: wait_port});
@ -649,9 +643,9 @@ mod tests {
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
let (response_chan, response_port) = comm::channel();
let (response_chan, response_port) = channel();
image_cache_task.send(Msg::GetImage(url, response_chan));
assert!(response_port.recv() == ImageResponseMsg::ImageNotReady);
assert!(response_port.recv().unwrap() == ImageResponseMsg::ImageNotReady);
wait_chan.send(());
image_cache_task.exit();
mock_resource_task.send(resource_task::ControlMsg::Exit);
@ -670,11 +664,11 @@ mod tests {
image_cache_task.send(Decode(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
join_port.recv();
join_port.recv().unwrap();
let (response_chan, response_port) = comm::channel();
let (response_chan, response_port) = channel();
image_cache_task.send(Msg::GetImage(url, response_chan));
match response_port.recv() {
match response_port.recv().unwrap() {
ImageResponseMsg::ImageReady(_) => (),
_ => panic!("bleh")
}
@ -696,12 +690,12 @@ mod tests {
image_cache_task.send(Decode(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
join_port.recv();
join_port.recv().unwrap();
for _ in range(0u32, 2u32) {
let (response_chan, response_port) = comm::channel();
let (response_chan, response_port) = channel();
image_cache_task.send(Msg::GetImage(url.clone(), response_chan));
match response_port.recv() {
match response_port.recv().unwrap() {
ImageResponseMsg::ImageReady(_) => (),
_ => panic!("bleh")
}
@ -713,13 +707,13 @@ mod tests {
#[test]
fn should_not_request_image_from_resource_task_if_image_is_already_available() {
let (image_bin_sent_chan, image_bin_sent) = comm::channel();
let (image_bin_sent_chan, image_bin_sent) = channel();
let (resource_task_exited_chan, resource_task_exited) = comm::channel();
let (resource_task_exited_chan, resource_task_exited) = channel();
let mock_resource_task = spawn_listener(proc(port: Receiver<resource_task::ControlMsg>) {
let mock_resource_task = spawn_listener(move |port: Receiver<resource_task::ControlMsg>| {
loop {
match port.recv() {
match port.recv().unwrap() {
resource_task::ControlMsg::Load(response) => {
let sniffer_task = sniffer_task::new_sniffer_task();
let senders = ResponseSenders {
@ -746,14 +740,14 @@ mod tests {
image_cache_task.send(Prefetch(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
image_bin_sent.recv();
image_bin_sent.recv().unwrap();
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.exit();
mock_resource_task.send(resource_task::ControlMsg::Exit);
resource_task_exited.recv();
resource_task_exited.recv().unwrap();
// Our resource task should not have received another request for the image
// because it's already cached
@ -765,13 +759,13 @@ mod tests {
#[test]
fn should_not_request_image_from_resource_task_if_image_fetch_already_failed() {
let (image_bin_sent_chan, image_bin_sent) = comm::channel();
let (image_bin_sent_chan, image_bin_sent) = channel();
let (resource_task_exited_chan, resource_task_exited) = comm::channel();
let (resource_task_exited_chan, resource_task_exited) = channel();
let mock_resource_task = spawn_listener(proc(port: Receiver<resource_task::ControlMsg>) {
let mock_resource_task = spawn_listener(move |port: Receiver<resource_task::ControlMsg>| {
loop {
match port.recv() {
match port.recv().unwrap() {
resource_task::ControlMsg::Load(response) => {
let sniffer_task = sniffer_task::new_sniffer_task();
let senders = ResponseSenders {
@ -799,7 +793,7 @@ mod tests {
image_cache_task.send(Decode(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
image_bin_sent.recv();
image_bin_sent.recv().unwrap();
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
@ -807,7 +801,7 @@ mod tests {
image_cache_task.exit();
mock_resource_task.send(resource_task::ControlMsg::Exit);
resource_task_exited.recv();
resource_task_exited.recv().unwrap();
// Our resource task should not have received another request for the image
// because it's already cached
@ -830,11 +824,11 @@ mod tests {
image_cache_task.send(Decode(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
join_port.recv();
join_port.recv().unwrap();
let (response_chan, response_port) = comm::channel();
let (response_chan, response_port) = channel();
image_cache_task.send(Msg::GetImage(url, response_chan));
match response_port.recv() {
match response_port.recv().unwrap() {
ImageResponseMsg::ImageFailed => (),
_ => panic!("bleh")
}
@ -856,19 +850,19 @@ mod tests {
image_cache_task.send(Decode(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
join_port.recv();
join_port.recv().unwrap();
let (response_chan, response_port) = comm::channel();
let (response_chan, response_port) = channel();
image_cache_task.send(Msg::GetImage(url.clone(), response_chan));
match response_port.recv() {
match response_port.recv().unwrap() {
ImageResponseMsg::ImageFailed => (),
_ => panic!("bleh")
}
// And ask again, we should get the same response
let (response_chan, response_port) = comm::channel();
let (response_chan, response_port) = channel();
image_cache_task.send(Msg::GetImage(url, response_chan));
match response_port.recv() {
match response_port.recv().unwrap() {
ImageResponseMsg::ImageFailed => (),
_ => panic!("bleh")
}
@ -890,13 +884,13 @@ mod tests {
image_cache_task.send(Decode(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
join_port.recv();
join_port.recv().unwrap();
// Make the request
let (response_chan, response_port) = comm::channel();
let (response_chan, response_port) = channel();
image_cache_task.send(Msg::GetImage(url, response_chan));
match response_port.recv() {
match response_port.recv().unwrap() {
ImageResponseMsg::ImageFailed => (),
_ => panic!("bleh")
}
@ -918,11 +912,11 @@ mod tests {
image_cache_task.send(Decode(url.clone()));
// Wait until our mock resource task has sent the image to the image cache
join_port.recv();
join_port.recv().unwrap();
let (response_chan, response_port) = comm::channel();
let (response_chan, response_port) = channel();
image_cache_task.send(Msg::WaitForImage(url, response_chan));
match response_port.recv() {
match response_port.recv().unwrap() {
ImageResponseMsg::ImageReady(..) => (),
_ => panic!("bleh")
}
@ -933,7 +927,7 @@ mod tests {
#[test]
fn should_return_image_on_wait_if_image_is_not_yet_loaded() {
let (wait_chan, wait_port) = comm::channel();
let (wait_chan, wait_port) = channel();
let mock_resource_task = mock_resource_task(box WaitSendTestImage {wait_port: wait_port});
@ -943,12 +937,12 @@ mod tests {
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
let (response_chan, response_port) = comm::channel();
let (response_chan, response_port) = channel();
image_cache_task.send(Msg::WaitForImage(url, response_chan));
wait_chan.send(());
match response_port.recv() {
match response_port.recv().unwrap() {
ImageResponseMsg::ImageReady(..) => (),
_ => panic!("bleh")
}
@ -959,7 +953,7 @@ mod tests {
#[test]
fn should_return_image_failed_on_wait_if_image_fails_to_load() {
let (wait_chan, wait_port) = comm::channel();
let (wait_chan, wait_port) = channel();
let mock_resource_task = mock_resource_task(box WaitSendTestImageErr{wait_port: wait_port});
@ -969,12 +963,12 @@ mod tests {
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
let (response_chan, response_port) = comm::channel();
let (response_chan, response_port) = channel();
image_cache_task.send(Msg::WaitForImage(url, response_chan));
wait_chan.send(());
match response_port.recv() {
match response_port.recv().unwrap() {
ImageResponseMsg::ImageFailed => (),
_ => panic!("bleh")
}
@ -993,9 +987,9 @@ mod tests {
image_cache_task.send(Prefetch(url.clone()));
image_cache_task.send(Decode(url.clone()));
let (response_chan, response_port) = comm::channel();
let (response_chan, response_port) = channel();
image_cache_task.send(Msg::GetImage(url, response_chan));
match response_port.recv() {
match response_port.recv().unwrap() {
ImageResponseMsg::ImageReady(_) => (),
_ => panic!("bleh")
}

7
components/net/lib.rs
View file

@ -2,17 +2,20 @@
* 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/. */
#![feature(default_type_params, globs, phase)]
#![feature(int_uint)]
#![feature(unboxed_closures)]
#![feature(box_syntax)]
#![deny(unused_imports)]
#![deny(unused_variables)]
#![allow(missing_copy_implementations)]
#![allow(unstable)]
extern crate collections;
extern crate geom;
extern crate hyper;
extern crate png;
#[phase(plugin, link)]
#[macro_use]
extern crate log;
extern crate serialize;
extern crate "util" as servo_util;

18
components/net/local_image_cache.rs
View file

@ -11,14 +11,14 @@ multiple times and thus triggering reflows multiple times.
use image_cache_task::{ImageCacheTask, ImageResponseMsg, Msg};
use std::borrow::ToOwned;
use std::comm::{Receiver, channel};
use std::collections::HashMap;
use std::collections::hash_map::{Occupied, Vacant};
use std::collections::hash_map::Entry::{Occupied, Vacant};
use std::sync::mpsc::{Receiver, channel};
use servo_util::task::spawn_named;
use url::Url;
pub trait ImageResponder<NodeAddress: Send> {
fn respond(&self) -> proc(ImageResponseMsg, NodeAddress):Send;
fn respond(&self) -> Box<Fn(ImageResponseMsg, NodeAddress)+Send>;
}
pub struct LocalImageCache<NodeAddress> {
@ -39,7 +39,7 @@ impl<NodeAddress: Send> LocalImageCache<NodeAddress> {
}
}
#[deriving(Clone)]
#[derive(Clone)]
struct ImageState {
prefetched: bool,
decoded: bool,
@ -118,7 +118,7 @@ impl<NodeAddress: Send> LocalImageCache<NodeAddress> {
let (response_chan, response_port) = channel();
self.image_cache_task.send(Msg::GetImage((*url).clone(), response_chan));
let response = response_port.recv();
let response = response_port.recv().unwrap();
match response {
ImageResponseMsg::ImageNotReady => {
// Need to reflow when the image is available
@ -128,13 +128,13 @@ impl<NodeAddress: Send> LocalImageCache<NodeAddress> {
// on the image to load and triggering layout
let image_cache_task = self.image_cache_task.clone();
assert!(self.on_image_available.is_some());
let on_image_available: proc(ImageResponseMsg, NodeAddress):Send =
let on_image_available =
self.on_image_available.as_ref().unwrap().respond();
let url = (*url).clone();
spawn_named("LocalImageCache".to_owned(), proc() {
spawn_named("LocalImageCache".to_owned(), move || {
let (response_chan, response_port) = channel();
image_cache_task.send(Msg::WaitForImage(url, response_chan));
on_image_available(response_port.recv(), node_address);
on_image_available(response_port.recv().unwrap(), node_address);
});
}
_ => ()
@ -157,7 +157,7 @@ impl<NodeAddress: Send> LocalImageCache<NodeAddress> {
match self.state_map.entry((*url).clone()) {
Occupied(entry) => entry.into_mut(),
Vacant(entry) =>
entry.set(ImageState {
entry.insert(ImageState {
prefetched: false,
decoded: false,
last_request_round: 0,

46
components/net/resource_task.rs
View file

@ -21,7 +21,7 @@ use hyper::mime::{Mime, Attr};
use url::Url;
use std::borrow::ToOwned;
use std::comm::{channel, Receiver, Sender};
use std::sync::mpsc::{channel, Receiver, Sender};
pub enum ControlMsg {
/// Request the data associated with a particular URL
@ -29,7 +29,7 @@ pub enum ControlMsg {
Exit
}
#[deriving(Clone)]
#[derive(Clone)]
pub struct LoadData {
pub url: Url,
pub method: Method,
@ -52,7 +52,7 @@ impl LoadData {
}
}
#[deriving(Clone)]
#[derive(Clone)]
pub struct ResourceCORSData {
/// CORS Preflight flag
pub preflight: bool,
@ -131,7 +131,7 @@ pub struct ResponseSenders {
}
/// Messages sent in response to a `Load` message
#[deriving(PartialEq,Show)]
#[derive(PartialEq,Show)]
pub enum ProgressMsg {
/// Binary data - there may be multiple of these
Payload(Vec<u8>),
@ -147,7 +147,7 @@ pub fn start_sending(senders: ResponseSenders, metadata: Metadata) -> Sender<Pro
/// For use by loaders in responding to a Load message.
pub fn start_sending_opt(senders: ResponseSenders, metadata: Metadata) -> Result<Sender<ProgressMsg>, ()> {
let (progress_chan, progress_port) = channel();
let result = senders.immediate_consumer.send_opt(TargetedLoadResponse {
let result = senders.immediate_consumer.send(TargetedLoadResponse {
load_response: LoadResponse {
metadata: metadata,
progress_port: progress_port,
@ -165,11 +165,11 @@ 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)));
let response = start_port.recv();
let response = start_port.recv().unwrap();
let mut buf = vec!();
loop {
match response.progress_port.recv() {
match response.progress_port.recv().unwrap() {
ProgressMsg::Payload(data) => buf.push_all(data.as_slice()),
ProgressMsg::Done(Ok(())) => return Ok((response.metadata, buf)),
ProgressMsg::Done(Err(e)) => return Err(e)
@ -184,7 +184,7 @@ pub type ResourceTask = Sender<ControlMsg>;
pub fn new_resource_task(user_agent: Option<String>) -> ResourceTask {
let (setup_chan, setup_port) = channel();
let sniffer_task = sniffer_task::new_sniffer_task();
spawn_named("ResourceManager".to_owned(), proc() {
spawn_named("ResourceManager".to_owned(), move || {
ResourceManager::new(setup_port, user_agent, sniffer_task).start();
});
setup_chan
@ -210,7 +210,7 @@ impl ResourceManager {
impl ResourceManager {
fn start(&self) {
loop {
match self.from_client.recv() {
match self.from_client.recv().unwrap() {
ControlMsg::Load(load_data) => {
self.load(load_data)
}
@ -229,21 +229,19 @@ impl ResourceManager {
eventual_consumer: load_data.consumer.clone(),
};
let loader = match load_data.url.scheme.as_slice() {
"file" => file_loader::factory,
"http" | "https" => http_loader::factory,
"data" => data_loader::factory,
"about" => about_loader::factory,
debug!("resource_task: loading url: {}", load_data.url.serialize());
match load_data.url.scheme.as_slice() {
"file" => file_loader::factory(load_data, self.sniffer_task.clone()),
"http" | "https" => http_loader::factory(load_data, self.sniffer_task.clone()),
"data" => data_loader::factory(load_data, self.sniffer_task.clone()),
"about" => about_loader::factory(load_data, self.sniffer_task.clone()),
_ => {
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())));
return
}
};
debug!("resource_task: loading url: {}", load_data.url.serialize());
loader(load_data, self.sniffer_task.clone());
}
}
}
@ -252,7 +250,7 @@ pub fn load_bytes_iter(resource_task: &ResourceTask, url: Url) -> (Metadata, Pro
let (input_chan, input_port) = channel();
resource_task.send(ControlMsg::Load(LoadData::new(url, input_chan)));
let response = input_port.recv();
let response = input_port.recv().unwrap();
let iter = ProgressMsgPortIterator { progress_port: response.progress_port };
(response.metadata, iter)
}
@ -262,9 +260,11 @@ pub struct ProgressMsgPortIterator {
progress_port: Receiver<ProgressMsg>
}
impl Iterator<Vec<u8>> for ProgressMsgPortIterator {
impl Iterator for ProgressMsgPortIterator {
type Item = Vec<u8>;
fn next(&mut self) -> Option<Vec<u8>> {
match self.progress_port.recv() {
match self.progress_port.recv().unwrap() {
ProgressMsg::Payload(data) => Some(data),
ProgressMsg::Done(Ok(())) => None,
ProgressMsg::Done(Err(e)) => {
@ -287,8 +287,8 @@ fn test_bad_scheme() {
let (start_chan, start) = channel();
let url = Url::parse("bogus://whatever").unwrap();
resource_task.send(ControlMsg::Load(LoadData::new(url, start_chan)));
let response = start.recv();
match response.progress_port.recv() {
let response = start.recv().unwrap();
match response.progress_port.recv().unwrap() {
ProgressMsg::Done(result) => { assert!(result.is_err()) }
_ => panic!("bleh")
}

12
components/net/sniffer_task.rs
View file

@ -3,16 +3,16 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
//! A task that sniffs data
use std::comm::{channel, Receiver, Sender};
use std::task::TaskBuilder;
use std::sync::mpsc::{channel, Receiver, Sender};
use std::thread::Builder;
use resource_task::{TargetedLoadResponse};
pub type SnifferTask = Sender<TargetedLoadResponse>;
pub fn new_sniffer_task() -> SnifferTask {
let(sen, rec) = channel();
let builder = TaskBuilder::new().named("SnifferManager");
builder.spawn(proc() {
let builder = Builder::new().name("SnifferManager".to_string());
builder.spawn(move || {
SnifferManager::new(rec).start();
});
sen
@ -33,9 +33,9 @@ impl SnifferManager {
impl SnifferManager {
fn start(self) {
loop {
match self.data_receiver.recv_opt() {
match self.data_receiver.recv() {
Ok(snif_data) => {
let _ = snif_data.consumer.send_opt(snif_data.load_response);
let _ = snif_data.consumer.send(snif_data.load_response);
}
Err(_) => break,
}

14
components/net/storage_task.rs
View file

@ -3,9 +3,9 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use std::borrow::ToOwned;
use std::comm::{channel, Receiver, Sender};
use std::collections::HashMap;
use std::collections::TreeMap;
use std::collections::BTreeMap;
use std::sync::mpsc::{channel, Receiver, Sender};
use url::Url;
use servo_util::str::DOMString;
@ -40,14 +40,14 @@ pub enum StorageTaskMsg {
pub type StorageTask = Sender<StorageTaskMsg>;
pub trait StorageTaskFactory {
fn new() -> StorageTask;
fn new() -> Self;
}
impl StorageTaskFactory for StorageTask {
/// Create a StorageTask
fn new() -> StorageTask {
let (chan, port) = channel();
spawn_named("StorageManager".to_owned(), proc() {
spawn_named("StorageManager".to_owned(), move || {
StorageManager::new(port).start();
});
chan
@ -56,7 +56,7 @@ impl StorageTaskFactory for StorageTask {
struct StorageManager {
port: Receiver<StorageTaskMsg>,
data: HashMap<String, TreeMap<DOMString, DOMString>>,
data: HashMap<String, BTreeMap<DOMString, DOMString>>,
}
impl StorageManager {
@ -71,7 +71,7 @@ impl StorageManager {
impl StorageManager {
fn start(&mut self) {
loop {
match self.port.recv() {
match self.port.recv().unwrap() {
StorageTaskMsg::Length(sender, url) => {
self.length(sender, url)
}
@ -112,7 +112,7 @@ impl StorageManager {
fn set_item(&mut self, sender: Sender<bool>, url: Url, name: DOMString, value: DOMString) {
let origin = self.get_origin_as_string(url);
if !self.data.contains_key(&origin) {
self.data.insert(origin.clone(), TreeMap::new());
self.data.insert(origin.clone(), BTreeMap::new());
}
let updated = self.data.get_mut(&origin).map(|entry| {