Add link following and refactor the profiler.

src/components/gfx/font.rs

@@ -18,6 +18,8 @@ use azure::scaled_font::ScaledFont;
 use azure::azure_hl::{BackendType, ColorPattern};
 use geom::{Point2D, Rect, Size2D};
 
+use servo_util::time::ProfilerChan;
+
 // FontHandle encapsulates access to the platform's font API,
 // e.g. quartz, FreeType. It provides access to metrics and tables
 // needed by the text shaper as well as access to the underlying font
@@ -210,13 +212,15 @@ pub struct Font {
     style: UsedFontStyle,
     metrics: FontMetrics,
     backend: BackendType,
+    profiler_chan: ProfilerChan,
 }
 
 pub impl Font {
     fn new_from_buffer(ctx: &FontContext,
                        buffer: ~[u8],
                        style: &SpecifiedFontStyle,
-                       backend: BackendType)
+                       backend: BackendType,
+                       profiler_chan: ProfilerChan)
             -> Result<@mut Font, ()> {
         let handle = FontHandleMethods::new_from_buffer(&ctx.handle, buffer, style);
         let handle: FontHandle = if handle.is_ok() {
@@ -235,11 +239,13 @@ pub impl Font {
             style: copy *style,
             metrics: metrics,
             backend: backend,
+            profiler_chan: profiler_chan,
         });
     }
 
     fn new_from_adopted_handle(_fctx: &FontContext, handle: FontHandle,
-                               style: &SpecifiedFontStyle, backend: BackendType) -> @mut Font {
+                               style: &SpecifiedFontStyle, backend: BackendType,
+                               profiler_chan: ProfilerChan) -> @mut Font {
         let metrics = handle.get_metrics();
 
         @mut Font {
@@ -249,19 +255,21 @@ pub impl Font {
             style: copy *style,
             metrics: metrics,
             backend: backend,
+            profiler_chan: profiler_chan,
         }
     }
 
     fn new_from_existing_handle(fctx: &FontContext, handle: &FontHandle,
-                                style: &SpecifiedFontStyle, backend: BackendType) -> Result<@mut Font,()> {
+                                style: &SpecifiedFontStyle, backend: BackendType,
+                                profiler_chan: ProfilerChan) -> Result<@mut Font,()> {
 
         // TODO(Issue #179): convert between specified and used font style here?
         let styled_handle = match handle.clone_with_style(&fctx.handle, style) {
             Ok(result) => result,
             Err(()) => return Err(())
         };
 
-        return Ok(Font::new_from_adopted_handle(fctx, styled_handle, style, backend));
+        return Ok(Font::new_from_adopted_handle(fctx, styled_handle, style, backend, profiler_chan));
     }
 
     priv fn get_shaper(@mut self) -> @Shaper {

src/components/gfx/font_context.rs

@@ -40,17 +40,18 @@ pub struct FontContext {
     handle: FontContextHandle,
     backend: BackendType,
     generic_fonts: HashMap<~str,~str>,
+    profiler_chan: ProfilerChan,
 }
 
 #[allow(non_implicitly_copyable_typarams)]
 pub impl<'self> FontContext {
     fn new(backend: BackendType,
            needs_font_list: bool,
-           prof_chan: ProfilerChan)
+           profiler_chan: ProfilerChan)
            -> FontContext {
         let handle = FontContextHandle::new();
         let font_list = if needs_font_list { 
-                            Some(FontList::new(&handle, prof_chan.clone())) }
+                            Some(FontList::new(&handle, profiler_chan.clone())) }
                         else { None };
 
         // TODO: Allow users to specify these.
@@ -69,6 +70,7 @@ pub impl<'self> FontContext {
             handle: handle,
             backend: backend,
             generic_fonts: generic_fonts,
+            profiler_chan: profiler_chan,
         }
     }
 
@@ -125,7 +127,8 @@ pub impl<'self> FontContext {
             for result.each |font_entry| {
                 found = true;
                 // TODO(Issue #203): route this instantion through FontContext's Font instance cache.
-                let instance = Font::new_from_existing_handle(self, &font_entry.handle, style, self.backend);
+                let instance = Font::new_from_existing_handle(self, &font_entry.handle, style, self.backend,
+                                                              self.profiler_chan.clone());
                 do result::iter(&instance) |font: &@mut Font| { fonts.push(*font); }
             };
 
@@ -163,7 +166,8 @@ pub impl<'self> FontContext {
                     Ok(Font::new_from_adopted_handle(self,
                                                      handle,
                                                      &desc.style,
-                                                     self.backend))
+                                                     self.backend,
+                                                     self.profiler_chan.clone()))
                 })
             }
         };

src/components/gfx/opts.rs

@@ -13,6 +13,7 @@ pub struct Opts {
     render_backend: BackendType,
     n_render_threads: uint,
     tile_size: uint,
+    profiler_period: Option<f64>,
 }
 
 #[allow(non_implicitly_copyable_typarams)]
@@ -26,13 +27,13 @@ pub fn from_cmdline_args(args: &[~str]) -> Opts {
         getopts::optopt(~"r"),  // rendering backend
         getopts::optopt(~"s"),  // size of tiles
         getopts::optopt(~"t"),  // threads to render with
+        getopts::optflagopt(~"p"),  // profiler flag and output interval
     ];
 
     let opt_match = match getopts::getopts(args, opts) {
       result::Ok(m) => { copy m }
       result::Err(f) => { fail!(getopts::fail_str(copy f)) }
     };
-
     let urls = if opt_match.free.is_empty() {
         fail!(~"servo asks that you provide 1 or more URLs")
     } else {
@@ -68,10 +69,18 @@ pub fn from_cmdline_args(args: &[~str]) -> Opts {
         None => 1,      // FIXME: Number of cores.
     };
 
+    let profiler_period: Option<f64> =
+        // if only flag is present, default to 5 second period
+        match getopts::opt_default(&opt_match, ~"p", ~"5") {
+        Some(period) => Some(f64::from_str(period).get()),
+        None => None,
+    };
+
     Opts {
         urls: urls,
         render_backend: render_backend,
         n_render_threads: n_render_threads,
         tile_size: tile_size,
+        profiler_period: profiler_period,
     }
 }

src/components/gfx/render_task.rs

@@ -18,9 +18,7 @@ use core::task::SingleThreaded;
 use std::task_pool::TaskPool;
 use servo_net::util::spawn_listener;
 
-use servo_util::time::ProfilerChan;
-use servo_util::time::profile;
-use servo_util::time::time;
+use servo_util::time::{ProfilerChan, profile};
 use servo_util::time;
 
 pub enum Msg {
@@ -124,7 +122,7 @@ impl<C: Compositor + Owned> Renderer<C> {
 
     fn render(&mut self, render_layer: RenderLayer) {
         debug!("renderer: rendering");
-        do time("rendering") {
+        do profile(time::RenderingCategory, self.profiler_chan.clone()) {
             let layer_buffer_set = do render_layers(&render_layer,
                                                     &self.opts,
                                                     self.profiler_chan.clone()) |render_layer_ref,

src/components/gfx/text/text_run.rs

@@ -6,6 +6,8 @@ use font_context::FontContext;
 use geometry::Au;
 use text::glyph::{BreakTypeNormal, GlyphStore};
 use font::{Font, FontDescriptor, RunMetrics};
+use servo_util::time;
+use servo_util::time::profile;
 use servo_util::range::Range;
 
 /// A text run.
@@ -44,7 +46,9 @@ pub impl<'self> TextRun {
     fn new(font: @mut Font, text: ~str, underline: bool) -> TextRun {
         let mut glyph_store = GlyphStore::new(str::char_len(text));
         TextRun::compute_potential_breaks(text, &mut glyph_store);
-        font.shape_text(text, &mut glyph_store);
+        do profile(time::LayoutShapingCategory, font.profiler_chan.clone()) {
+            font.shape_text(text, &mut glyph_store);
+        }
 
         let run = TextRun {
             text: text,

src/components/main/compositing/mod.rs

@@ -5,8 +5,10 @@
 use compositing::resize_rate_limiter::ResizeRateLimiter;
 use platform::{Application, Window};
 use script::script_task::{LoadMsg, ScriptMsg, SendEventMsg};
-use windowing::{ApplicationMethods, WindowMethods};
-use script::dom::event::ClickEvent;
+use windowing::{ApplicationMethods, WindowMethods, WindowMouseEvent, WindowClickEvent};
+use windowing::{WindowMouseDownEvent, WindowMouseUpEvent};
+
+use script::dom::event::{Event, ClickEvent, MouseDownEvent, MouseUpEvent};
 
 use azure::azure_hl::{DataSourceSurface, DrawTarget, SourceSurfaceMethods};
 use core::cell::Cell;
@@ -233,12 +235,24 @@ fn run_main_loop(port: Port<Msg>,
 
     let script_chan_clone = script_chan.clone();
 
-    // When the user clicks, perform hit testing
-    do window.set_click_callback |layer_click_point| {
-        let world_click_point = layer_click_point + *world_offset;
-        debug!("osmain: clicked at %?", world_click_point);
-
-        script_chan_clone.send(SendEventMsg(ClickEvent(world_click_point)));
+    // When the user triggers a mouse event, perform appropriate hit testing
+    do window.set_mouse_callback |window_mouse_event: WindowMouseEvent| {
+        let event: Event;
+        let world_mouse_point = |layer_mouse_point: Point2D<f32>| {
+            layer_mouse_point + *world_offset
+        };
+        match window_mouse_event {
+            WindowClickEvent(button, layer_mouse_point) => {
+                event = ClickEvent(button, world_mouse_point(layer_mouse_point));
+            }
+            WindowMouseDownEvent(button, layer_mouse_point) => {
+                event = MouseDownEvent(button, world_mouse_point(layer_mouse_point));
+            }
+            WindowMouseUpEvent(button, layer_mouse_point) => {
+                event = MouseUpEvent(button, world_mouse_point(layer_mouse_point));
+            }
+        }
+        script_chan_clone.send(SendEventMsg(event));
     }
 
     // When the user scrolls, move the layer around.

src/components/main/css/select_handler.rs

@@ -24,6 +24,16 @@ fn with_node_name<R>(node: AbstractNode<LayoutView>, f: &fn(&str) -> R) -> R {
 }
 
 impl SelectHandler<AbstractNode<LayoutView>> for NodeSelectHandler {
+    // FIXME(tkuehn): placeholder to get servo to compile
+    fn node_has_class(&self, node: &AbstractNode<LayoutView>, s: &str) -> bool {
+        true
+    }
+
+    // FIXME(tkuehn): placeholder to get servo to compile
+    fn with_node_classes<R>(&self, node: &AbstractNode<LayoutView>, f: &fn(Option<&str>) -> R) -> R {
+        f(None)
+    }
+
     fn with_node_name<R>(&self, node: &AbstractNode<LayoutView>, f: &fn(&str) -> R) -> R {
         with_node_name(*node, f)
     }

src/components/main/engine.rs

@@ -18,7 +18,7 @@ use script::script_task;
 use servo_net::image_cache_task::{ImageCacheTask, ImageCacheTaskClient};
 use servo_net::resource_task::ResourceTask;
 use servo_net::resource_task;
-use servo_util::time::{ProfilerChan, ProfilerPort, ProfilerTask};
+use servo_util::time::{profiler_force_print, ProfilerChan, ProfilerPort, ProfilerTask};
 use std::net::url::Url;
 
 pub type EngineTask = Chan<Msg>;
@@ -39,6 +39,12 @@ pub struct Engine {
     profiler_task: ProfilerTask,
 }
 
+impl Drop for Engine {
+    fn finalize(&self) {
+        profiler_force_print(self.profiler_task.chan.clone()); 
+    }
+}
+
 impl Engine {
     pub fn start(compositor: CompositorTask,
                  opts: &Opts,
@@ -58,9 +64,12 @@ impl Engine {
                                               opts.with_ref(|o| copy *o),
                                               profiler_chan.clone());
 
-            let profiler_task = ProfilerTask::new(profiler_port.take(), profiler_chan.clone());
-
             let opts = opts.take();
+
+            let profiler_task = ProfilerTask::new(profiler_port.take(),
+                                                  profiler_chan.clone(),
+                                                  opts.profiler_period);
+
             let layout_task = layout_task::create_layout_task(render_task.clone(),
                                                               image_cache_task.clone(),
                                                               opts,

src/components/main/layout/layout_task.rs

@@ -342,13 +342,14 @@ impl Layout {
                         flow.build_display_list(&builder,
                                                 &flow.position(),
                                                 display_list);
-                        // iterate in reverse to ensure we have the most recently painted render box
                         let (x, y) = (Au::from_frac_px(point.x as float),
                                       Au::from_frac_px(point.y as float));
                         let mut resp = Err(());
                         let display_list = &display_list.take().list;
+                        // iterate in reverse to ensure we have the most recently painted render box
                         for display_list.each_reverse |display_item| {
                             let bounds = display_item.bounds();
+                            // TODO this check should really be performed by a method of DisplayItem
                             if x <= bounds.origin.x + bounds.size.width &&
                                bounds.origin.x <= x &&
                                y < bounds.origin.y + bounds.size.height &&