Move osmain task to osmain module

src/servo/gfx/compositor.rs

@@ -8,10 +8,10 @@ enum msg {
     exit(comm::chan<()>)
 }
 
-fn compositor(osmain_ch: comm::chan<osmain_msg>) -> comm::chan<msg> {
+fn compositor(osmain_ch: comm::chan<osmain::msg>) -> comm::chan<msg> {
     task::spawn_listener {|po|
         let draw_target_po = comm::port();
-        comm::send(osmain_ch, om_get_draw_target(comm::chan(draw_target_po)));
+        comm::send(osmain_ch, osmain::get_draw_target(comm::chan(draw_target_po)));
         let draw_target = comm::recv(draw_target_po);
 
         let black_color = {
@@ -77,7 +77,7 @@ fn compositor(osmain_ch: comm::chan<osmain_msg>) -> comm::chan<msg> {
                     unsafe { unsafe::reinterpret_cast(green_pattern) }
                 );
                 let draw_po = comm::port();
-                comm::send(osmain_ch, om_draw(comm::chan(draw_po)));
+                comm::send(osmain_ch, osmain::draw(comm::chan(draw_po)));
                 comm::recv(draw_po);
               }
               exit(response_ch) {

src/servo/osmain.rs

@@ -0,0 +1,95 @@
+enum msg {
+    get_draw_target(comm::chan<AzDrawTargetRef>),
+    add_key_handler(comm::chan<()>),
+    draw(comm::chan<()>),
+    exit
+}
+
+fn osmain() -> comm::chan<msg> {
+    on_osmain::<msg> {|po|
+        let mut key_handlers = [];
+
+        sdl::init([
+            sdl::init_video
+        ]);
+        let screen = sdl::video::set_video_mode(
+            800, 600, 32,
+            [sdl::video::swsurface],
+            [sdl::video::doublebuf]);
+        assert !screen.is_null();
+        let sdl_surf = sdl::video::create_rgb_surface(
+            [sdl::video::swsurface],
+            800, 600, 32,
+            0x00FF0000u32,
+            0x0000FF00u32,
+            0x000000FFu32,
+            0x00000000u32
+            );
+        assert !sdl_surf.is_null();
+        sdl::video::lock_surface(sdl_surf);
+        let cairo_surf = unsafe {
+            cairo_image_surface_create_for_data(
+                unsafe::reinterpret_cast((*sdl_surf).pixels),
+                cairo::CAIRO_FORMAT_RGB24,
+                (*sdl_surf).w,
+                (*sdl_surf).h,
+                (*sdl_surf).pitch as libc::c_int
+            )
+        };
+        assert !cairo_surf.is_null();
+        let azure_target = AzCreateDrawTargetForCairoSurface(cairo_surf);
+        assert !azure_target.is_null();
+
+        loop {
+            sdl::event::poll_event {|event|
+                alt event {
+                  sdl::event::keydown_event(_) {
+                    key_handlers.iter {|key_ch|
+                        comm::send(key_ch, ())
+                    }
+                  }
+                  _ { }
+                }
+            }
+
+            // Handle messages
+            if comm::peek(po) {
+                alt check comm::recv(po) {
+                  add_key_handler(key_ch) {
+                    key_handlers += [key_ch];
+                  }
+                  get_draw_target(response_ch) {
+                    comm::send(response_ch, azure_target);
+                  }
+                  draw(response_ch) {
+                    sdl::video::unlock_surface(sdl_surf);
+                    sdl::video::blit_surface(sdl_surf, ptr::null(),
+                                             screen, ptr::null());
+                    sdl::video::lock_surface(sdl_surf);
+                    sdl::video::flip(screen);
+                    comm::send(response_ch, ());
+                  }
+                  exit { break; }
+                }
+            }
+        }
+        AzReleaseDrawTarget(azure_target);
+        cairo_surface_destroy(cairo_surf);
+        sdl::video::unlock_surface(sdl_surf);
+        sdl::quit();
+    }
+}
+
+// A function for spawning into the platform's main thread
+fn on_osmain<T: send>(f: fn~(comm::port<T>)) -> comm::chan<T> {
+    let builder = task::builder();
+    let opts = {
+        sched: some({
+            mode: task::osmain,
+            native_stack_size: none
+        })
+        with task::get_opts(builder)
+    };
+    task::set_opts(builder, opts);
+    ret task::run_listener(builder, f);
+}

src/servo/servo.rc

@@ -38,3 +38,5 @@ mod widget {
 mod util {
     mod tree;
 }
+
+mod osmain;

src/servo/servo.rs

@@ -11,102 +11,9 @@ fn sleep() {
     }
 }
 
-// A function for spawning into the platform's main thread
-fn on_osmain<T: send>(f: fn~(comm::port<T>)) -> comm::chan<T> {
-    let builder = task::builder();
-    let opts = {
-        sched: some({
-            mode: task::osmain,
-            native_stack_size: none
-        })
-        with task::get_opts(builder)
-    };
-    task::set_opts(builder, opts);
-    ret task::run_listener(builder, f);
-}
-
-// Messages to the platform event handler task
-enum osmain_msg {
-    om_get_draw_target(comm::chan<AzDrawTargetRef>),
-    om_add_key_handler(comm::chan<()>),
-    om_draw(comm::chan<()>),
-    om_exit
-}
-
 fn main() {
     // The platform event handler thread
-    let osmain_ch = on_osmain::<osmain_msg> {|po|
+    let osmain_ch = osmain::osmain();
-        let mut key_handlers = [];
-
-        sdl::init([
-            sdl::init_video
-        ]);
-        let screen = sdl::video::set_video_mode(
-            800, 600, 32,
-            [sdl::video::swsurface],
-            [sdl::video::doublebuf]);
-        assert !screen.is_null();
-        let sdl_surf = sdl::video::create_rgb_surface(
-            [sdl::video::swsurface],
-            800, 600, 32,
-            0x00FF0000u32,
-            0x0000FF00u32,
-            0x000000FFu32,
-            0x00000000u32
-            );
-        assert !sdl_surf.is_null();
-        sdl::video::lock_surface(sdl_surf);
-        let cairo_surf = unsafe {
-            cairo_image_surface_create_for_data(
-                unsafe::reinterpret_cast((*sdl_surf).pixels),
-                cairo::CAIRO_FORMAT_RGB24,
-                (*sdl_surf).w,
-                (*sdl_surf).h,
-                (*sdl_surf).pitch as libc::c_int
-            )
-        };
-        assert !cairo_surf.is_null();
-        let azure_target = AzCreateDrawTargetForCairoSurface(cairo_surf);
-        assert !azure_target.is_null();
-
-        loop {
-            sdl::event::poll_event {|event|
-                alt event {
-                  sdl::event::keydown_event(_) {
-                    key_handlers.iter {|key_ch|
-                        comm::send(key_ch, ())
-                    }
-                  }
-                  _ { }
-                }
-            }
-
-            // Handle messages
-            if comm::peek(po) {
-                alt check comm::recv(po) {
-                  om_add_key_handler(key_ch) {
-                    key_handlers += [key_ch];
-                  }
-                  om_get_draw_target(response_ch) {
-                    comm::send(response_ch, azure_target);
-                  }
-                  om_draw(response_ch) {
-                    sdl::video::unlock_surface(sdl_surf);
-                    sdl::video::blit_surface(sdl_surf, ptr::null(),
-                                             screen, ptr::null());
-                    sdl::video::lock_surface(sdl_surf);
-                    sdl::video::flip(screen);
-                    comm::send(response_ch, ());
-                  }
-                  exit { break; }
-                }
-            }
-        }
-        AzReleaseDrawTarget(azure_target);
-        cairo_surface_destroy(cairo_surf);
-        sdl::video::unlock_surface(sdl_surf);
-        sdl::quit();
-    };
 
     // The drawing task
     let draw_ch = gfx::compositor::compositor(osmain_ch);
@@ -145,7 +52,7 @@ fn main() {
     // The keyboard handler
     task::spawn {||
         let key_po = comm::port();
-        comm::send(osmain_ch, om_add_key_handler(comm::chan(key_po)));
+        comm::send(osmain_ch, osmain::add_key_handler(comm::chan(key_po)));
         loop {
             alt comm::recv(key_po) {
               _ {
@@ -153,7 +60,7 @@ fn main() {
                 let draw_exit_confirm_po = comm::port();
                 comm::send(draw_ch, gfx::compositor::exit(comm::chan(draw_exit_confirm_po)));
                 comm::recv(draw_exit_confirm_po);
-                comm::send(osmain_ch, om_exit);
+                comm::send(osmain_ch, osmain::exit);
                 break;
               }
             }