Pipeline create is now wrapped in a task that supervises the tasks

created by script, rendering, and layout. When any of those fail,
the pipeline is removed from the FrameTree and a new one is created
with a failure HTML file.

Additionally, the top-level Makefile is changed to store debug info.

1 files changed, 76 insertions, 30 deletions

diff --git a/src/components/main/pipeline.rs b/src/components/main/pipeline.rs
index 0204748c20b..0a716e0acf9 100644
--- a/src/components/main/pipeline.rs
+++ b/src/components/main/pipeline.rs
@@ -11,7 +11,7 @@ use gfx::opts::Opts;
 use layout::layout_task::LayoutTask;
 use script::layout_interface::LayoutChan;
 use script::script_task::{ExecuteMsg, LoadMsg};
-use servo_msg::constellation_msg::{ConstellationChan, PipelineId, SubpageId};
+use servo_msg::constellation_msg::{ConstellationChan, FailureMsg, PipelineId, SubpageId};
 use script::dom::node::AbstractNode;
 use script::script_task::{AttachLayoutMsg, NewLayoutInfo, ScriptTask, ScriptChan};
 use script::script_task;
@@ -20,9 +20,11 @@ use servo_net::resource_task::ResourceTask;
 use servo_util::time::ProfilerChan;
 use geom::size::Size2D;
 use extra::future::Future;
+use std::cell::Cell;
 use std::comm;
+use std::task;
 
-/// A uniquely-identifiable pipeline of stript task, layout task, and render task. 
+/// A uniquely-identifiable pipeline of script task, layout task, and render task. 
 #[deriving(Clone)]
 pub struct Pipeline {
     id: PipelineId,
@@ -94,37 +96,81 @@ impl Pipeline {
         let (script_port, script_chan) = special_stream!(ScriptChan);
         let (layout_port, layout_chan) = special_stream!(LayoutChan);
         let (render_port, render_chan) = special_stream!(RenderChan);
+        let pipeline = Pipeline::new(id,
+                                     subpage_id,
+                                     script_chan.clone(),
+                                     layout_chan.clone(),
+                                     render_chan.clone());
+        let (port, chan) = stream::<task::TaskResult>();
+        
+        let script_port = Cell::new(script_port);
+        let resource_task = Cell::new(resource_task);
+        let size = Cell::new(size);
+        let render_port = Cell::new(render_port);
+        let layout_port = Cell::new(layout_port);
+        let constellation_chan_handler = Cell::new(constellation_chan.clone());
+        let constellation_chan = Cell::new(constellation_chan);
+        let image_cache_task = Cell::new(image_cache_task);
+        let profiler_chan = Cell::new(profiler_chan);
+
+        do Pipeline::spawn(chan) {
+            let script_port = script_port.take();
+            let resource_task = resource_task.take();
+            let size = size.take();
+            let render_port = render_port.take();
+            let layout_port = layout_port.take();
+            let constellation_chan = constellation_chan.take();
+            let image_cache_task = image_cache_task.take();
+            let profiler_chan = profiler_chan.take();
+
+            ScriptTask::create(id,
+                               compositor_chan.clone(),
+                               layout_chan.clone(),
+                               script_port,
+                               script_chan.clone(),
+                               constellation_chan.clone(),
+                               resource_task,
+                               image_cache_task.clone(),
+                               size);
+
+            RenderTask::create(id,
+                               render_port,
+                               compositor_chan.clone(),
+                               opts.clone(),
+                               profiler_chan.clone());
+
+            LayoutTask::create(id,
+                               layout_port,
+                               constellation_chan,
+                               script_chan.clone(),
+                               render_chan.clone(),
+                               image_cache_task,
+                               opts.clone(),
+                               profiler_chan);
+        };
 
-        ScriptTask::create(id,
-                           compositor_chan.clone(),
-                           layout_chan.clone(),
-                           script_port,
-                           script_chan.clone(),
-                           constellation_chan.clone(),
-                           resource_task,
-                           image_cache_task.clone(),
-                           size);
-
+        do spawn {
+            match port.recv() {
+                task::Success => (),
+                task::Failure => {
+                    let constellation_chan = constellation_chan_handler.take();
+                    constellation_chan.send(FailureMsg(id, subpage_id));
+                }
+            }
+        };
 
-        RenderTask::create(id,
-                           render_port,
-                           compositor_chan.clone(),
-                           opts.clone(),
-                           profiler_chan.clone());
+        pipeline
+    }
 
-        LayoutTask::create(id,
-                           layout_port,
-                           constellation_chan,
-                           script_chan.clone(),
-                           render_chan.clone(),
-                           image_cache_task,
-                           opts.clone(),
-                           profiler_chan);
-        Pipeline::new(id,
-                      subpage_id,
-                      script_chan,
-                      layout_chan,
-                      render_chan)
+    /// This function wraps the task creation within a supervised task
+    /// so that failure will only tear down those tasks instead of ours.
+    pub fn spawn(chan:Chan<task::TaskResult>, f:~fn()) {
+        let mut task = task::task();
+        task.opts.notify_chan = Some(chan);
+        task.supervised();
+        do task.spawn {
+            f();
+        };
     }
 
     pub fn new(id: PipelineId,