Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-24 15:50:21 +01:00
Code Issues Projects Releases Packages Wiki Activity

Replace usage of ResponseSenders by LoadConsumer

Browse source
This commit is contained in:
Marcus Klaas 2015-04-19 13:26:56 +02:00
parent 40ee41ca92
commit c1f25bbfe4
8 changed files with 28 additions and 43 deletions
Download patch file Download diff file Expand all files Collapse all files

4
components/net/about_loader.rs
View file

@ -2,7 +2,7 @@
* 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 net_traits::{LoadData, Metadata,ResponseSenders};
use net_traits::{LoadData, Metadata, LoadConsumer};
use net_traits::ProgressMsg::Done;
use mime_classifier::MIMEClassifier;
use resource_task::start_sending;
@ -18,7 +18,7 @@ use std::borrow::IntoCow;
use std::fs::PathExt;
use std::sync::Arc;
pub fn factory(mut load_data: LoadData, start_chan: ResponseSenders, classifier: Arc<MIMEClassifier>) {
pub fn factory(mut load_data: LoadData, start_chan: LoadConsumer, classifier: Arc<MIMEClassifier>) {
match load_data.url.non_relative_scheme_data().unwrap() {
"blank" => {
let chan = start_sending(start_chan, Metadata {

6
components/net/data_loader.rs
View file

@ -2,7 +2,7 @@
* 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 net_traits::{LoadData, Metadata, ResponseSenders};
use net_traits::{LoadData, Metadata, LoadConsumer};
use net_traits::ProgressMsg::{Payload, Done};
use mime_classifier::MIMEClassifier;
use resource_task::start_sending;
@ -13,7 +13,7 @@ use hyper::mime::Mime;
use std::sync::Arc;
use url::{percent_decode, SchemeData};
pub fn factory(load_data: LoadData, senders: ResponseSenders, _classifier: Arc<MIMEClassifier>) {
pub fn factory(load_data: LoadData, senders: LoadConsumer, _classifier: Arc<MIMEClassifier>) {
// NB: we don't spawn a new task.
// Hypothesis: data URLs are too small for parallel base64 etc. to be worth it.
// Should be tested at some point.
@ -21,7 +21,7 @@ pub fn factory(load_data: LoadData, senders: ResponseSenders, _classifier: Arc<M
load(load_data, senders)
}
pub fn load(load_data: LoadData, start_chan: ResponseSenders) {
pub fn load(load_data: LoadData, start_chan: LoadConsumer) {
let url = load_data.url;
assert!(&*url.scheme == "data");

4
components/net/file_loader.rs
View file

@ -2,7 +2,7 @@
* 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 net_traits::{LoadData, Metadata, ResponseSenders};
use net_traits::{LoadData, Metadata, LoadConsumer};
use net_traits::ProgressMsg::{Payload, Done};
use mime_classifier::MIMEClassifier;
use resource_task::{start_sending, start_sending_sniffed, ProgressSender};
@ -43,7 +43,7 @@ fn read_all(reader: &mut File, progress_chan: &ProgressSender)
}
}
pub fn factory(load_data: LoadData, senders: ResponseSenders, classifier: Arc<MIMEClassifier>) {
pub fn factory(load_data: LoadData, senders: LoadConsumer, classifier: Arc<MIMEClassifier>) {
let url = load_data.url;
assert!(&*url.scheme == "file");
spawn_named("file_loader".to_owned(), move || {

10
components/net/http_loader.rs
View file

@ -2,7 +2,7 @@
* 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 net_traits::{ControlMsg, CookieSource, LoadData, Metadata, ResponseSenders};
use net_traits::{ControlMsg, CookieSource, LoadData, Metadata, LoadConsumer};
use net_traits::ProgressMsg::{Payload, Done};
use mime_classifier::MIMEClassifier;
use resource_task::{start_sending_opt, start_sending_sniffed_opt};
@ -32,13 +32,13 @@ use url::{Url, UrlParser};
use std::borrow::ToOwned;
pub fn factory(cookies_chan: Sender<ControlMsg>)
-> Box<Invoke<(LoadData, ResponseSenders, Arc<MIMEClassifier>)> + Send> {
-> Box<Invoke<(LoadData, LoadConsumer, Arc<MIMEClassifier>)> + Send> {
box move |(load_data, senders, classifier)| {
spawn_named("http_loader".to_owned(), move || load(load_data, senders, classifier, cookies_chan))
}
}
fn send_error(url: Url, err: String, start_chan: ResponseSenders) {
fn send_error(url: Url, err: String, start_chan: LoadConsumer) {
let mut metadata: Metadata = Metadata::default(url);
metadata.status = None;
@ -66,7 +66,7 @@ fn read_block<R: Read>(reader: &mut R) -> Result<ReadResult, ()> {
}
}
fn load(mut load_data: LoadData, start_chan: ResponseSenders, classifier: Arc<MIMEClassifier>, cookies_chan: Sender<ControlMsg>) {
fn load(mut load_data: LoadData, start_chan: LoadConsumer, classifier: Arc<MIMEClassifier>, cookies_chan: Sender<ControlMsg>) {
// FIXME: At the time of writing this FIXME, servo didn't have any central
// location for configuration. If you're reading this and such a
// repository DOES exist, please update this constant to use it.
@ -339,7 +339,7 @@ reason: \"certificate verify failed\" }]";
}
fn send_data<R: Read>(reader: &mut R,
start_chan: ResponseSenders,
start_chan: LoadConsumer,
metadata: Metadata,
classifier: Arc<MIMEClassifier>) {
let (progress_chan, mut chunk) = {

23
components/net/resource_task.rs
View file

@ -12,7 +12,7 @@ use cookie_storage::CookieStorage;
use cookie;
use mime_classifier::MIMEClassifier;
use net_traits::{ControlMsg, LoadData, LoadResponse, ResponseSenders, LoadConsumer};
use net_traits::{ControlMsg, LoadData, LoadResponse, LoadConsumer};
use net_traits::{Metadata, ProgressMsg, ResourceTask, AsyncResponseTarget, ResponseAction};
use net_traits::ProgressMsg::Done;
use util::opts;
@ -81,19 +81,19 @@ impl ProgressSender {
}
/// For use by loaders in responding to a Load message.
pub fn start_sending(start_chan: ResponseSenders, metadata: Metadata) -> ProgressSender {
pub fn start_sending(start_chan: LoadConsumer, metadata: Metadata) -> ProgressSender {
start_sending_opt(start_chan, metadata).ok().unwrap()
}
/// For use by loaders in responding to a Load message that allows content sniffing.
pub fn start_sending_sniffed(start_chan: ResponseSenders, metadata: Metadata,
pub fn start_sending_sniffed(start_chan: LoadConsumer, metadata: Metadata,
classifier: Arc<MIMEClassifier>, partial_body: &Vec<u8>)
-> ProgressSender {
start_sending_sniffed_opt(start_chan, metadata, classifier, partial_body).ok().unwrap()
}
/// For use by loaders in responding to a Load message that allows content sniffing.
pub fn start_sending_sniffed_opt(start_chan: ResponseSenders, mut metadata: Metadata,
pub fn start_sending_sniffed_opt(start_chan: LoadConsumer, mut metadata: Metadata,
classifier: Arc<MIMEClassifier>, partial_body: &Vec<u8>)
-> Result<ProgressSender, ()> {
if opts::get().sniff_mime_types {
@ -116,9 +116,9 @@ pub fn start_sending_sniffed_opt(start_chan: ResponseSenders, mut metadata: Meta
}
/// For use by loaders in responding to a Load message.
pub fn start_sending_opt(start_chan: ResponseSenders, metadata: Metadata) -> Result<ProgressSender, ()> {
pub fn start_sending_opt(start_chan: LoadConsumer, metadata: Metadata) -> Result<ProgressSender, ()> {
match start_chan {
ResponseSenders::Channel(start_chan) => {
LoadConsumer::Channel(start_chan) => {
let (progress_chan, progress_port) = channel();
let result = start_chan.send(LoadResponse {
metadata: metadata,
@ -129,7 +129,7 @@ pub fn start_sending_opt(start_chan: ResponseSenders, metadata: Metadata) -> Res
Err(_) => Err(())
}
}
ResponseSenders::Listener(target) => {
LoadConsumer::Listener(target) => {
target.invoke_with_listener(ResponseAction::HeadersAvailable(metadata));
Ok(ProgressSender::Listener(target))
}
@ -238,14 +238,13 @@ impl ResourceManager {
self.user_agent.as_ref().map(|ua| load_data.headers.set(UserAgent(ua.clone())));
fn from_factory(factory: fn(LoadData, ResponseSenders, Arc<MIMEClassifier>))
-> Box<Invoke<(LoadData, ResponseSenders, Arc<MIMEClassifier>)> + Send> {
fn from_factory(factory: fn(LoadData, LoadConsumer, Arc<MIMEClassifier>))
-> Box<Invoke<(LoadData, LoadConsumer, Arc<MIMEClassifier>)> + Send> {
box move |(load_data, senders, classifier)| {
factory(load_data, senders, classifier)
}
}
let senders = ResponseSenders::from_consumer(consumer);
let loader = match &*load_data.url.scheme {
"file" => from_factory(file_loader::factory),
"http" | "https" | "view-source" => http_loader::factory(self.resource_task.clone()),
@ -253,13 +252,13 @@ impl ResourceManager {
"about" => from_factory(about_loader::factory),
_ => {
debug!("resource_task: no loader for scheme {}", load_data.url.scheme);
start_sending(senders, Metadata::default(load_data.url))
start_sending(consumer, Metadata::default(load_data.url))
.send(ProgressMsg::Done(Err("no loader for scheme".to_string()))).unwrap();
return
}
};
debug!("resource_task: loading url: {}", load_data.url.serialize());
loader.invoke((load_data, senders, self.mime_classifier.clone()));
loader.invoke((load_data, consumer, self.mime_classifier.clone()));
}
}

14
components/net_traits/lib.rs
View file

@ -203,20 +203,6 @@ pub enum CookieSource {
NonHTTP,
}
pub enum ResponseSenders {
Channel(Sender<LoadResponse>),
Listener(Box<AsyncResponseTarget+ Send>),
}
impl ResponseSenders {
pub fn from_consumer(consumer: LoadConsumer) -> ResponseSenders {
match consumer {
LoadConsumer::Channel(c) => ResponseSenders::Channel(c),
LoadConsumer::Listener(l) => ResponseSenders::Listener(l),
}
}
}
/// Messages sent in response to a `Load` message
#[derive(PartialEq,Debug)]
pub enum ProgressMsg {

2
tests/unit/net/data_loader.rs
View file

@ -4,7 +4,7 @@
extern crate hyper;
use net_traits::ResponseSenders::Channel;
use net_traits::LoadConsumer::Channel;
use net_traits::LoadData;
use net_traits::ProgressMsg::{Payload, Done};
use self::hyper::header::ContentType;

8
tests/unit/net/image_cache_task.rs
View file

@ -7,7 +7,7 @@ use net_traits::image_cache_task::ImageResponseMsg::*;
use net_traits::image_cache_task::Msg::*;
use net::resource_task::{start_sending, ProgressSender};
use net_traits::{ControlMsg, Metadata, ResourceTask, ResponseSenders};
use net_traits::{ControlMsg, Metadata, ResourceTask};
use net_traits::image_cache_task::{ImageCacheTask, ImageCacheTaskClient, ImageResponseMsg, Msg};
use net_traits::ProgressMsg::{Payload, Done};
use profile::time;
@ -111,7 +111,7 @@ fn mock_resource_task<T: Closure + Send + 'static>(on_load: Box<T>) -> ResourceT
loop {
match port.recv().unwrap() {
ControlMsg::Load(_, consumer) => {
let chan = start_sending(ResponseSenders::from_consumer(consumer), Metadata::default(
let chan = start_sending(consumer, Metadata::default(
Url::parse("file:///fake").unwrap()));
on_load.invoke(chan);
}
@ -281,7 +281,7 @@ fn should_not_request_image_from_resource_task_if_image_is_already_available() {
loop {
match port.recv().unwrap() {
ControlMsg::Load(_, consumer) => {
let chan = start_sending(ResponseSenders::from_consumer(consumer), Metadata::default(
let chan = start_sending(consumer, Metadata::default(
Url::parse("file:///fake").unwrap()));
chan.send(Payload(test_image_bin())).unwrap();
chan.send(Done(Ok(()))).unwrap();
@ -330,7 +330,7 @@ fn should_not_request_image_from_resource_task_if_image_fetch_already_failed() {
loop {
match port.recv().unwrap() {
ControlMsg::Load(_, consumer) => {
let chan = start_sending(ResponseSenders::from_consumer(consumer), Metadata::default(
let chan = start_sending(consumer, Metadata::default(
Url::parse("file:///fake").unwrap()));
chan.send(Payload(test_image_bin())).unwrap();
chan.send(Done(Err("".to_string()))).unwrap();