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

Hard-code resource task loaders. They never change.

Browse source
This commit is contained in:
Simon Sapin 2014-07-19 12:22:22 +01:00
parent dc49f4fda6
commit 709504e1f9
1 changed files with 14 additions and 66 deletions
Download patch file Download diff file Expand all files Collapse all files

80
src/components/net/resource_task.rs
View file

@ -162,40 +162,27 @@ each URL scheme
*/
type LoaderTaskFactory = extern "Rust" fn() -> LoaderTask;
/// Create a ResourceTask with the default loaders
/// Create a ResourceTask
pub fn new_resource_task() -> ResourceTask {
let loaders = vec!(
("file".to_string(), file_loader::factory),
("http".to_string(), http_loader::factory),
("data".to_string(), data_loader::factory),
);
create_resource_task_with_loaders(loaders)
}
fn create_resource_task_with_loaders(loaders: Vec<(String, LoaderTaskFactory)>) -> ResourceTask {
let (setup_chan, setup_port) = channel();
let builder = TaskBuilder::new().named("ResourceManager");
builder.spawn(proc() {
let (chan, port) = channel();
setup_chan.send(chan);
ResourceManager::new(port, loaders).start();
ResourceManager::new(port).start();
});
setup_port.recv()
}
struct ResourceManager {
from_client: Receiver<ControlMsg>,
/// Per-scheme resource loaders
loaders: Vec<(String, LoaderTaskFactory)>,
}
impl ResourceManager {
fn new(from_client: Receiver<ControlMsg>, loaders: Vec<(String, LoaderTaskFactory)>)
-> ResourceManager {
fn new(from_client: Receiver<ControlMsg>) -> ResourceManager {
ResourceManager {
from_client : from_client,
loaders : loaders,
}
}
}
@ -216,29 +203,19 @@ impl ResourceManager {
}
fn load(&self, load_data: LoadData, start_chan: Sender<LoadResponse>) {
match self.get_loader_factory(&load_data) {
Some(loader_factory) => {
debug!("resource_task: loading url: {:s}", load_data.url.serialize());
loader_factory(load_data, start_chan);
}
None => {
let loader = match load_data.url.scheme.as_slice() {
"file" => file_loader::factory(),
"http" => http_loader::factory(),
"data" => data_loader::factory(),
_ => {
debug!("resource_task: no loader for scheme {:s}", load_data.url.scheme);
start_sending(start_chan, Metadata::default(load_data.url)).send(Done(Err("no loader for scheme".to_string())));
start_sending(start_chan, Metadata::default(load_data.url))
.send(Done(Err("no loader for scheme".to_string())));
return
}
}
}
fn get_loader_factory(&self, load_data: &LoadData) -> Option<LoaderTask> {
for scheme_loader in self.loaders.iter() {
match *scheme_loader {
(ref scheme, ref loader_factory) => {
if (*scheme) == load_data.url.scheme {
return Some((*loader_factory)());
}
}
}
}
return None;
};
debug!("resource_task: loading url: {:s}", load_data.url.serialize());
loader(load_data, start_chan);
}
}
@ -261,32 +238,3 @@ fn test_bad_scheme() {
}
resource_task.send(Exit);
}
#[cfg(test)]
static snicklefritz_payload: [u8, ..3] = [1, 2, 3];
#[cfg(test)]
fn snicklefritz_loader_factory() -> LoaderTask {
let f: LoaderTask = proc(load_data: LoadData, start_chan: Sender<LoadResponse>) {
let progress_chan = start_sending(start_chan, Metadata::default(load_data.url));
progress_chan.send(Payload(Vec::from_slice(snicklefritz_payload)));
progress_chan.send(Done(Ok(())));
};
f
}
#[test]
fn should_delegate_to_scheme_loader() {
let loader_factories = vec!(("snicklefritz".to_string(), snicklefritz_loader_factory));
let resource_task = create_resource_task_with_loaders(loader_factories);
let (start_chan, start) = channel();
let url = Url::parse("snicklefritz://heya").unwrap();
resource_task.send(Load(LoadData::new(url), start_chan));
let response = start.recv();
let progress = response.progress_port;
assert!(progress.recv() == Payload(Vec::from_slice(snicklefritz_payload)));
assert!(progress.recv() == Done(Ok(())));
resource_task.send(Exit);
}