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

Cleanup

Browse source
This commit is contained in:
Brian Anderson 2012-08-19 18:58:42 -07:00
parent 38565738fa
commit 1cfecd4ca8
4 changed files with 68 additions and 64 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/servo/content/content_task.rs
View file

@ -51,7 +51,7 @@ enum PingMsg {
type ContentTask = Chan<ControlMsg>;
fn ContentTask<S: Compositor send copy>(layout_task: LayoutTask, compositor: S, resource_task: ResourceTask) -> ContentTask {
fn ContentTask<S: Compositor send copy>(layout_task: LayoutTask, +compositor: S, resource_task: ResourceTask) -> ContentTask {
do spawn_listener::<ControlMsg> |from_master| {
Content(layout_task, compositor, from_master, resource_task).start();
}
@ -70,7 +70,7 @@ fn join_layout(scope: NodeScope, layout_task: LayoutTask) {
}
}
struct Content<C:Compositor send copy> {
struct Content<C:Compositor> {
let compositor: C;
let layout_task: LayoutTask;
let from_master: comm::Port<ControlMsg>;
@ -84,7 +84,7 @@ struct Content<C:Compositor send copy> {
let resource_task: ResourceTask;
new(layout_task: LayoutTask, compositor: C, from_master: Port<ControlMsg>,
new(layout_task: LayoutTask, +compositor: C, from_master: Port<ControlMsg>,
resource_task: ResourceTask) {
self.layout_task = layout_task;
self.compositor = compositor;

96
src/servo/engine.rs
View file

@ -1,3 +1,5 @@
export EngineTask, EngineProto;
import gfx::compositor::Compositor;
import gfx::render_task;
import render_task::RenderTask;
@ -18,17 +20,10 @@ fn macros() {
include!("macros.rs");
}
struct Engine<C:Compositor send copy> {
let compositor: C;
type EngineTask = EngineProto::client::Running;
let render_task: RenderTask;
let resource_task: ResourceTask;
let image_cache_task: ImageCacheTask;
let layout_task: LayoutTask;
let content_task: ContentTask;
new(+compositor: C) {
self.compositor = compositor;
fn EngineTask<C: Compositor send copy>(+compositor: C) -> EngineTask {
do spawn_service(EngineProto::init) |request, move compositor| {
let render_task = RenderTask(compositor);
let resource_task = ResourceTask();
@ -36,46 +31,59 @@ struct Engine<C:Compositor send copy> {
let layout_task = LayoutTask(render_task, image_cache_task);
let content_task = ContentTask(layout_task, compositor, resource_task);
self.render_task = render_task;
self.resource_task = resource_task;
self.image_cache_task = image_cache_task;
self.layout_task = layout_task;
self.content_task = content_task;
Engine {
compositor: compositor,
render_task: render_task,
resource_task: resource_task,
image_cache_task: image_cache_task,
layout_task: layout_task,
content_task: content_task,
}.run(request);
}
}
fn start() -> EngineProto::client::Running {
do spawn_service(EngineProto::init) |request| {
import EngineProto::*;
let mut request = request;
loop {
select! {
request => {
LoadURL(url) -> next {
// TODO: change copy to move once we have match move
let url = move_ref!(url);
if url.path.ends_with(".js") {
self.content_task.send(content_task::ExecuteMsg(url))
} else {
self.content_task.send(content_task::ParseMsg(url))
}
request = next;
},
struct Engine<C:Compositor> {
compositor: C;
render_task: RenderTask;
resource_task: ResourceTask;
image_cache_task: ImageCacheTask;
layout_task: LayoutTask;
content_task: ContentTask;
}
Exit -> channel {
self.content_task.send(content_task::ExitMsg);
self.layout_task.send(layout_task::ExitMsg);
impl<C: Compositor> Engine<C> {
fn run(+request: EngineProto::server::Running) {
import EngineProto::*;
let mut request = request;
let (response_chan, response_port) = pipes::stream();
self.render_task.send(render_task::ExitMsg(response_chan));
response_port.recv();
self.image_cache_task.exit();
self.resource_task.send(resource_task::Exit);
server::Exited(channel);
break
loop {
select! {
request => {
LoadURL(url) -> next {
// TODO: change copy to move once we have match move
let url = move_ref!(url);
if url.path.ends_with(".js") {
self.content_task.send(content_task::ExecuteMsg(url))
} else {
self.content_task.send(content_task::ParseMsg(url))
}
request = next;
},
Exit -> channel {
self.content_task.send(content_task::ExitMsg);
self.layout_task.send(layout_task::ExitMsg);
let (response_chan, response_port) = pipes::stream();
self.render_task.send(render_task::ExitMsg(response_chan));
response_port.recv();
self.image_cache_task.exit();
self.resource_task.send(resource_task::Exit);
server::Exited(channel);
break
}
}
}

2
src/servo/gfx/render_task.rs
View file

@ -30,7 +30,7 @@ enum Msg {
type RenderTask = comm::Chan<Msg>;
fn RenderTask<C: Compositor send copy>(compositor: C) -> RenderTask {
fn RenderTask<C: Compositor send>(+compositor: C) -> RenderTask {
do task::spawn_listener |po: comm::Port<Msg>| {
let (draw_target_ch, draw_target_po) = pipes::stream();
let mut draw_target_ch = draw_target_ch;

24
src/servo/servo.rs
View file

@ -3,8 +3,7 @@ import option::swap_unwrap;
import platform::osmain;
import osmain::{OSMain, AddKeyHandler};
import opts::{Opts, Screen, Png};
import engine::Engine;
import engine::EngineProto;
import engine::{EngineTask, EngineProto};
import url_to_str = std::net::url::to_str;
import util::url::make_url;
@ -39,14 +38,13 @@ fn run_pipeline_screen(urls: ~[~str]) {
osmain.send(AddKeyHandler(keypress_to_engine));
// Create a serve instance
let engine = Engine(osmain);
let mut engine_chan = some(engine.start());
let mut engine_task = some(EngineTask(osmain));
for urls.each |filename| {
let url = make_url(filename, none);
#debug["master: Sending url `%s`", url_to_str(url)];
engine_chan =
some(EngineProto::client::LoadURL(swap_unwrap(&mut engine_chan),
engine_task =
some(EngineProto::client::LoadURL(swap_unwrap(&mut engine_task),
url));
#debug["master: Waiting for keypress"];
@ -58,8 +56,8 @@ fn run_pipeline_screen(urls: ~[~str]) {
// Shut everything down
#debug["master: Shut down"];
let engine_chan = EngineProto::client::Exit(option::unwrap(engine_chan));
pipes::recv(engine_chan);
let engine_task = EngineProto::client::Exit(option::unwrap(engine_task));
pipes::recv(engine_task);
osmain.send(osmain::Exit);
}
@ -74,18 +72,16 @@ fn run_pipeline_png(-url: ~str, outfile: ~str) {
listen(|pngdata_from_compositor| {
let compositor = PngCompositor(pngdata_from_compositor);
let engine = Engine(compositor);
let engine_chan = engine.start();
let engine_chan =
EngineProto::client::LoadURL(engine_chan, make_url(url, none));
let engine_task = EngineTask(compositor);
let engine_task = EngineProto::client::LoadURL(engine_task, make_url(url, none));
match buffered_file_writer(outfile) {
ok(writer) => writer.write(pngdata_from_compositor.recv()),
err(e) => fail e
}
let engine_chan = EngineProto::client::Exit(engine_chan);
pipes::recv(engine_chan);
let engine_task = EngineProto::client::Exit(engine_task);
pipes::recv(engine_task);
compositor.send(png_compositor::Exit);
})
}