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>; 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| { do spawn_listener::<ControlMsg> |from_master| {
Content(layout_task, compositor, from_master, resource_task).start(); 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 compositor: C;
let layout_task: LayoutTask; let layout_task: LayoutTask;
let from_master: comm::Port<ControlMsg>; let from_master: comm::Port<ControlMsg>;
@ -84,7 +84,7 @@ struct Content<C:Compositor send copy> {
let resource_task: ResourceTask; 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) { resource_task: ResourceTask) {
self.layout_task = layout_task; self.layout_task = layout_task;
self.compositor = compositor; self.compositor = compositor;

100
src/servo/engine.rs
View file

@ -1,3 +1,5 @@
export EngineTask, EngineProto;
import gfx::compositor::Compositor; import gfx::compositor::Compositor;
import gfx::render_task; import gfx::render_task;
import render_task::RenderTask; import render_task::RenderTask;
@ -18,17 +20,10 @@ fn macros() {
include!("macros.rs"); include!("macros.rs");
} }
struct Engine<C:Compositor send copy> { type EngineTask = EngineProto::client::Running;
let compositor: C;
let render_task: RenderTask; fn EngineTask<C: Compositor send copy>(+compositor: C) -> EngineTask {
let resource_task: ResourceTask; do spawn_service(EngineProto::init) |request, move compositor| {
let image_cache_task: ImageCacheTask;
let layout_task: LayoutTask;
let content_task: ContentTask;
new(+compositor: C) {
self.compositor = compositor;
let render_task = RenderTask(compositor); let render_task = RenderTask(compositor);
let resource_task = ResourceTask(); let resource_task = ResourceTask();
@ -36,46 +31,59 @@ struct Engine<C:Compositor send copy> {
let layout_task = LayoutTask(render_task, image_cache_task); let layout_task = LayoutTask(render_task, image_cache_task);
let content_task = ContentTask(layout_task, compositor, resource_task); let content_task = ContentTask(layout_task, compositor, resource_task);
self.render_task = render_task; Engine {
self.resource_task = resource_task; compositor: compositor,
self.image_cache_task = image_cache_task; render_task: render_task,
self.layout_task = layout_task; resource_task: resource_task,
self.content_task = content_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 { struct Engine<C:Compositor> {
select! { compositor: C;
request => { render_task: RenderTask;
LoadURL(url) -> next { resource_task: ResourceTask;
// TODO: change copy to move once we have match move image_cache_task: ImageCacheTask;
let url = move_ref!(url); layout_task: LayoutTask;
if url.path.ends_with(".js") { content_task: ContentTask;
self.content_task.send(content_task::ExecuteMsg(url)) }
} else {
self.content_task.send(content_task::ParseMsg(url)) impl<C: Compositor> Engine<C> {
} fn run(+request: EngineProto::server::Running) {
request = next; import EngineProto::*;
}, let mut request = request;
Exit -> channel { loop {
self.content_task.send(content_task::ExitMsg); select! {
self.layout_task.send(layout_task::ExitMsg); request => {
LoadURL(url) -> next {
let (response_chan, response_port) = pipes::stream(); // TODO: change copy to move once we have match move
self.render_task.send(render_task::ExitMsg(response_chan)); let url = move_ref!(url);
response_port.recv(); if url.path.ends_with(".js") {
self.content_task.send(content_task::ExecuteMsg(url))
self.image_cache_task.exit(); } else {
self.resource_task.send(resource_task::Exit); self.content_task.send(content_task::ParseMsg(url))
server::Exited(channel);
break
} }
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>; 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>| { do task::spawn_listener |po: comm::Port<Msg>| {
let (draw_target_ch, draw_target_po) = pipes::stream(); let (draw_target_ch, draw_target_po) = pipes::stream();
let mut draw_target_ch = draw_target_ch; 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 platform::osmain;
import osmain::{OSMain, AddKeyHandler}; import osmain::{OSMain, AddKeyHandler};
import opts::{Opts, Screen, Png}; import opts::{Opts, Screen, Png};
import engine::Engine; import engine::{EngineTask, EngineProto};
import engine::EngineProto;
import url_to_str = std::net::url::to_str; import url_to_str = std::net::url::to_str;
import util::url::make_url; import util::url::make_url;
@ -39,14 +38,13 @@ fn run_pipeline_screen(urls: ~[~str]) {
osmain.send(AddKeyHandler(keypress_to_engine)); osmain.send(AddKeyHandler(keypress_to_engine));
// Create a serve instance // Create a serve instance
let engine = Engine(osmain); let mut engine_task = some(EngineTask(osmain));
let mut engine_chan = some(engine.start());
for urls.each |filename| { for urls.each |filename| {
let url = make_url(filename, none); let url = make_url(filename, none);
#debug["master: Sending url `%s`", url_to_str(url)]; #debug["master: Sending url `%s`", url_to_str(url)];
engine_chan = engine_task =
some(EngineProto::client::LoadURL(swap_unwrap(&mut engine_chan), some(EngineProto::client::LoadURL(swap_unwrap(&mut engine_task),
url)); url));
#debug["master: Waiting for keypress"]; #debug["master: Waiting for keypress"];
@ -58,8 +56,8 @@ fn run_pipeline_screen(urls: ~[~str]) {
// Shut everything down // Shut everything down
#debug["master: Shut down"]; #debug["master: Shut down"];
let engine_chan = EngineProto::client::Exit(option::unwrap(engine_chan)); let engine_task = EngineProto::client::Exit(option::unwrap(engine_task));
pipes::recv(engine_chan); pipes::recv(engine_task);
osmain.send(osmain::Exit); osmain.send(osmain::Exit);
} }
@ -74,18 +72,16 @@ fn run_pipeline_png(-url: ~str, outfile: ~str) {
listen(|pngdata_from_compositor| { listen(|pngdata_from_compositor| {
let compositor = PngCompositor(pngdata_from_compositor); let compositor = PngCompositor(pngdata_from_compositor);
let engine = Engine(compositor); let engine_task = EngineTask(compositor);
let engine_chan = engine.start(); let engine_task = EngineProto::client::LoadURL(engine_task, make_url(url, none));
let engine_chan =
EngineProto::client::LoadURL(engine_chan, make_url(url, none));
match buffered_file_writer(outfile) { match buffered_file_writer(outfile) {
ok(writer) => writer.write(pngdata_from_compositor.recv()), ok(writer) => writer.write(pngdata_from_compositor.recv()),
err(e) => fail e err(e) => fail e
} }
let engine_chan = EngineProto::client::Exit(engine_chan); let engine_task = EngineProto::client::Exit(engine_task);
pipes::recv(engine_chan); pipes::recv(engine_task);
compositor.send(png_compositor::Exit); compositor.send(png_compositor::Exit);
}) })
} }