From cf773ab0f22cdfdc09ae56d4d4966fe8cb15a135 Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Tue, 17 Dec 2013 18:16:05 -0800
Subject: [PATCH] servo: Merge #1424 - Harden layout (from
 pcwalton:harden-layout); r=pcwalton

This changeset gets rid of the `FooView` phantom type in favor of a more brute force approach that just whitelists methods that layout is allowed to call. The set is surprisingly small now that layout isn't going to the DOM for much.

If this approach turns out not to scale, we can do something fancier, but I'd rather just have it be safe and secure first and then refactor later for programmer happiness.

r? @kmcallister

Source-Repo: https://github.com/servo/servo
Source-Revision: 824c7ac613ebb80bb432ff6425c5e25c642b6afb
---
 servo/src/components/main/css/matching.rs     |  46 +-
 servo/src/components/main/css/node_style.rs   |   4 +-
 servo/src/components/main/css/node_util.rs    |   4 +-
 servo/src/components/main/layout/box.rs       |  40 +-
 servo/src/components/main/layout/construct.rs |  48 +--
 servo/src/components/main/layout/extra.rs     |   5 +-
 servo/src/components/main/layout/flow.rs      |   6 +-
 servo/src/components/main/layout/inline.rs    |   3 +-
 .../src/components/main/layout/layout_task.rs |  16 +-
 servo/src/components/main/layout/text.rs      |   5 +-
 servo/src/components/main/layout/util.rs      |  36 +-
 servo/src/components/main/layout/wrapper.rs   | 397 +++++++++++++++++
 servo/src/components/main/servo.rc            |   1 +
 servo/src/components/script/dom/attrlist.rs   |   9 +-
 .../script/dom/bindings/codegen/Bindings.conf |  12 +-
 .../dom/bindings/codegen/CodegenRust.py       |   2 +-
 .../components/script/dom/bindings/node.rs    |   8 +-
 .../components/script/dom/characterdata.rs    |   4 +-
 servo/src/components/script/dom/comment.rs    |   6 +-
 servo/src/components/script/dom/document.rs   |  37 +-
 .../components/script/dom/documentfragment.rs |   9 +-
 .../src/components/script/dom/documenttype.rs |   7 +-
 servo/src/components/script/dom/element.rs    |  67 +--
 .../src/components/script/dom/eventtarget.rs  |   4 +-
 servo/src/components/script/dom/formdata.rs   |  12 +-
 .../script/dom/htmlanchorelement.rs           |   4 +-
 .../script/dom/htmlappletelement.rs           |   4 +-
 .../components/script/dom/htmlareaelement.rs  |   4 +-
 .../components/script/dom/htmlaudioelement.rs |   4 +-
 .../components/script/dom/htmlbaseelement.rs  |   4 +-
 .../components/script/dom/htmlbodyelement.rs  |   4 +-
 .../components/script/dom/htmlbrelement.rs    |   4 +-
 .../script/dom/htmlbuttonelement.rs           |   6 +-
 .../script/dom/htmlcanvaselement.rs           |   4 +-
 .../components/script/dom/htmlcollection.rs   |  14 +-
 .../components/script/dom/htmldataelement.rs  |   4 +-
 .../script/dom/htmldatalistelement.rs         |   4 +-
 .../script/dom/htmldirectoryelement.rs        |   4 +-
 .../components/script/dom/htmldivelement.rs   |   4 +-
 .../components/script/dom/htmldlistelement.rs |   4 +-
 .../src/components/script/dom/htmldocument.rs |   4 +-
 .../src/components/script/dom/htmlelement.rs  |   6 +-
 .../components/script/dom/htmlembedelement.rs |   4 +-
 .../script/dom/htmlfieldsetelement.rs         |   6 +-
 .../components/script/dom/htmlfontelement.rs  |   4 +-
 .../components/script/dom/htmlformelement.rs  |   6 +-
 .../components/script/dom/htmlframeelement.rs |   4 +-
 .../script/dom/htmlframesetelement.rs         |   4 +-
 .../components/script/dom/htmlheadelement.rs  |   4 +-
 .../script/dom/htmlheadingelement.rs          |   4 +-
 .../components/script/dom/htmlhrelement.rs    |   4 +-
 .../components/script/dom/htmlhtmlelement.rs  |   4 +-
 .../script/dom/htmliframeelement.rs           |   8 +-
 .../components/script/dom/htmlimageelement.rs |  22 +-
 .../components/script/dom/htmlinputelement.rs |   4 +-
 .../components/script/dom/htmllabelelement.rs |   4 +-
 .../script/dom/htmllegendelement.rs           |   4 +-
 .../components/script/dom/htmllielement.rs    |   4 +-
 .../components/script/dom/htmllinkelement.rs  |   4 +-
 .../components/script/dom/htmlmainelement.rs  |   4 +-
 .../components/script/dom/htmlmapelement.rs   |   4 +-
 .../components/script/dom/htmlmetaelement.rs  |   4 +-
 .../components/script/dom/htmlmeterelement.rs |   4 +-
 .../components/script/dom/htmlmodelement.rs   |   4 +-
 .../script/dom/htmlobjectelement.rs           |   6 +-
 .../components/script/dom/htmlolistelement.rs |   4 +-
 .../script/dom/htmloptgroupelement.rs         |   4 +-
 .../script/dom/htmloptionelement.rs           |   6 +-
 .../script/dom/htmloutputelement.rs           |   6 +-
 .../script/dom/htmlparagraphelement.rs        |   4 +-
 .../components/script/dom/htmlparamelement.rs |   4 +-
 .../components/script/dom/htmlpreelement.rs   |   4 +-
 .../script/dom/htmlprogresselement.rs         |   4 +-
 .../components/script/dom/htmlquoteelement.rs |   4 +-
 .../script/dom/htmlscriptelement.rs           |   4 +-
 .../script/dom/htmlselectelement.rs           |  14 +-
 .../script/dom/htmlsourceelement.rs           |   4 +-
 .../components/script/dom/htmlspanelement.rs  |   4 +-
 .../components/script/dom/htmlstyleelement.rs |   4 +-
 .../script/dom/htmltablecaptionelement.rs     |   4 +-
 .../script/dom/htmltablecolelement.rs         |   4 +-
 .../script/dom/htmltabledatacellelement.rs    |   4 +-
 .../components/script/dom/htmltableelement.rs |   4 +-
 .../script/dom/htmltableheadercellelement.rs  |   4 +-
 .../script/dom/htmltablerowelement.rs         |   4 +-
 .../script/dom/htmltablesectionelement.rs     |   4 +-
 .../script/dom/htmltemplateelement.rs         |   4 +-
 .../script/dom/htmltextareaelement.rs         |   4 +-
 .../components/script/dom/htmltimeelement.rs  |   4 +-
 .../components/script/dom/htmltitleelement.rs |   4 +-
 .../components/script/dom/htmltrackelement.rs |   4 +-
 .../components/script/dom/htmlulistelement.rs |   4 +-
 .../script/dom/htmlunknownelement.rs          |   4 +-
 .../components/script/dom/htmlvideoelement.rs |   4 +-
 servo/src/components/script/dom/node.rs       | 405 ++++++------------
 servo/src/components/script/dom/nodelist.rs   |  14 +-
 servo/src/components/script/dom/text.rs       |   8 +-
 servo/src/components/script/dom/uievent.rs    |   4 +-
 servo/src/components/script/dom/window.rs     |   4 +-
 .../script/html/hubbub_html_parser.rs         |  18 +-
 .../src/components/script/layout_interface.rs |  14 +-
 servo/src/components/script/script_task.rs    |   8 +-
 servo/src/components/style/node.rs            |   4 +-
 103 files changed, 907 insertions(+), 692 deletions(-)
 create mode 100644 servo/src/components/main/layout/wrapper.rs

diff --git a/servo/src/components/main/css/matching.rs b/servo/src/components/main/css/matching.rs
index 6de245e3d605..ead2052421ea 100644
--- a/servo/src/components/main/css/matching.rs
+++ b/servo/src/components/main/css/matching.rs
@@ -4,32 +4,33 @@
 
 // High-level interface to CSS selector matching.
 
-use std::cell::Cell;
-use std::comm;
-use std::task;
-use std::vec;
-use std::rt;
-use extra::arc::{Arc, RWArc};
-
 use css::node_style::StyledNode;
 use layout::incremental;
 use layout::util::LayoutDataAccess;
+use layout::wrapper::LayoutNode;
 
-use script::dom::node::{AbstractNode, LayoutView};
+use extra::arc::{Arc, RWArc};
+use std::cast;
+use std::cell::Cell;
+use std::comm;
+use std::libc::uintptr_t;
+use std::rt;
+use std::task;
+use std::vec;
 use style::{TNode, Stylist, cascade};
 
 pub trait MatchMethods {
     fn match_node(&self, stylist: &Stylist);
     fn match_subtree(&self, stylist: RWArc<Stylist>);
 
-    fn cascade_node(&self, parent: Option<AbstractNode<LayoutView>>);
-    fn cascade_subtree(&self, parent: Option<AbstractNode<LayoutView>>);
+    fn cascade_node(&self, parent: Option<LayoutNode>);
+    fn cascade_subtree(&self, parent: Option<LayoutNode>);
 }
 
-impl MatchMethods for AbstractNode<LayoutView> {
+impl<'self> MatchMethods for LayoutNode<'self> {
     fn match_node(&self, stylist: &Stylist) {
-        let applicable_declarations = do self.with_imm_element |element| {
-            let style_attribute = match element.style_attribute {
+        let applicable_declarations = do self.with_element |element| {
+            let style_attribute = match *element.style_attribute() {
                 None => None,
                 Some(ref style_attribute) => Some(style_attribute)
             };
@@ -63,7 +64,20 @@ impl MatchMethods for AbstractNode<LayoutView> {
             if nodes.len() > 0 {
                 let chan = chan.clone();
                 let stylist = stylist.clone();
-                do task::spawn_with((nodes, stylist)) |(nodes, stylist)| {
+               
+                // FIXME(pcwalton): This transmute is to work around the fact that we have no
+                // mechanism for safe fork/join parallelism. If we had such a thing, then we could
+                // close over the lifetime-bounded `LayoutNode`. But we can't, so we force it with
+                // a transmute.
+                let evil: uintptr_t = unsafe {
+                    cast::transmute(nodes)
+                };
+
+                do task::spawn_with((evil, stylist)) |(evil, stylist)| {
+                    let nodes: ~[LayoutNode] = unsafe {
+                        cast::transmute(evil)
+                    };
+
                     let nodes = Cell::new(nodes);
                     do stylist.read |stylist| {
                         for node in nodes.take().move_iter() {
@@ -80,7 +94,7 @@ impl MatchMethods for AbstractNode<LayoutView> {
         }
     }
 
-    fn cascade_node(&self, parent: Option<AbstractNode<LayoutView>>) {
+    fn cascade_node(&self, parent: Option<LayoutNode>) {
         let parent_style = match parent {
             Some(ref parent) => Some(parent.style()),
             None => None
@@ -111,7 +125,7 @@ impl MatchMethods for AbstractNode<LayoutView> {
         }
     }
 
-    fn cascade_subtree(&self, parent: Option<AbstractNode<LayoutView>>) {
+    fn cascade_subtree(&self, parent: Option<LayoutNode>) {
         self.cascade_node(parent);
 
         for kid in self.children() {
diff --git a/servo/src/components/main/css/node_style.rs b/servo/src/components/main/css/node_style.rs
index af9b927e171e..6810d9187eaa 100644
--- a/servo/src/components/main/css/node_style.rs
+++ b/servo/src/components/main/css/node_style.rs
@@ -6,10 +6,10 @@
 
 use css::node_util::NodeUtil;
 use layout::incremental::RestyleDamage;
+use layout::wrapper::LayoutNode;
 
 use extra::arc::Arc;
 use style::ComputedValues;
-use script::dom::node::{AbstractNode, LayoutView};
 
 /// Node mixin providing `style` method that returns a `NodeStyle`
 pub trait StyledNode {
@@ -17,7 +17,7 @@ pub trait StyledNode {
     fn restyle_damage(&self) -> RestyleDamage;
 }
 
-impl StyledNode for AbstractNode<LayoutView> {
+impl<'self> StyledNode for LayoutNode<'self> {
     #[inline]
     fn style<'a>(&'a self) -> &'a Arc<ComputedValues> {
         self.get_css_select_results()
diff --git a/servo/src/components/main/css/node_util.rs b/servo/src/components/main/css/node_util.rs
index b5d8e790c002..a84fb5cc0612 100644
--- a/servo/src/components/main/css/node_util.rs
+++ b/servo/src/components/main/css/node_util.rs
@@ -4,11 +4,11 @@
 
 use layout::incremental::RestyleDamage;
 use layout::util::LayoutDataAccess;
+use layout::wrapper::LayoutNode;
 
 use extra::arc::Arc;
 use std::cast;
 use style::{ComputedValues, TNode};
-use script::dom::node::{AbstractNode, LayoutView};
 
 pub trait NodeUtil {
     fn get_css_select_results<'a>(&'a self) -> &'a Arc<ComputedValues>;
@@ -18,7 +18,7 @@ pub trait NodeUtil {
     fn set_restyle_damage(self, damage: RestyleDamage);
 }
 
-impl NodeUtil for AbstractNode<LayoutView> {
+impl<'self> NodeUtil for LayoutNode<'self> {
     /** 
      * Provides the computed style for the given node. If CSS selector
      * Returns the style results for the given node. If CSS selector
diff --git a/servo/src/components/main/layout/box.rs b/servo/src/components/main/layout/box.rs
index 9c341f12028a..70cda196fc9a 100644
--- a/servo/src/components/main/layout/box.rs
+++ b/servo/src/components/main/layout/box.rs
@@ -15,7 +15,6 @@ use gfx::display_list::{TextDisplayItemClass, TextDisplayItemFlags, ClipDisplayI
 use gfx::display_list::{ClipDisplayItemClass};
 use gfx::font::{FontStyle, FontWeight300};
 use gfx::text::text_run::TextRun;
-use script::dom::node::{AbstractNode, LayoutView};
 use servo_msg::constellation_msg::{FrameRectMsg, PipelineId, SubpageId};
 use servo_net::image::holder::ImageHolder;
 use servo_net::local_image_cache::LocalImageCache;
@@ -40,6 +39,7 @@ use layout::flow::Flow;
 use layout::flow;
 use layout::model::{MaybeAuto, specified};
 use layout::util::OpaqueNode;
+use layout::wrapper::LayoutNode;
 
 /// Boxes (`struct Box`) are the leaves of the layout tree. They cannot position themselves. In
 /// general, boxes do not have a simple correspondence with CSS boxes in the specification:
@@ -116,12 +116,10 @@ impl ImageBoxInfo {
     ///
     /// FIXME(pcwalton): The fact that image boxes store the cache in the box makes little sense to
     /// me.
-    pub fn new(node: &AbstractNode<LayoutView>,
-               image_url: Url,
-               local_image_cache: MutexArc<LocalImageCache>)
+    pub fn new(node: &LayoutNode, image_url: Url, local_image_cache: MutexArc<LocalImageCache>)
                -> ImageBoxInfo {
-        fn convert_length(node: &AbstractNode<LayoutView>, name: &str) -> Option<Au> {
-            node.with_imm_element(|element| {
+        fn convert_length(node: &LayoutNode, name: &str) -> Option<Au> {
+            node.with_element(|element| {
                 element.get_attr(None, name).and_then(|string| {
                     let n: Option<int> = FromStr::from_str(string);
                     n
@@ -165,14 +163,12 @@ pub struct IframeBoxInfo {
 
 impl IframeBoxInfo {
     /// Creates the information specific to an iframe box.
-    pub fn new(node: &AbstractNode<LayoutView>) -> IframeBoxInfo {
-        node.with_imm_iframe_element(|iframe_element| {
-            let size = iframe_element.size.unwrap();
-            IframeBoxInfo {
-                pipeline_id: size.pipeline_id,
-                subpage_id: size.subpage_id,
-            }
-        })
+    pub fn new(node: &LayoutNode) -> IframeBoxInfo {
+        let (pipeline_id, subpage_id) = node.iframe_pipeline_and_subpage_ids();
+        IframeBoxInfo {
+            pipeline_id: pipeline_id,
+            subpage_id: subpage_id,
+        }
     }
 }
 
@@ -209,13 +205,11 @@ pub struct UnscannedTextBoxInfo {
 
 impl UnscannedTextBoxInfo {
     /// Creates a new instance of `UnscannedTextBoxInfo` from the given DOM node.
-    pub fn new(node: &AbstractNode<LayoutView>) -> UnscannedTextBoxInfo {
-        node.with_imm_text(|text_node| {
-            // FIXME(pcwalton): Don't copy text; atomically reference count it instead.
-            UnscannedTextBoxInfo {
-                text: text_node.element.data.to_str(),
-            }
-        })
+    pub fn new(node: &LayoutNode) -> UnscannedTextBoxInfo {
+        // FIXME(pcwalton): Don't copy text; atomically reference count it instead.
+        UnscannedTextBoxInfo {
+            text: node.text(),
+        }
     }
 }
 
@@ -230,7 +224,7 @@ pub enum SplitBoxResult {
 
 impl Box {
     /// Constructs a new `Box` instance.
-    pub fn new(node: AbstractNode<LayoutView>, specific: SpecificBoxInfo) -> Box {
+    pub fn new(node: LayoutNode, specific: SpecificBoxInfo) -> Box {
         // Find the nearest ancestor element and take its style. (It should be either that node or
         // its immediate parent.)
         //
@@ -250,7 +244,7 @@ impl Box {
         }
 
         Box {
-            node: OpaqueNode::from_node(&node),
+            node: OpaqueNode::from_layout_node(&node),
             style: (*nearest_ancestor_element.style()).clone(),
             position: Slot::init(Au::zero_rect()),
             border: Slot::init(Zero::zero()),
diff --git a/servo/src/components/main/layout/construct.rs b/servo/src/components/main/layout/construct.rs
index 42764b9fe604..80a8ffb8a1ba 100644
--- a/servo/src/components/main/layout/construct.rs
+++ b/servo/src/components/main/layout/construct.rs
@@ -30,11 +30,11 @@ use layout::flow::{Flow, FlowData, MutableFlowUtils};
 use layout::inline::InlineFlow;
 use layout::text::TextRunScanner;
 use layout::util::LayoutDataAccess;
+use layout::wrapper::{LayoutNode, PostorderNodeMutTraversal};
 
 use script::dom::element::{HTMLIframeElementTypeId, HTMLImageElementTypeId};
-use script::dom::node::{AbstractNode, CommentNodeTypeId, DoctypeNodeTypeId};
-use script::dom::node::{DocumentFragmentNodeTypeId, DocumentNodeTypeId, ElementNodeTypeId};
-use script::dom::node::{LayoutView, PostorderNodeMutTraversal, TextNodeTypeId};
+use script::dom::node::{CommentNodeTypeId, DoctypeNodeTypeId, DocumentFragmentNodeTypeId};
+use script::dom::node::{DocumentNodeTypeId, ElementNodeTypeId, TextNodeTypeId};
 use servo_util::slot::Slot;
 use std::util;
 use style::computed_values::{display, float};
@@ -198,13 +198,9 @@ impl<'self> FlowConstructor<'self> {
     }
 
     /// Builds the `ImageBoxInfo` for the given image. This is out of line to guide inlining.
-    fn build_box_info_for_image(&mut self, node: AbstractNode<LayoutView>) -> Option<ImageBoxInfo> {
+    fn build_box_info_for_image(&mut self, node: LayoutNode) -> Option<ImageBoxInfo> {
         // FIXME(pcwalton): Don't copy URLs.
-        let url = node.with_imm_image_element(|image_element| {
-            image_element.image.as_ref().map(|url| (*url).clone())
-        });
-
-        match url {
+        match node.image_url() {
             None => None,
             Some(url) => {
                 // FIXME(pcwalton): The fact that image boxes store the cache within them makes
@@ -215,7 +211,7 @@ impl<'self> FlowConstructor<'self> {
     }
 
     /// Builds a `Box` for the given node.
-    fn build_box_for_node(&mut self, node: AbstractNode<LayoutView>) -> Box {
+    fn build_box_for_node(&mut self, node: LayoutNode) -> Box {
         let specific = match node.type_id() {
             ElementNodeTypeId(HTMLImageElementTypeId) => {
                 match self.build_box_info_for_image(node) {
@@ -235,10 +231,7 @@ impl<'self> FlowConstructor<'self> {
     /// `#[inline(always)]` because this is performance critical and LLVM will not inline it
     /// otherwise.
     #[inline(always)]
-    fn flush_inline_boxes_to_flow(&mut self,
-                                  boxes: ~[Box],
-                                  flow: &mut ~Flow:,
-                                  node: AbstractNode<LayoutView>) {
+    fn flush_inline_boxes_to_flow(&mut self, boxes: ~[Box], flow: &mut ~Flow:, node: LayoutNode) {
         if boxes.len() > 0 {
             let inline_base = FlowData::new(self.next_flow_id(), node);
             let mut inline_flow = ~InlineFlow::from_boxes(inline_base, boxes) as ~Flow:;
@@ -252,7 +245,7 @@ impl<'self> FlowConstructor<'self> {
     fn flush_inline_boxes_to_flow_if_necessary(&mut self,
                                                opt_boxes: &mut Option<~[Box]>,
                                                flow: &mut ~Flow:,
-                                               node: AbstractNode<LayoutView>) {
+                                               node: LayoutNode) {
         let opt_boxes = util::replace(opt_boxes, None);
         if opt_boxes.len() > 0 {
             self.flush_inline_boxes_to_flow(opt_boxes.to_vec(), flow, node)
@@ -264,7 +257,7 @@ impl<'self> FlowConstructor<'self> {
     /// whether {ib} splits needed to happen.
     fn build_children_of_block_flow(&mut self,
                                     flow: &mut ~Flow:,
-                                    node: AbstractNode<LayoutView>) {
+                                    node: LayoutNode) {
         // Gather up boxes for the inline flows we might need to create.
         let mut opt_boxes_for_inline_flow = None;
         let mut first_box = true;
@@ -349,7 +342,7 @@ impl<'self> FlowConstructor<'self> {
     /// Builds a flow for a node with `display: block`. This yields a `BlockFlow` with possibly
     /// other `BlockFlow`s or `InlineFlow`s underneath it, depending on whether {ib} splits needed
     /// to happen.
-    fn build_flow_for_block(&mut self, node: AbstractNode<LayoutView>) -> ~Flow: {
+    fn build_flow_for_block(&mut self, node: LayoutNode) -> ~Flow: {
         let base = FlowData::new(self.next_flow_id(), node);
         let box = self.build_box_for_node(node);
         let mut flow = ~BlockFlow::from_box(base, box) as ~Flow:;
@@ -359,7 +352,7 @@ impl<'self> FlowConstructor<'self> {
 
     /// Builds the flow for a node with `float: {left|right}`. This yields a float `BlockFlow` with
     /// a `BlockFlow` underneath it.
-    fn build_flow_for_floated_block(&mut self, node: AbstractNode<LayoutView>, float_type: FloatType)
+    fn build_flow_for_floated_block(&mut self, node: LayoutNode, float_type: FloatType)
                                     -> ~Flow: {
         let base = FlowData::new(self.next_flow_id(), node);
         let box = self.build_box_for_node(node);
@@ -371,7 +364,7 @@ impl<'self> FlowConstructor<'self> {
     /// Concatenates the boxes of kids, adding in our own borders/padding/margins if necessary.
     /// Returns the `InlineBoxesConstructionResult`, if any. There will be no
     /// `InlineBoxesConstructionResult` if this node consisted entirely of ignorable whitespace.
-    fn build_boxes_for_nonreplaced_inline_content(&mut self, node: AbstractNode<LayoutView>)
+    fn build_boxes_for_nonreplaced_inline_content(&mut self, node: LayoutNode)
                                                   -> ConstructionResult {
         let mut opt_inline_block_splits = None;
         let mut opt_box_accumulator = None;
@@ -437,8 +430,7 @@ impl<'self> FlowConstructor<'self> {
 
     /// Creates an `InlineBoxesConstructionResult` for replaced content. Replaced content doesn't
     /// render its children, so this just nukes a child's boxes and creates a `Box`.
-    fn build_boxes_for_replaced_inline_content(&mut self, node: AbstractNode<LayoutView>)
-                                               -> ConstructionResult {
+    fn build_boxes_for_replaced_inline_content(&mut self, node: LayoutNode) -> ConstructionResult {
         for kid in node.children() {
             kid.set_flow_construction_result(NoConstructionResult)
         }
@@ -454,7 +446,7 @@ impl<'self> FlowConstructor<'self> {
 
     /// Builds one or more boxes for a node with `display: inline`. This yields an
     /// `InlineBoxesConstructionResult`.
-    fn build_boxes_for_inline(&mut self, node: AbstractNode<LayoutView>) -> ConstructionResult {
+    fn build_boxes_for_inline(&mut self, node: LayoutNode) -> ConstructionResult {
         // Is this node replaced content?
         if !node.is_replaced_content() {
             // Go to a path that concatenates our kids' boxes.
@@ -470,7 +462,7 @@ impl<'self> PostorderNodeMutTraversal for FlowConstructor<'self> {
     // `#[inline(always)]` because this is always called from the traversal function and for some
     // reason LLVM's inlining heuristics go awry here.
     #[inline(always)]
-    fn process(&mut self, node: AbstractNode<LayoutView>) -> bool {
+    fn process(&mut self, node: LayoutNode) -> bool {
         // Get the `display` property for this node, and determine whether this node is floated.
         let (display, float) = match node.type_id() {
             ElementNodeTypeId(_) => {
@@ -534,13 +526,9 @@ trait NodeUtils {
     /// Replaces the flow construction result in a node with `NoConstructionResult` and returns the
     /// old value.
     fn swap_out_construction_result(self) -> ConstructionResult;
-
-    /// Returns true if this node consists entirely of ignorable whitespace and false otherwise.
-    /// Ignorable whitespace is defined as whitespace that would be removed per CSS 2.1 § 16.6.1.
-    fn is_ignorable_whitespace(self) -> bool;
 }
 
-impl NodeUtils for AbstractNode<LayoutView> {
+impl<'self> NodeUtils for LayoutNode<'self> {
     fn is_replaced_content(self) -> bool {
         match self.type_id() {
             TextNodeTypeId |
@@ -570,10 +558,6 @@ impl NodeUtils for AbstractNode<LayoutView> {
             None => fail!("no layout data"),
         }
     }
-
-    fn is_ignorable_whitespace(self) -> bool {
-        self.is_text() && self.with_imm_text(|text| text.element.data.is_whitespace())
-    }
 }
 
 /// Strips ignorable whitespace from the start of a list of boxes.
diff --git a/servo/src/components/main/layout/extra.rs b/servo/src/components/main/layout/extra.rs
index 8b6a8c46478c..c17bfc4e0e4b 100644
--- a/servo/src/components/main/layout/extra.rs
+++ b/servo/src/components/main/layout/extra.rs
@@ -5,8 +5,7 @@
 //! Code for managing the layout data in the DOM.
 
 use layout::util::{LayoutData, LayoutDataAccess};
-
-use script::dom::node::{AbstractNode, LayoutView};
+use layout::wrapper::LayoutNode;
 
 /// Functionality useful for querying the layout-specific data on DOM nodes.
 pub trait LayoutAuxMethods {
@@ -14,7 +13,7 @@ pub trait LayoutAuxMethods {
     fn initialize_style_for_subtree(self);
 }
 
-impl LayoutAuxMethods for AbstractNode<LayoutView> {
+impl<'self> LayoutAuxMethods for LayoutNode<'self> {
     /// Resets layout data and styles for the node.
     ///
     /// FIXME(pcwalton): Do this as part of box building instead of in a traversal.
diff --git a/servo/src/components/main/layout/flow.rs b/servo/src/components/main/layout/flow.rs
index 4b612286b305..d7d1f602f29a 100644
--- a/servo/src/components/main/layout/flow.rs
+++ b/servo/src/components/main/layout/flow.rs
@@ -33,13 +33,13 @@ use layout::display_list_builder::{DisplayListBuilder, ExtraDisplayListData};
 use layout::float_context::{FloatContext, Invalid};
 use layout::incremental::RestyleDamage;
 use layout::inline::InlineFlow;
+use layout::wrapper::LayoutNode;
 
 use extra::dlist::{DList, DListIterator, MutDListIterator};
 use extra::container::Deque;
 use geom::point::Point2D;
 use geom::rect::Rect;
 use gfx::display_list::{ClipDisplayItemClass, DisplayList};
-use script::dom::node::{AbstractNode, LayoutView};
 use servo_util::geometry::Au;
 use std::cast;
 use std::cell::Cell;
@@ -382,7 +382,6 @@ impl FlowFlags {
 /// FIXME: We need a naming convention for pseudo-inheritance like this. How about
 /// `CommonFlowInfo`?
 pub struct FlowData {
-    node: AbstractNode<LayoutView>,
     restyle_damage: RestyleDamage,
 
     /// The children of this flow.
@@ -433,10 +432,9 @@ impl Iterator<@Box> for BoxIterator {
 
 impl FlowData {
     #[inline]
-    pub fn new(id: int, node: AbstractNode<LayoutView>) -> FlowData {
+    pub fn new(id: int, node: LayoutNode) -> FlowData {
         let style = node.style();
         FlowData {
-            node: node,
             restyle_damage: node.restyle_damage(),
 
             children: DList::new(),
diff --git a/servo/src/components/main/layout/inline.rs b/servo/src/components/main/layout/inline.rs
index c270d90df607..5d5022eaf309 100644
--- a/servo/src/components/main/layout/inline.rs
+++ b/servo/src/components/main/layout/inline.rs
@@ -441,10 +441,11 @@ pub struct InlineFlow {
     // these ranges are disjoint, and are the result of inline layout.
     // also some metadata used for positioning lines
     lines: ~[LineBox],
+
     // vec of ranges into boxes that represent elements. These ranges
     // must be well-nested, and are only related to the content of
     // boxes (not lines). Ranges are only kept for non-leaf elements.
-    elems: ElementMapping
+    elems: ElementMapping,
 }
 
 impl InlineFlow {
diff --git a/servo/src/components/main/layout/layout_task.rs b/servo/src/components/main/layout/layout_task.rs
index 74070b6a6f81..8f5edcfb3ab1 100644
--- a/servo/src/components/main/layout/layout_task.rs
+++ b/servo/src/components/main/layout/layout_task.rs
@@ -17,6 +17,7 @@ use layout::flow::{PostorderFlowTraversal};
 use layout::flow;
 use layout::incremental::{RestyleDamage};
 use layout::util::{LayoutData, LayoutDataAccess, OpaqueNode};
+use layout::wrapper::LayoutNode;
 
 use extra::arc::{Arc, RWArc, MutexArc};
 use geom::point::Point2D;
@@ -28,7 +29,7 @@ use gfx::opts::Opts;
 use gfx::render_task::{RenderMsg, RenderChan, RenderLayer};
 use gfx::{render_task, color};
 use script::dom::event::ReflowEvent;
-use script::dom::node::{AbstractNode, LayoutDataRef, LayoutView, ElementNodeTypeId};
+use script::dom::node::{AbstractNode, ElementNodeTypeId, LayoutDataRef};
 use script::dom::element::{HTMLBodyElementTypeId, HTMLHtmlElementTypeId};
 use script::layout_interface::{AddStylesheetMsg, ContentBoxQuery};
 use script::layout_interface::{ContentBoxesQuery, ContentBoxesResponse, ExitNowMsg, LayoutQuery};
@@ -358,8 +359,7 @@ impl LayoutTask {
     /// is intertwined with selector matching, making it difficult to compare directly. It is
     /// marked `#[inline(never)]` to aid benchmarking in sampling profilers.
     #[inline(never)]
-    fn construct_flow_tree(&self, layout_context: &mut LayoutContext, node: AbstractNode<LayoutView>)
-                           -> ~Flow: {
+    fn construct_flow_tree(&self, layout_context: &mut LayoutContext, node: LayoutNode) -> ~Flow: {
         node.traverse_postorder_mut(&mut FlowConstructor::init(layout_context));
 
         let result = match *node.mutate_layout_data().ptr {
@@ -401,7 +401,7 @@ impl LayoutTask {
     /// The high-level routine that performs layout tasks.
     fn handle_reflow(&mut self, data: &Reflow) {
         // FIXME: Isolate this transmutation into a "bridge" module.
-        let node: &AbstractNode<LayoutView> = unsafe {
+        let node: &LayoutNode = unsafe {
             transmute(&data.document_root)
         };
 
@@ -534,7 +534,7 @@ impl LayoutTask {
             // The neat thing here is that in order to answer the following two queries we only
             // need to compare nodes for equality. Thus we can safely work only with `OpaqueNode`.
             ContentBoxQuery(node, reply_chan) => {
-                let node = OpaqueNode::from_node(&node);
+                let node = OpaqueNode::from_script_node(&node);
 
                 fn union_boxes_for_node<'a>(
                                         accumulator: &mut Option<Rect<Au>>,
@@ -557,7 +557,7 @@ impl LayoutTask {
                 reply_chan.send(ContentBoxResponse(rect.unwrap_or(Au::zero_rect())))
             }
             ContentBoxesQuery(node, reply_chan) => {
-                let node = OpaqueNode::from_node(&node);
+                let node = OpaqueNode::from_script_node(&node);
 
                 fn add_boxes_for_node<'a>(
                                       accumulator: &mut ~[Rect<Au>],
@@ -608,8 +608,8 @@ impl LayoutTask {
                             // incremental flow construction could create this. Paranoid validation
                             // against the set of valid nodes should occur in the script task to
                             // ensure that this is a valid address instead of transmuting here.
-                            let node: AbstractNode<LayoutView> = unsafe {
-                                item.base().extra.to_node()
+                            let node: AbstractNode = unsafe {
+                                item.base().extra.to_script_node()
                             };
                             let resp = Some(HitTestResponse(node));
                             return resp;
diff --git a/servo/src/components/main/layout/text.rs b/servo/src/components/main/layout/text.rs
index 457b014ed9c6..bc3059695d69 100644
--- a/servo/src/components/main/layout/text.rs
+++ b/servo/src/components/main/layout/text.rs
@@ -3,15 +3,16 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 //! Text layout.
-use extra::arc::Arc;
+
 use layout::box::{Box, ScannedTextBox, ScannedTextBoxInfo, UnscannedTextBox};
 use layout::context::LayoutContext;
 use layout::flow::Flow;
 
+use extra::arc::Arc;
 use gfx::text::text_run::TextRun;
 use gfx::text::util::{CompressWhitespaceNewline, transform_text};
-use std::vec;
 use servo_util::range::Range;
+use std::vec;
 
 /// A stack-allocated object for scanning an inline flow into `TextRun`-containing `TextBox`es.
 struct TextRunScanner {
diff --git a/servo/src/components/main/layout/util.rs b/servo/src/components/main/layout/util.rs
index 66681135b529..90c85acb1aac 100644
--- a/servo/src/components/main/layout/util.rs
+++ b/servo/src/components/main/layout/util.rs
@@ -4,9 +4,10 @@
 
 use layout::box::Box;
 use layout::construct::{ConstructionResult, NoConstructionResult};
+use layout::wrapper::LayoutNode;
 
 use extra::arc::Arc;
-use script::dom::node::{AbstractNode, LayoutView};
+use script::dom::node::AbstractNode;
 use servo_util::range::Range;
 use servo_util::slot::{MutSlotRef, SlotRef};
 use std::cast;
@@ -163,23 +164,23 @@ pub trait LayoutDataAccess {
     fn mutate_layout_data<'a>(&'a self) -> MutSlotRef<'a,Option<~LayoutData>>;
 }
 
-impl LayoutDataAccess for AbstractNode<LayoutView> {
+impl<'self> LayoutDataAccess for LayoutNode<'self> {
     #[inline(always)]
     unsafe fn borrow_layout_data_unchecked<'a>(&'a self) -> &'a Option<~LayoutData> {
-        cast::transmute(self.node().layout_data.borrow_unchecked())
+        cast::transmute(self.get().layout_data.borrow_unchecked())
     }
 
     #[inline(always)]
     fn borrow_layout_data<'a>(&'a self) -> SlotRef<'a,Option<~LayoutData>> {
         unsafe {
-            cast::transmute(self.node().layout_data.borrow())
+            cast::transmute(self.get().layout_data.borrow())
         }
     }
 
     #[inline(always)]
     fn mutate_layout_data<'a>(&'a self) -> MutSlotRef<'a,Option<~LayoutData>> {
         unsafe {
-            cast::transmute(self.node().layout_data.mutate())
+            cast::transmute(self.get().layout_data.mutate())
         }
     }
 }
@@ -193,25 +194,24 @@ impl LayoutDataAccess for AbstractNode<LayoutView> {
 #[deriving(Clone, Eq)]
 pub struct OpaqueNode(uintptr_t);
 
-impl<T> Equiv<AbstractNode<T>> for OpaqueNode {
-    fn equiv(&self, node: &AbstractNode<T>) -> bool {
-        unsafe {
-            **self == cast::transmute_copy::<AbstractNode<T>,uintptr_t>(node)
-        }
-    }
-}
-
 impl OpaqueNode {
-    /// Converts a DOM node to an `OpaqueNode`.
-    pub fn from_node<T>(node: &AbstractNode<T>) -> OpaqueNode {
+    /// Converts a DOM node (layout view) to an `OpaqueNode`.
+    pub fn from_layout_node(node: &LayoutNode) -> OpaqueNode {
         unsafe {
             OpaqueNode(cast::transmute_copy(node))
         }
     }
 
-    /// Unsafely converts an `OpaqueNode` to a DOM node. Use this only if you absolutely know what
-    /// you're doing.
-    pub unsafe fn to_node<T>(&self) -> AbstractNode<T> {
+    /// Converts a DOM node (script view) to an `OpaqueNode`.
+    pub fn from_script_node(node: &AbstractNode) -> OpaqueNode {
+        unsafe {
+            OpaqueNode(cast::transmute_copy(node))
+        }
+    }
+
+    /// Unsafely converts an `OpaqueNode` to a DOM node (script view). Use this only if you
+    /// absolutely know what you're doing.
+    pub unsafe fn to_script_node(&self) -> AbstractNode {
         cast::transmute(**self)
     }
 
diff --git a/servo/src/components/main/layout/wrapper.rs b/servo/src/components/main/layout/wrapper.rs
new file mode 100644
index 000000000000..6ab1504df853
--- /dev/null
+++ b/servo/src/components/main/layout/wrapper.rs
@@ -0,0 +1,397 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+//! A safe wrapper for DOM nodes that prevents layout from mutating the DOM, from letting DOM nodes
+//! escape, and from generally doing anything that it isn't supposed to. This is accomplished via
+//! a simple whitelist of allowed operations.
+//!
+//! As a security wrapper is only as good as its whitelist, be careful when adding operations to
+//! this list. The cardinal rules are:
+//!
+//! (1) Layout is not allowed to mutate the DOM.
+//!
+//! (2) Layout is not allowed to see anything with `Abstract` in the name, because it could hang
+//!     onto these objects and cause use-after-free.
+
+use extra::url::Url;
+use script::dom::element::{Element, HTMLAreaElementTypeId, HTMLAnchorElementTypeId};
+use script::dom::element::{HTMLLinkElementTypeId};
+use script::dom::htmliframeelement::HTMLIFrameElement;
+use script::dom::htmlimageelement::HTMLImageElement;
+use script::dom::node::{AbstractNode, DocumentNodeTypeId, ElementNodeTypeId, Node, NodeTypeId};
+use script::dom::text::Text;
+use servo_msg::constellation_msg::{PipelineId, SubpageId};
+use std::cast;
+use style::{PropertyDeclarationBlock, TElement, TNode};
+
+/// A wrapper so that layout can access only the methods that it should have access to. Layout must
+/// only ever see these and must never see instances of `AbstractNode`.
+#[deriving(Clone, Eq)]
+pub struct LayoutNode<'self> {
+    /// The wrapped node.
+    priv node: AbstractNode,
+
+    /// Being chained to a value prevents `LayoutNode`s from escaping.
+    priv chain: &'self (),
+}
+
+impl<'self> LayoutNode<'self> {
+    /// Creates a new layout node, scoped to the given closure.
+    pub unsafe fn with_layout_node<R>(node: AbstractNode, f: &fn<'a>(LayoutNode<'a>) -> R) -> R {
+        let heavy_iron_ball = ();
+        f(LayoutNode {
+            node: node,
+            chain: &heavy_iron_ball,
+        })
+    }
+
+    /// Creates a new layout node with the same lifetime as this layout node.
+    unsafe fn new_with_this_lifetime(&self, node: AbstractNode) -> LayoutNode<'self> {
+        LayoutNode {
+            node: node,
+            chain: self.chain,
+        }
+    }
+
+    /// Returns the interior of this node as a `Node`. This is highly unsafe for layout to call
+    /// and as such is marked `unsafe`.
+    pub unsafe fn get<'a>(&'a self) -> &'a Node {
+        cast::transmute(self.node.node())
+    }
+
+    /// Returns the first child of this node.
+    pub fn first_child(&self) -> Option<LayoutNode<'self>> {
+        unsafe {
+            self.node.first_child().map(|node| self.new_with_this_lifetime(node))
+        }
+    }
+
+    /// Returns the first child of this node.
+    pub fn last_child(&self) -> Option<LayoutNode<'self>> {
+        unsafe {
+            self.node.last_child().map(|node| self.new_with_this_lifetime(node))
+        }
+    }
+
+    /// Iterates over this node and all its descendants, in preorder.
+    ///
+    /// FIXME(pcwalton): Terribly inefficient. We should use parallelism.
+    pub fn traverse_preorder(&self) -> LayoutTreeIterator<'self> {
+        let mut nodes = ~[];
+        gather_layout_nodes(self, &mut nodes, false);
+        LayoutTreeIterator::new(nodes)
+    }
+
+    /// Returns an iterator over this node's children.
+    pub fn children(&self) -> LayoutNodeChildrenIterator<'self> {
+        LayoutNodeChildrenIterator {
+            current_node: self.first_child(),
+        }
+    }
+
+    /// Returns the type ID of this node. Fails if this node is borrowed mutably.
+    pub fn type_id(&self) -> NodeTypeId {
+        self.node.type_id()
+    }
+
+    /// If this is an image element, returns its URL. If this is not an image element, fails.
+    ///
+    /// FIXME(pcwalton): Don't copy URLs.
+    pub fn image_url(&self) -> Option<Url> {
+        unsafe {
+            self.with_image_element(|image_element| {
+                image_element.image.as_ref().map(|url| (*url).clone())
+            })
+        }
+    }
+
+    /// Downcasts this node to an image element and calls the given closure.
+    ///
+    /// FIXME(pcwalton): RAII.
+    unsafe fn with_image_element<R>(self, f: &fn(&HTMLImageElement) -> R) -> R {
+        if !self.node.is_image_element() {
+            fail!(~"node is not an image element");
+        }
+        self.node.transmute(f)
+    }
+
+    /// If this node is an iframe element, returns its pipeline and subpage IDs. If this node is
+    /// not an iframe element, fails.
+    pub fn iframe_pipeline_and_subpage_ids(&self) -> (PipelineId, SubpageId) {
+        unsafe {
+            self.with_iframe_element(|iframe_element| {
+                let size = iframe_element.size.unwrap();
+                (size.pipeline_id, size.subpage_id)
+            })
+        }
+    }
+
+    /// Downcasts this node to an iframe element and calls the given closure.
+    ///
+    /// FIXME(pcwalton): RAII.
+    unsafe fn with_iframe_element<R>(self, f: &fn(&HTMLIFrameElement) -> R) -> R {
+        if !self.node.is_iframe_element() {
+            fail!(~"node is not an iframe element");
+        }
+        self.node.transmute(f)
+    }
+
+    /// Returns true if this node is a text node or false otherwise.
+    #[inline]
+    pub fn is_text(self) -> bool {
+        self.node.is_text()
+    }
+
+    /// Returns true if this node consists entirely of ignorable whitespace and false otherwise.
+    /// Ignorable whitespace is defined as whitespace that would be removed per CSS 2.1 § 16.6.1.
+    pub fn is_ignorable_whitespace(&self) -> bool {
+        unsafe {
+            self.is_text() && self.with_text(|text| text.element.data.is_whitespace())
+        }
+    }
+
+    /// If this is a text node, copies out the text. If this is not a text node, fails.
+    ///
+    /// FIXME(pcwalton): Don't copy text. Atomically reference count instead.
+    pub fn text(&self) -> ~str {
+        unsafe {
+            self.with_text(|text| text.element.data.to_str())
+        }
+    }
+
+    /// Downcasts this node to a text node and calls the given closure.
+    ///
+    /// FIXME(pcwalton): RAII.
+    unsafe fn with_text<R>(self, f: &fn(&Text) -> R) -> R {
+        self.node.with_imm_text(f)
+    }
+
+    /// Dumps this node tree, for debugging.
+    pub fn dump(&self) {
+        self.node.dump()
+    }
+
+    /// Returns a string that describes this node, for debugging.
+    pub fn debug_str(&self) -> ~str {
+        self.node.debug_str()
+    }
+
+    /// Traverses the tree in postorder.
+    ///
+    /// TODO(pcwalton): Offer a parallel version with a compatible API.
+    pub fn traverse_postorder<T:PostorderNodeTraversal>(self, traversal: &T) -> bool {
+        if traversal.should_prune(self) {
+            return true
+        }
+
+        let mut opt_kid = self.first_child();
+        loop {
+            match opt_kid {
+                None => break,
+                Some(kid) => {
+                    if !kid.traverse_postorder(traversal) {
+                        return false
+                    }
+                    opt_kid = kid.next_sibling()
+                }
+            }
+        }
+
+        traversal.process(self)
+    }
+
+    /// Traverses the tree in postorder.
+    ///
+    /// TODO(pcwalton): Offer a parallel version with a compatible API.
+    pub fn traverse_postorder_mut<T:PostorderNodeMutTraversal>(mut self, traversal: &mut T)
+                                  -> bool {
+        if traversal.should_prune(self) {
+            return true
+        }
+
+        let mut opt_kid = self.first_child();
+        loop {
+            match opt_kid {
+                None => break,
+                Some(kid) => {
+                    if !kid.traverse_postorder_mut(traversal) {
+                        return false
+                    }
+                    opt_kid = kid.next_sibling()
+                }
+            }
+        }
+
+        traversal.process(self)
+    }
+}
+
+impl<'self> TNode<LayoutElement<'self>> for LayoutNode<'self> {
+    fn parent_node(&self) -> Option<LayoutNode<'self>> {
+        unsafe {
+            self.node.node().parent_node.map(|node| self.new_with_this_lifetime(node))
+        }
+    }
+
+    fn prev_sibling(&self) -> Option<LayoutNode<'self>> {
+        unsafe {
+            self.node.node().prev_sibling.map(|node| self.new_with_this_lifetime(node))
+        }
+    }
+    
+    fn next_sibling(&self) -> Option<LayoutNode<'self>> {
+        unsafe {
+            self.node.node().next_sibling.map(|node| self.new_with_this_lifetime(node))
+        }
+    }
+
+    fn is_element(&self) -> bool {
+        match self.node.type_id() {
+            ElementNodeTypeId(*) => true,
+            _ => false
+        }
+    }
+
+    fn is_document(&self) -> bool {
+        match self.node.type_id() {
+            DocumentNodeTypeId(*) => true,
+            _ => false
+        }
+    }
+
+    /// If this is an element, accesses the element data. Fails if this is not an element node.
+    #[inline]
+    fn with_element<R>(&self, f: &fn(&LayoutElement<'self>) -> R) -> R {
+        self.node.with_imm_element(|element| {
+            // FIXME(pcwalton): Workaround until Rust gets multiple lifetime parameters on
+            // implementations.
+            unsafe {
+                f(&LayoutElement {
+                    element: cast::transmute_region(element),
+                })
+            }
+        })
+    }
+}
+
+pub struct LayoutNodeChildrenIterator<'self> {
+    priv current_node: Option<LayoutNode<'self>>,
+}
+
+impl<'self> Iterator<LayoutNode<'self>> for LayoutNodeChildrenIterator<'self> {
+    fn next(&mut self) -> Option<LayoutNode<'self>> {
+        let node = self.current_node;
+        self.current_node = do self.current_node.and_then |node| {
+            node.next_sibling()
+        };
+        node
+    }
+}
+
+// FIXME: Do this without precomputing a vector of refs.
+// Easy for preorder; harder for postorder.
+//
+// FIXME(pcwalton): Parallelism! Eventually this should just be nuked.
+pub struct LayoutTreeIterator<'self> {
+    priv nodes: ~[LayoutNode<'self>],
+    priv index: uint,
+}
+
+impl<'self> LayoutTreeIterator<'self> {
+    fn new(nodes: ~[LayoutNode<'self>]) -> LayoutTreeIterator<'self> {
+        LayoutTreeIterator {
+            nodes: nodes,
+            index: 0,
+        }
+    }
+}
+
+impl<'self> Iterator<LayoutNode<'self>> for LayoutTreeIterator<'self> {
+    fn next(&mut self) -> Option<LayoutNode<'self>> {
+        if self.index >= self.nodes.len() {
+            None
+        } else {
+            let v = self.nodes[self.index].clone();
+            self.index += 1;
+            Some(v)
+        }
+    }
+}
+
+/// FIXME(pcwalton): This is super inefficient.
+fn gather_layout_nodes<'a>(cur: &LayoutNode<'a>, refs: &mut ~[LayoutNode<'a>], postorder: bool) {
+    if !postorder {
+        refs.push(cur.clone());
+    }
+    for kid in cur.children() {
+        gather_layout_nodes(&kid, refs, postorder)
+    }
+    if postorder {
+        refs.push(cur.clone());
+    }
+}
+
+/// A bottom-up, parallelizable traversal.
+pub trait PostorderNodeTraversal {
+    /// The operation to perform. Return true to continue or false to stop.
+    fn process<'a>(&'a self, node: LayoutNode<'a>) -> bool;
+
+    /// Returns true if this node should be pruned. If this returns true, we skip the operation
+    /// entirely and do not process any descendant nodes. This is called *before* child nodes are
+    /// visited. The default implementation never prunes any nodes.
+    fn should_prune<'a>(&'a self, _node: LayoutNode<'a>) -> bool {
+        false
+    }
+}
+
+/// A bottom-up, parallelizable traversal.
+pub trait PostorderNodeMutTraversal {
+    /// The operation to perform. Return true to continue or false to stop.
+    fn process<'a>(&'a mut self, node: LayoutNode<'a>) -> bool;
+
+    /// Returns true if this node should be pruned. If this returns true, we skip the operation
+    /// entirely and do not process any descendant nodes. This is called *before* child nodes are
+    /// visited. The default implementation never prunes any nodes.
+    fn should_prune<'a>(&'a self, _node: LayoutNode<'a>) -> bool {
+        false
+    }
+}
+
+/// A wrapper around elements that ensures layout can only ever access safe properties.
+pub struct LayoutElement<'self> {
+    priv element: &'self Element,
+}
+
+impl<'self> LayoutElement<'self> {
+    pub fn style_attribute(&self) -> &'self Option<PropertyDeclarationBlock> {
+        &self.element.style_attribute
+    }
+}
+
+impl<'self> TElement for LayoutElement<'self> {
+    fn get_local_name<'a>(&'a self) -> &'a str {
+        self.element.tag_name.as_slice()
+    }
+
+    fn get_namespace_url<'a>(&'a self) -> &'a str {
+        self.element.namespace.to_str().unwrap_or("")
+    }
+
+    fn get_attr(&self, ns_url: Option<~str>, name: &str) -> Option<~str> {
+        self.element.get_attr(ns_url, name)
+    }
+
+    fn get_link(&self) -> Option<~str> {
+        // FIXME: This is HTML only.
+        match self.element.node.type_id {
+            // http://www.whatwg.org/specs/web-apps/current-work/multipage/selectors.html#
+            // selector-link
+            ElementNodeTypeId(HTMLAnchorElementTypeId) |
+            ElementNodeTypeId(HTMLAreaElementTypeId) |
+            ElementNodeTypeId(HTMLLinkElementTypeId) => self.get_attr(None, "href"),
+            _ => None,
+        }
+    }
+}
+
diff --git a/servo/src/components/main/servo.rc b/servo/src/components/main/servo.rc
index e6584df38c74..cc451b4e7ce9 100755
--- a/servo/src/components/main/servo.rc
+++ b/servo/src/components/main/servo.rc
@@ -88,6 +88,7 @@ pub mod layout {
     pub mod text;
     pub mod util;
     pub mod incremental;
+    pub mod wrapper;
     mod extra;
 }
 
diff --git a/servo/src/components/script/dom/attrlist.rs b/servo/src/components/script/dom/attrlist.rs
index 48f74be69d5c..450a6830e8b3 100644
--- a/servo/src/components/script/dom/attrlist.rs
+++ b/servo/src/components/script/dom/attrlist.rs
@@ -5,18 +5,17 @@
 use dom::attr::Attr;
 use dom::bindings::codegen::AttrListBinding;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::node::{AbstractNode, ScriptView};
+use dom::node::{AbstractNode};
 use dom::window::Window;
 
 pub struct AttrList {
     reflector_: Reflector,
     window: @mut Window,
-    owner: AbstractNode<ScriptView>
+    owner: AbstractNode,
 }
 
 impl AttrList {
-        pub fn new_inherited(window: @mut Window,
-                             elem: AbstractNode<ScriptView>) -> AttrList {
+    pub fn new_inherited(window: @mut Window, elem: AbstractNode) -> AttrList {
         AttrList {
             reflector_: Reflector::new(),
             window: window,
@@ -24,7 +23,7 @@ impl AttrList {
         }
     }
 
-    pub fn new(window: @mut Window, elem: AbstractNode<ScriptView>) -> @mut AttrList {
+    pub fn new(window: @mut Window, elem: AbstractNode) -> @mut AttrList {
         reflect_dom_object(@mut AttrList::new_inherited(window, elem),
                            window, AttrListBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/bindings/codegen/Bindings.conf b/servo/src/components/script/dom/bindings/codegen/Bindings.conf
index 18665606bba0..b7e01242793a 100644
--- a/servo/src/components/script/dom/bindings/codegen/Bindings.conf
+++ b/servo/src/components/script/dom/bindings/codegen/Bindings.conf
@@ -121,7 +121,7 @@ DOMInterfaces = {
 }],
 
 'CharacterData': {
-    'nativeType': 'AbstractNode<ScriptView>',
+    'nativeType': 'AbstractNode',
     'concreteType': 'CharacterData',
     'pointerType': ''
 },
@@ -182,7 +182,7 @@ DOMInterfaces = {
 }],
 
 'Element': {
-    'nativeType': 'AbstractNode<ScriptView>',
+    'nativeType': 'AbstractNode',
     'pointerType': '',
     'needsAbstract': ['getClientRects', 'getBoundingClientRect', 'setAttribute', 'setAttributeNS', 'id', 'attributes']
 },
@@ -239,7 +239,7 @@ DOMInterfaces = {
 },
 
 'HTMLFormElement': {
-    'nativeType': 'AbstractNode<ScriptView>',
+    'nativeType': 'AbstractNode',
     'pointerType': '',
     'register': False
 },
@@ -302,8 +302,8 @@ DOMInterfaces = {
 },
 
 'Node': {
-    'nativeType': 'AbstractNode<ScriptView>',
-    'concreteType': 'Node<ScriptView>',
+    'nativeType': 'AbstractNode',
+    'concreteType': 'Node',
     'pointerType': '',
     'needsAbstract': [
         'appendChild',
@@ -574,7 +574,7 @@ def addExternalIface(iface, nativeType=None, headerFile=None, pointerType=None):
 
 def addHTMLElement(element, concrete=None, needsAbstract=[]):
   DOMInterfaces[element] = {
-    'nativeType': 'AbstractNode<ScriptView>',
+    'nativeType': 'AbstractNode',
     'pointerType': '',
     'concreteType': concrete if concrete else element,
     'customTrace': 'trace',
diff --git a/servo/src/components/script/dom/bindings/codegen/CodegenRust.py b/servo/src/components/script/dom/bindings/codegen/CodegenRust.py
index 23359cae5fc9..b426c2989edf 100644
--- a/servo/src/components/script/dom/bindings/codegen/CodegenRust.py
+++ b/servo/src/components/script/dom/bindings/codegen/CodegenRust.py
@@ -5161,7 +5161,7 @@ class CGBindingRoot(CGThing):
                           'dom::bindings::proxyhandler',
                           'dom::bindings::proxyhandler::*',
                           'dom::document::AbstractDocument',
-                          'dom::node::{AbstractNode, ScriptView}',
+                          'dom::node::AbstractNode',
                           'dom::eventtarget::AbstractEventTarget',
                           'dom::event::AbstractEvent',
                           'servo_util::vec::zip_copies',
diff --git a/servo/src/components/script/dom/bindings/node.rs b/servo/src/components/script/dom/bindings/node.rs
index 6a009a9bac41..cdc4c58bce0b 100644
--- a/servo/src/components/script/dom/bindings/node.rs
+++ b/servo/src/components/script/dom/bindings/node.rs
@@ -4,14 +4,14 @@
 
 use dom::bindings::utils::{Reflectable, Reflector, Traceable};
 use dom::types::*;
-use dom::node::{AbstractNode, ScriptView};
+use dom::node::AbstractNode;
 
 use std::cast;
 use std::libc;
 use std::ptr;
 use js::jsapi::{JSTracer, JSTRACE_OBJECT, JS_CallTracer};
 
-impl Reflectable for AbstractNode<ScriptView> {
+impl Reflectable for AbstractNode {
     fn reflector<'a>(&'a self) -> &'a Reflector {
         self.node().reflector()
     }
@@ -21,10 +21,10 @@ impl Reflectable for AbstractNode<ScriptView> {
     }
 }
 
-impl Traceable for Node<ScriptView> {
+impl Traceable for Node {
     fn trace(&self, tracer: *mut JSTracer) {
         #[fixed_stack_segment]
-        fn trace_node(tracer: *mut JSTracer, node: Option<AbstractNode<ScriptView>>, name: &str) {
+        fn trace_node(tracer: *mut JSTracer, node: Option<AbstractNode>, name: &str) {
             if node.is_none() {
                 return;
             }
diff --git a/servo/src/components/script/dom/characterdata.rs b/servo/src/components/script/dom/characterdata.rs
index dbdf67f92c52..bf3c81fd0c5e 100644
--- a/servo/src/components/script/dom/characterdata.rs
+++ b/servo/src/components/script/dom/characterdata.rs
@@ -7,10 +7,10 @@
 use dom::bindings::utils::{DOMString, ErrorResult, Fallible};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::AbstractDocument;
-use dom::node::{Node, NodeTypeId, ScriptView};
+use dom::node::{Node, NodeTypeId};
 
 pub struct CharacterData {
-    node: Node<ScriptView>,
+    node: Node,
     data: ~str
 }
 
diff --git a/servo/src/components/script/dom/comment.rs b/servo/src/components/script/dom/comment.rs
index bae0ba0f66bd..1d42d28b97f5 100644
--- a/servo/src/components/script/dom/comment.rs
+++ b/servo/src/components/script/dom/comment.rs
@@ -6,7 +6,7 @@ use dom::bindings::codegen::CommentBinding;
 use dom::bindings::utils::{DOMString, Fallible};
 use dom::characterdata::CharacterData;
 use dom::document::AbstractDocument;
-use dom::node::{AbstractNode, ScriptView, CommentNodeTypeId, Node};
+use dom::node::{AbstractNode, CommentNodeTypeId, Node};
 use dom::window::Window;
 
 /// An HTML comment.
@@ -21,12 +21,12 @@ impl Comment {
         }
     }
 
-    pub fn new(text: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(text: ~str, document: AbstractDocument) -> AbstractNode {
         let node = Comment::new_inherited(text, document);
         Node::reflect_node(@mut node, document, CommentBinding::Wrap)
     }
 
-    pub fn Constructor(owner: @mut Window, data: DOMString) -> Fallible<AbstractNode<ScriptView>> {
+    pub fn Constructor(owner: @mut Window, data: DOMString) -> Fallible<AbstractNode> {
         Ok(Comment::new(data, owner.Document()))
     }
 }
diff --git a/servo/src/components/script/dom/document.rs b/servo/src/components/script/dom/document.rs
index cd3bb5785070..0e366f76a805 100644
--- a/servo/src/components/script/dom/document.rs
+++ b/servo/src/components/script/dom/document.rs
@@ -15,7 +15,7 @@ use dom::event::{AbstractEvent, Event};
 use dom::htmlcollection::HTMLCollection;
 use dom::htmldocument::HTMLDocument;
 use dom::mouseevent::MouseEvent;
-use dom::node::{AbstractNode, ScriptView, Node, ElementNodeTypeId, DocumentNodeTypeId};
+use dom::node::{AbstractNode, Node, ElementNodeTypeId, DocumentNodeTypeId};
 use dom::text::Text;
 use dom::uievent::UIEvent;
 use dom::window::Window;
@@ -29,7 +29,6 @@ use std::cast;
 use std::hashmap::HashMap;
 use std::str::eq_slice;
 use std::unstable::raw::Box;
-use style::{TElement, TNode};
 
 #[deriving(Eq)]
 pub enum DocumentTypeId {
@@ -87,12 +86,12 @@ pub enum DocumentType {
 }
 
 pub struct Document {
-    node: Node<ScriptView>,
+    node: Node,
     reflector_: Reflector,
     window: @mut Window,
     doctype: DocumentType,
     title: ~str,
-    idmap: HashMap<DOMString, AbstractNode<ScriptView>>
+    idmap: HashMap<DOMString, AbstractNode>
 }
 
 impl Document {
@@ -161,7 +160,7 @@ impl Reflectable for Document {
 }
 
 impl Document {
-    pub fn GetDocumentElement(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetDocumentElement(&self) -> Option<AbstractNode> {
         do self.node.children().find |c| {
             c.is_element()
         }
@@ -183,7 +182,7 @@ impl Document {
         HTMLCollection::new(self.window, ~[])
     }
 
-    pub fn GetElementById(&self, id: DOMString) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetElementById(&self, id: DOMString) -> Option<AbstractNode> {
         // TODO: "in tree order, within the context object's tree"
         // http://dom.spec.whatwg.org/#dom-document-getelementbyid.
         match self.idmap.find_equiv(&id) {
@@ -192,7 +191,8 @@ impl Document {
         }
     }
 
-    pub fn CreateElement(&self, abstract_self: AbstractDocument, local_name: DOMString) -> Fallible<AbstractNode<ScriptView>> {
+    pub fn CreateElement(&self, abstract_self: AbstractDocument, local_name: DOMString)
+                         -> Fallible<AbstractNode> {
         if xml_name_type(local_name) == InvalidXMLName {
             debug!("Not a valid element name");
             return Err(InvalidCharacter);
@@ -201,15 +201,16 @@ impl Document {
         Ok(build_element_from_tag(local_name, abstract_self))
     }
 
-    pub fn CreateDocumentFragment(&self, abstract_self: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn CreateDocumentFragment(&self, abstract_self: AbstractDocument) -> AbstractNode {
         DocumentFragment::new(abstract_self)
     }
 
-    pub fn CreateTextNode(&self, abstract_self: AbstractDocument, data: DOMString) -> AbstractNode<ScriptView> {
+    pub fn CreateTextNode(&self, abstract_self: AbstractDocument, data: DOMString)
+                          -> AbstractNode {
         Text::new(data, abstract_self)
     }
 
-    pub fn CreateComment(&self, abstract_self: AbstractDocument, data: DOMString) -> AbstractNode<ScriptView> {
+    pub fn CreateComment(&self, abstract_self: AbstractDocument, data: DOMString) -> AbstractNode {
         Comment::new(data, abstract_self)
     }
 
@@ -330,15 +331,15 @@ impl Document {
         self.window.wait_until_safe_to_modify_dom();
     }
 
-    pub fn register_nodes_with_id(&mut self, root: &AbstractNode<ScriptView>) {
-        foreach_ided_elements(root, |id: &DOMString, abstract_node: &AbstractNode<ScriptView>| {
+    pub fn register_nodes_with_id(&mut self, root: &AbstractNode) {
+        foreach_ided_elements(root, |id: &DOMString, abstract_node: &AbstractNode| {
             // TODO: "in tree order, within the context object's tree"
             // http://dom.spec.whatwg.org/#dom-document-getelementbyid.
             self.idmap.find_or_insert(id.clone(), *abstract_node);
         });
     }
 
-    pub fn unregister_nodes_with_id(&mut self, root: &AbstractNode<ScriptView>) {
+    pub fn unregister_nodes_with_id(&mut self, root: &AbstractNode) {
         foreach_ided_elements(root, |id: &DOMString, _| {
             // TODO: "in tree order, within the context object's tree"
             // http://dom.spec.whatwg.org/#dom-document-getelementbyid.
@@ -347,7 +348,7 @@ impl Document {
     }
 
     pub fn update_idmap(&mut self,
-                        abstract_self: AbstractNode<ScriptView>,
+                        abstract_self: AbstractNode,
                         new_id: DOMString,
                         old_id: Option<DOMString>) {
         // remove old ids if the old ones are not same as the new one.
@@ -359,19 +360,17 @@ impl Document {
         }
 
         // TODO: support the case if multiple elements which haves same id are in the same document.
-        self.idmap.mangle(new_id, abstract_self,
-                         |_, new_node: AbstractNode<ScriptView>| -> AbstractNode<ScriptView> {
+        self.idmap.mangle(new_id, abstract_self, |_, new_node: AbstractNode| -> AbstractNode {
                              new_node
                          },
-                         |_, old_node: &mut AbstractNode<ScriptView>, new_node: AbstractNode<ScriptView>| {
+                         |_, old_node: &mut AbstractNode, new_node: AbstractNode| {
                              *old_node = new_node;
                          });
     }
 }
 
 #[inline(always)]
-fn foreach_ided_elements(root: &AbstractNode<ScriptView>,
-                         callback: &fn(&DOMString, &AbstractNode<ScriptView>)) {
+fn foreach_ided_elements(root: &AbstractNode, callback: &fn(&DOMString, &AbstractNode)) {
     for node in root.traverse_preorder() {
         if !node.is_element() {
             continue;
diff --git a/servo/src/components/script/dom/documentfragment.rs b/servo/src/components/script/dom/documentfragment.rs
index 1f4e6a351137..0b4c56d2c92b 100644
--- a/servo/src/components/script/dom/documentfragment.rs
+++ b/servo/src/components/script/dom/documentfragment.rs
@@ -5,12 +5,11 @@
 use dom::bindings::codegen::DocumentFragmentBinding;
 use dom::bindings::utils::Fallible;
 use dom::document::AbstractDocument;
-use dom::node::{ScriptView, Node, DocumentFragmentNodeTypeId};
-use dom::node::{AbstractNode};
+use dom::node::{AbstractNode, DocumentFragmentNodeTypeId, Node};
 use dom::window::Window;
 
 pub struct DocumentFragment {
-    node: Node<ScriptView>,
+    node: Node,
 }
 
 impl DocumentFragment {
@@ -21,14 +20,14 @@ impl DocumentFragment {
         }
     }
 
-    pub fn new(document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(document: AbstractDocument) -> AbstractNode {
         let node = DocumentFragment::new_inherited(document);
         Node::reflect_node(@mut node, document, DocumentFragmentBinding::Wrap)
     }
 }
 
 impl DocumentFragment {
-    pub fn Constructor(owner: @mut Window) -> Fallible<AbstractNode<ScriptView>> {
+    pub fn Constructor(owner: @mut Window) -> Fallible<AbstractNode> {
         Ok(DocumentFragment::new(owner.Document()))
     }
 }
diff --git a/servo/src/components/script/dom/documenttype.rs b/servo/src/components/script/dom/documenttype.rs
index 9c4d6a750fa3..66e731e724b5 100644
--- a/servo/src/components/script/dom/documenttype.rs
+++ b/servo/src/components/script/dom/documenttype.rs
@@ -5,11 +5,11 @@
 use dom::bindings::codegen::DocumentTypeBinding;
 use dom::bindings::utils::DOMString;
 use dom::document::AbstractDocument;
-use dom::node::{AbstractNode, ScriptView, Node, DoctypeNodeTypeId};
+use dom::node::{AbstractNode, Node, DoctypeNodeTypeId};
 
 /// The `DOCTYPE` tag.
 pub struct DocumentType {
-    node: Node<ScriptView>,
+    node: Node,
     name: DOMString,
     public_id: DOMString,
     system_id: DOMString,
@@ -36,7 +36,8 @@ impl DocumentType {
                public_id: Option<~str>,
                system_id: Option<~str>,
                force_quirks: bool,
-               document: AbstractDocument) -> AbstractNode<ScriptView> {
+               document: AbstractDocument)
+               -> AbstractNode {
         let documenttype = DocumentType::new_inherited(name,
                                                        public_id,
                                                        system_id,
diff --git a/servo/src/components/script/dom/element.rs b/servo/src/components/script/dom/element.rs
index 001cd3e34f96..31dd20596f44 100644
--- a/servo/src/components/script/dom/element.rs
+++ b/servo/src/components/script/dom/element.rs
@@ -4,6 +4,7 @@
 
 //! Element nodes.
 
+use dom::attr::Attr;
 use dom::attrlist::AttrList;
 use dom::bindings::utils::{Reflectable, DOMString, ErrorResult, Fallible, Reflector};
 use dom::bindings::utils::{null_str_as_empty, NamespaceError};
@@ -12,15 +13,13 @@ use dom::htmlcollection::HTMLCollection;
 use dom::clientrect::ClientRect;
 use dom::clientrectlist::ClientRectList;
 use dom::document::AbstractDocument;
-use dom::node::{ElementNodeTypeId, Node, ScriptView, AbstractNode};
-use dom::attr:: Attr;
+use dom::node::{AbstractNode, ElementNodeTypeId, Node};
 use dom::document;
 use dom::namespace;
 use dom::namespace::Namespace;
 use layout_interface::{ContentBoxQuery, ContentBoxResponse, ContentBoxesQuery};
 use layout_interface::{ContentBoxesResponse, ContentChangedDocumentDamage};
 use layout_interface::{MatchSelectorsDocumentDamage};
-use style::{TElement, TNode};
 use style;
 
 use std::comm;
@@ -29,7 +28,7 @@ use std::str::{eq, eq_slice};
 use std::ascii::StrAsciiExt;
 
 pub struct Element {
-    node: Node<ScriptView>,
+    node: Node,
     tag_name: ~str,     // TODO: This should be an atom, not a ~str.
     namespace: Namespace,
     attrs: HashMap<~str, ~[@mut Attr]>,
@@ -125,31 +124,6 @@ pub enum ElementTypeId {
 // Element methods
 //
 
-impl TElement for Element {
-    fn get_local_name<'a>(&'a self) -> &'a str {
-        self.tag_name.as_slice()
-    }
-
-    fn get_namespace_url<'a>(&'a self) -> &'a str {
-        self.namespace.to_str().unwrap_or("")
-    }
-
-    fn get_attr(&self, ns_url: Option<~str>, name: &str) -> Option<~str> {
-        self.get_attribute(ns_url, name).map(|attr| attr.value.clone())
-    }
-
-    fn get_link(&self) -> Option<~str>{
-        // FIXME: This is HTML only.
-        match self.node.type_id {
-            // http://www.whatwg.org/specs/web-apps/current-work/multipage/selectors.html#selector-link
-            ElementNodeTypeId(HTMLAnchorElementTypeId) |
-            ElementNodeTypeId(HTMLAreaElementTypeId) |
-            ElementNodeTypeId(HTMLLinkElementTypeId)
-            => self.get_attr(None, "href"),
-            _ => None,
-        }
-    }
-}
 
 impl<'self> Element {
     pub fn new_inherited(type_id: ElementTypeId, tag_name: ~str, namespace: Namespace, document: AbstractDocument) -> Element {
@@ -187,15 +161,18 @@ impl<'self> Element {
         })
     }
 
-    pub fn set_attr(&mut self,
-                    abstract_self: AbstractNode<ScriptView>,
-                    name: DOMString,
-                    value: DOMString) -> ErrorResult {
+    // FIXME(pcwalton): This is kind of confusingly named relative to the above...
+    pub fn get_attr(&self, ns_url: Option<~str>, name: &str) -> Option<~str> {
+        self.get_attribute(ns_url, name).map(|attr| attr.value.clone())
+    }
+
+    pub fn set_attr(&mut self, abstract_self: AbstractNode, name: DOMString, value: DOMString)
+                    -> ErrorResult {
         self.set_attribute(abstract_self, namespace::Null, name, value)
     }
 
     pub fn set_attribute(&mut self,
-                         abstract_self: AbstractNode<ScriptView>,
+                         abstract_self: AbstractNode,
                          namespace: Namespace,
                          raw_name: DOMString,
                          value: DOMString) -> ErrorResult {
@@ -260,7 +237,7 @@ impl<'self> Element {
     }
 
     fn after_set_attr(&mut self,
-                      abstract_self: AbstractNode<ScriptView>,
+                      abstract_self: AbstractNode,
                       local_name: DOMString,
                       value: DOMString,
                       old_value: Option<DOMString>) {
@@ -309,18 +286,18 @@ impl Element {
         self.tag_name.to_ascii_upper()
     }
 
-    pub fn Id(&self, _abstract_self: AbstractNode<ScriptView>) -> DOMString {
+    pub fn Id(&self, _abstract_self: AbstractNode) -> DOMString {
         match self.get_attr(None, "id") {
             Some(x) => x,
             None => ~""
         }
     }
 
-    pub fn SetId(&mut self, abstract_self: AbstractNode<ScriptView>, id: DOMString) {
+    pub fn SetId(&mut self, abstract_self: AbstractNode, id: DOMString) {
         self.set_attribute(abstract_self, namespace::Null, ~"id", id);
     }
 
-    pub fn Attributes(&mut self, abstract_self: AbstractNode<ScriptView>) -> @mut AttrList {
+    pub fn Attributes(&mut self, abstract_self: AbstractNode) -> @mut AttrList {
         match self.attr_list {
             None => {
                 let window = self.node.owner_doc().document().window;
@@ -341,16 +318,14 @@ impl Element {
             .map(|attr| attr.value.clone())
     }
 
-    pub fn SetAttribute(&mut self,
-                        abstract_self: AbstractNode<ScriptView>,
-                        name: DOMString,
-                        value: DOMString) -> ErrorResult {
+    pub fn SetAttribute(&mut self, abstract_self: AbstractNode, name: DOMString, value: DOMString)
+                        -> ErrorResult {
         self.set_attr(abstract_self, name, value);
         Ok(())
     }
 
     pub fn SetAttributeNS(&mut self,
-                          abstract_self: AbstractNode<ScriptView>,
+                          abstract_self: AbstractNode,
                           namespace_url: Option<DOMString>,
                           name: DOMString,
                           value: DOMString) -> ErrorResult {
@@ -409,7 +384,7 @@ impl Element {
     pub fn MozRequestPointerLock(&self) {
     }
 
-    pub fn GetClientRects(&self, abstract_self: AbstractNode<ScriptView>) -> @mut ClientRectList {
+    pub fn GetClientRects(&self, abstract_self: AbstractNode) -> @mut ClientRectList {
         let win = self.node.owner_doc().document().window;
         let node = abstract_self;
         assert!(node.is_element());
@@ -431,7 +406,7 @@ impl Element {
         ClientRectList::new(win, rects)
     }
 
-    pub fn GetBoundingClientRect(&self, abstract_self: AbstractNode<ScriptView>) -> @mut ClientRect {
+    pub fn GetBoundingClientRect(&self, abstract_self: AbstractNode) -> @mut ClientRect {
         let win = self.node.owner_doc().document().window;
         let node = abstract_self;
         assert!(node.is_element());
@@ -509,7 +484,7 @@ impl Element {
         Ok(())
     }
 
-    pub fn QuerySelector(&self, _selectors: DOMString) -> Fallible<Option<AbstractNode<ScriptView>>> {
+    pub fn QuerySelector(&self, _selectors: DOMString) -> Fallible<Option<AbstractNode>> {
         Ok(None)
     }
 }
diff --git a/servo/src/components/script/dom/eventtarget.rs b/servo/src/components/script/dom/eventtarget.rs
index a47d780b3bfc..d3768ed656ec 100644
--- a/servo/src/components/script/dom/eventtarget.rs
+++ b/servo/src/components/script/dom/eventtarget.rs
@@ -8,7 +8,7 @@ use dom::bindings::codegen::EventListenerBinding::EventListener;
 use dom::document::AbstractDocument;
 use dom::event::AbstractEvent;
 use dom::eventdispatcher::dispatch_event;
-use dom::node::{AbstractNode, ScriptView};
+use dom::node::AbstractNode;
 use dom::window::Window;
 
 use std::cast;
@@ -50,7 +50,7 @@ impl AbstractEventTarget {
         }
     }
 
-    pub fn from_node(node: AbstractNode<ScriptView>) -> AbstractEventTarget {
+    pub fn from_node(node: AbstractNode) -> AbstractEventTarget {
         unsafe {
             cast::transmute(node)
         }
diff --git a/servo/src/components/script/dom/formdata.rs b/servo/src/components/script/dom/formdata.rs
index 1ee68db74fb6..3722fb3e9ca0 100644
--- a/servo/src/components/script/dom/formdata.rs
+++ b/servo/src/components/script/dom/formdata.rs
@@ -6,7 +6,7 @@ use dom::bindings::utils::{Fallible, Reflectable, Reflector, reflect_dom_object}
 use dom::bindings::utils::DOMString;
 use dom::bindings::codegen::FormDataBinding;
 use dom::blob::Blob;
-use dom::node::{AbstractNode, ScriptView};
+use dom::node::AbstractNode;
 use dom::window::Window;
 
 use std::hashmap::HashMap;
@@ -20,11 +20,11 @@ pub struct FormData {
     data: HashMap<~str, FormDatum>,
     reflector_: Reflector,
     window: @mut Window,
-    form: Option<AbstractNode<ScriptView>>
+    form: Option<AbstractNode>
 }
 
 impl FormData {
-    pub fn new_inherited(form: Option<AbstractNode<ScriptView>>, window: @mut Window) -> FormData {
+    pub fn new_inherited(form: Option<AbstractNode>, window: @mut Window) -> FormData {
         FormData {
             data: HashMap::new(),
             reflector_: Reflector::new(),
@@ -33,12 +33,12 @@ impl FormData {
         }
     }
 
-    pub fn new(form: Option<AbstractNode<ScriptView>>, window: @mut Window) -> @mut FormData {
+    pub fn new(form: Option<AbstractNode>, window: @mut Window) -> @mut FormData {
         reflect_dom_object(@mut FormData::new_inherited(form, window), window, FormDataBinding::Wrap)
     }
 
-    pub fn Constructor(window: @mut Window,
-                       form: Option<AbstractNode<ScriptView>>) -> Fallible<@mut FormData> {
+    pub fn Constructor(window: @mut Window, form: Option<AbstractNode>)
+                       -> Fallible<@mut FormData> {
         Ok(FormData::new(form, window))
     }
 
diff --git a/servo/src/components/script/dom/htmlanchorelement.rs b/servo/src/components/script/dom/htmlanchorelement.rs
index 17f3db7bb674..db1d68472d22 100644
--- a/servo/src/components/script/dom/htmlanchorelement.rs
+++ b/servo/src/components/script/dom/htmlanchorelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLAnchorElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLAnchorElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLAnchorElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLAnchorElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLAnchorElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlappletelement.rs b/servo/src/components/script/dom/htmlappletelement.rs
index e21460eeae39..5d5a9f5df5d0 100644
--- a/servo/src/components/script/dom/htmlappletelement.rs
+++ b/servo/src/components/script/dom/htmlappletelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLAppletElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLAppletElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLAppletElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLAppletElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLAppletElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlareaelement.rs b/servo/src/components/script/dom/htmlareaelement.rs
index 13df0e4fe49b..cb088d525424 100644
--- a/servo/src/components/script/dom/htmlareaelement.rs
+++ b/servo/src/components/script/dom/htmlareaelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLAreaElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLAreaElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLAreaElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLAreaElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLAreaElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlaudioelement.rs b/servo/src/components/script/dom/htmlaudioelement.rs
index 6ece4235c7c6..45f2e9af340c 100644
--- a/servo/src/components/script/dom/htmlaudioelement.rs
+++ b/servo/src/components/script/dom/htmlaudioelement.rs
@@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLAudioElementBinding;
 use dom::document::AbstractDocument;
 use dom::element::HTMLAudioElementTypeId;
 use dom::htmlmediaelement::HTMLMediaElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLAudioElement {
     htmlmediaelement: HTMLMediaElement
@@ -19,7 +19,7 @@ impl HTMLAudioElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLAudioElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLAudioElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlbaseelement.rs b/servo/src/components/script/dom/htmlbaseelement.rs
index 97970b1128de..10d07f226c50 100644
--- a/servo/src/components/script/dom/htmlbaseelement.rs
+++ b/servo/src/components/script/dom/htmlbaseelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLBaseElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLBaseElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLBaseElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLBaseElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLBaseElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlbodyelement.rs b/servo/src/components/script/dom/htmlbodyelement.rs
index 10d5ebb3dab8..944d09ce3b20 100644
--- a/servo/src/components/script/dom/htmlbodyelement.rs
+++ b/servo/src/components/script/dom/htmlbodyelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLBodyElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLBodyElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLBodyElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLBodyElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLBodyElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlbrelement.rs b/servo/src/components/script/dom/htmlbrelement.rs
index 6fe7748467c5..51e04f07d58f 100644
--- a/servo/src/components/script/dom/htmlbrelement.rs
+++ b/servo/src/components/script/dom/htmlbrelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLBRElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLBRElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLBRElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLBRElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLBRElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlbuttonelement.rs b/servo/src/components/script/dom/htmlbuttonelement.rs
index 963d9524cee6..95b162acaa6a 100644
--- a/servo/src/components/script/dom/htmlbuttonelement.rs
+++ b/servo/src/components/script/dom/htmlbuttonelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLButtonElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 use dom::validitystate::ValidityState;
 
 pub struct HTMLButtonElement {
@@ -21,7 +21,7 @@ impl HTMLButtonElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLButtonElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLButtonElementBinding::Wrap)
     }
@@ -44,7 +44,7 @@ impl HTMLButtonElement {
         Ok(())
     }
 
-    pub fn GetForm(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetForm(&self) -> Option<AbstractNode> {
         None
     }
 
diff --git a/servo/src/components/script/dom/htmlcanvaselement.rs b/servo/src/components/script/dom/htmlcanvaselement.rs
index 4c789163d72c..086c859447af 100644
--- a/servo/src/components/script/dom/htmlcanvaselement.rs
+++ b/servo/src/components/script/dom/htmlcanvaselement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLCanvasElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLCanvasElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLCanvasElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLCanvasElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLCanvasElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlcollection.rs b/servo/src/components/script/dom/htmlcollection.rs
index 204c1a23501c..f374d5bd70ee 100644
--- a/servo/src/components/script/dom/htmlcollection.rs
+++ b/servo/src/components/script/dom/htmlcollection.rs
@@ -5,7 +5,7 @@
 use dom::bindings::codegen::HTMLCollectionBinding;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::utils::{DOMString, Fallible};
-use dom::node::{AbstractNode, ScriptView};
+use dom::node::AbstractNode;
 use dom::window::Window;
 
 use js::jsapi::{JSObject, JSContext};
@@ -13,14 +13,13 @@ use js::jsapi::{JSObject, JSContext};
 use std::ptr;
 
 pub struct HTMLCollection {
-    elements: ~[AbstractNode<ScriptView>],
+    elements: ~[AbstractNode],
     reflector_: Reflector,
     window: @mut Window,
 }
 
 impl HTMLCollection {
-    pub fn new_inherited(window: @mut Window,
-                         elements: ~[AbstractNode<ScriptView>]) -> HTMLCollection {
+    pub fn new_inherited(window: @mut Window, elements: ~[AbstractNode]) -> HTMLCollection {
         HTMLCollection {
             elements: elements,
             reflector_: Reflector::new(),
@@ -28,8 +27,7 @@ impl HTMLCollection {
         }
     }
 
-    pub fn new(window: @mut Window,
-               elements: ~[AbstractNode<ScriptView>]) -> @mut HTMLCollection {
+    pub fn new(window: @mut Window, elements: ~[AbstractNode]) -> @mut HTMLCollection {
         reflect_dom_object(@mut HTMLCollection::new_inherited(window, elements),
                            window, HTMLCollectionBinding::Wrap)
     }
@@ -38,7 +36,7 @@ impl HTMLCollection {
         self.elements.len() as u32
     }
 
-    pub fn Item(&self, index: u32) -> Option<AbstractNode<ScriptView>> {
+    pub fn Item(&self, index: u32) -> Option<AbstractNode> {
         if index < self.Length() {
             Some(self.elements[index])
         } else {
@@ -50,7 +48,7 @@ impl HTMLCollection {
         Ok(ptr::null())
     }
 
-    pub fn IndexedGetter(&self, index: u32, found: &mut bool) -> Option<AbstractNode<ScriptView>> {
+    pub fn IndexedGetter(&self, index: u32, found: &mut bool) -> Option<AbstractNode> {
         *found = true;
         self.Item(index)
     }
diff --git a/servo/src/components/script/dom/htmldataelement.rs b/servo/src/components/script/dom/htmldataelement.rs
index 98c24c28e2e0..7a4f7795a9fa 100644
--- a/servo/src/components/script/dom/htmldataelement.rs
+++ b/servo/src/components/script/dom/htmldataelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLDataElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLDataElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLDataElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLDataElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLDataElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmldatalistelement.rs b/servo/src/components/script/dom/htmldatalistelement.rs
index 9f5bfce6b37d..2cc31b6b4281 100644
--- a/servo/src/components/script/dom/htmldatalistelement.rs
+++ b/servo/src/components/script/dom/htmldatalistelement.rs
@@ -7,7 +7,7 @@ use dom::document::AbstractDocument;
 use dom::element::HTMLDataListElementTypeId;
 use dom::htmlcollection::HTMLCollection;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLDataListElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLDataListElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLDataListElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLDataListElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmldirectoryelement.rs b/servo/src/components/script/dom/htmldirectoryelement.rs
index fb63cecfaf99..026e8883055a 100644
--- a/servo/src/components/script/dom/htmldirectoryelement.rs
+++ b/servo/src/components/script/dom/htmldirectoryelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::ErrorResult;
 use dom::document::AbstractDocument;
 use dom::element::HTMLDirectoryElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLDirectoryElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLDirectoryElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLDirectoryElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLDirectoryElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmldivelement.rs b/servo/src/components/script/dom/htmldivelement.rs
index fd148438fdfc..0d32034dcf6d 100644
--- a/servo/src/components/script/dom/htmldivelement.rs
+++ b/servo/src/components/script/dom/htmldivelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLDivElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLDivElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLDivElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLDivElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLDivElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmldlistelement.rs b/servo/src/components/script/dom/htmldlistelement.rs
index 4310b55b609c..3bfff50575a1 100644
--- a/servo/src/components/script/dom/htmldlistelement.rs
+++ b/servo/src/components/script/dom/htmldlistelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLDListElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLDListElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLDListElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLDListElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLDListElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmldocument.rs b/servo/src/components/script/dom/htmldocument.rs
index 16bf7f8b569c..6fb84620ab0b 100644
--- a/servo/src/components/script/dom/htmldocument.rs
+++ b/servo/src/components/script/dom/htmldocument.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{Reflectable, Reflector, Traceable};
 use dom::document::{AbstractDocument, Document, HTML};
 use dom::element::HTMLHeadElementTypeId;
 use dom::htmlcollection::HTMLCollection;
-use dom::node::{AbstractNode, ScriptView, ElementNodeTypeId};
+use dom::node::{AbstractNode, ElementNodeTypeId};
 use dom::window::Window;
 
 use js::jsapi::JSTracer;
@@ -32,7 +32,7 @@ impl HTMLDocument {
 }
 
 impl HTMLDocument {
-    pub fn GetHead(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetHead(&self) -> Option<AbstractNode> {
         match self.parent.GetDocumentElement() {
             None => None,
             Some(root) => root.traverse_preorder().find(|child| {
diff --git a/servo/src/components/script/dom/htmlelement.rs b/servo/src/components/script/dom/htmlelement.rs
index 6a79ee11864f..f87032989261 100644
--- a/servo/src/components/script/dom/htmlelement.rs
+++ b/servo/src/components/script/dom/htmlelement.rs
@@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLElementBinding;
 use dom::bindings::utils::{DOMString, ErrorResult, Fallible};
 use dom::document::AbstractDocument;
 use dom::element::{Element, ElementTypeId, HTMLElementTypeId};
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 use js::jsapi::{JSContext, JSVal};
 use js::JSVAL_NULL;
 use dom::namespace;
@@ -22,7 +22,7 @@ impl HTMLElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLElement::new_inherited(HTMLElementTypeId, localName, document);
         Node::reflect_node(@mut element, document, HTMLElementBinding::Wrap)
     }
@@ -133,7 +133,7 @@ impl HTMLElement {
     pub fn SetClassName(&self, _class: DOMString) {
     }
 
-    pub fn GetOffsetParent(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetOffsetParent(&self) -> Option<AbstractNode> {
         None
     }
 
diff --git a/servo/src/components/script/dom/htmlembedelement.rs b/servo/src/components/script/dom/htmlembedelement.rs
index 9319680bfc07..b387aa51800e 100644
--- a/servo/src/components/script/dom/htmlembedelement.rs
+++ b/servo/src/components/script/dom/htmlembedelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLEmbedElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLEmbedElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLEmbedElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLEmbedElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLEmbedElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlfieldsetelement.rs b/servo/src/components/script/dom/htmlfieldsetelement.rs
index 9eb4a3be6275..f63a56fe7233 100644
--- a/servo/src/components/script/dom/htmlfieldsetelement.rs
+++ b/servo/src/components/script/dom/htmlfieldsetelement.rs
@@ -8,7 +8,7 @@ use dom::document::AbstractDocument;
 use dom::element::HTMLFieldSetElementTypeId;
 use dom::htmlcollection::HTMLCollection;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 use dom::validitystate::ValidityState;
 
 pub struct HTMLFieldSetElement {
@@ -22,7 +22,7 @@ impl HTMLFieldSetElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLFieldSetElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLFieldSetElementBinding::Wrap)
     }
@@ -37,7 +37,7 @@ impl HTMLFieldSetElement {
         Ok(())
     }
 
-    pub fn GetForm(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetForm(&self) -> Option<AbstractNode> {
         None
     }
 
diff --git a/servo/src/components/script/dom/htmlfontelement.rs b/servo/src/components/script/dom/htmlfontelement.rs
index 22526ec9bc9a..dc9924b102bc 100644
--- a/servo/src/components/script/dom/htmlfontelement.rs
+++ b/servo/src/components/script/dom/htmlfontelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLFontElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLFontElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLFontElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLFontElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLFontElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlformelement.rs b/servo/src/components/script/dom/htmlformelement.rs
index d312816def92..4382c863169f 100644
--- a/servo/src/components/script/dom/htmlformelement.rs
+++ b/servo/src/components/script/dom/htmlformelement.rs
@@ -8,7 +8,7 @@ use dom::document::AbstractDocument;
 use dom::element::HTMLFormElementTypeId;
 use dom::htmlcollection::HTMLCollection;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLFormElement {
     htmlelement: HTMLElement
@@ -21,7 +21,7 @@ impl HTMLFormElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLFormElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLFormElementBinding::Wrap)
     }
@@ -120,7 +120,7 @@ impl HTMLFormElement {
         false
     }
 
-    pub fn IndexedGetter(&self, _index: u32, _found: &mut bool) -> AbstractNode<ScriptView> {
+    pub fn IndexedGetter(&self, _index: u32, _found: &mut bool) -> AbstractNode {
         fail!("Not implemented.")
     }
 }
diff --git a/servo/src/components/script/dom/htmlframeelement.rs b/servo/src/components/script/dom/htmlframeelement.rs
index b63333f55fec..c8daf679ccc8 100644
--- a/servo/src/components/script/dom/htmlframeelement.rs
+++ b/servo/src/components/script/dom/htmlframeelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLFrameElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 use dom::windowproxy::WindowProxy;
 
 pub struct HTMLFrameElement {
@@ -21,7 +21,7 @@ impl HTMLFrameElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLFrameElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLFrameElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlframesetelement.rs b/servo/src/components/script/dom/htmlframesetelement.rs
index 9a569b4d18d0..60aa03d4e94f 100644
--- a/servo/src/components/script/dom/htmlframesetelement.rs
+++ b/servo/src/components/script/dom/htmlframesetelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLFrameSetElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLFrameSetElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLFrameSetElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLFrameSetElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLFrameSetElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlheadelement.rs b/servo/src/components/script/dom/htmlheadelement.rs
index cd2a046cba96..d480504aeabc 100644
--- a/servo/src/components/script/dom/htmlheadelement.rs
+++ b/servo/src/components/script/dom/htmlheadelement.rs
@@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLHeadElementBinding;
 use dom::document::AbstractDocument;
 use dom::element::HTMLHeadElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLHeadElement {
     htmlelement: HTMLElement
@@ -19,7 +19,7 @@ impl HTMLHeadElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLHeadElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLHeadElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlheadingelement.rs b/servo/src/components/script/dom/htmlheadingelement.rs
index aa1a4b6a96a0..284982c6852b 100644
--- a/servo/src/components/script/dom/htmlheadingelement.rs
+++ b/servo/src/components/script/dom/htmlheadingelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::DOMString;
 use dom::document::AbstractDocument;
 use dom::element::HTMLHeadingElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub enum HeadingLevel {
     Heading1,
@@ -31,7 +31,7 @@ impl HTMLHeadingElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument, level: HeadingLevel) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument, level: HeadingLevel) -> AbstractNode {
         let element = HTMLHeadingElement::new_inherited(localName, document, level);
         Node::reflect_node(@mut element, document, HTMLHeadingElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlhrelement.rs b/servo/src/components/script/dom/htmlhrelement.rs
index a3897d3ffb51..274e82be2ff7 100644
--- a/servo/src/components/script/dom/htmlhrelement.rs
+++ b/servo/src/components/script/dom/htmlhrelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLHRElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLHRElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLHRElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLHRElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLHRElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlhtmlelement.rs b/servo/src/components/script/dom/htmlhtmlelement.rs
index b445e08a64e9..685f01b6bbdb 100644
--- a/servo/src/components/script/dom/htmlhtmlelement.rs
+++ b/servo/src/components/script/dom/htmlhtmlelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLHtmlElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLHtmlElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLHtmlElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLHtmlElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLHtmlElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmliframeelement.rs b/servo/src/components/script/dom/htmliframeelement.rs
index d1579164f419..b41dd2c773ee 100644
--- a/servo/src/components/script/dom/htmliframeelement.rs
+++ b/servo/src/components/script/dom/htmliframeelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLIframeElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 use dom::windowproxy::WindowProxy;
 
 use extra::url::Url;
@@ -52,7 +52,7 @@ impl HTMLIFrameElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLIFrameElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLIFrameElementBinding::Wrap)
     }
@@ -83,14 +83,14 @@ impl HTMLIFrameElement {
         Ok(())
     }
 
-    pub fn Sandbox(&self, _abstract_self: AbstractNode<ScriptView>) -> DOMString {
+    pub fn Sandbox(&self, _abstract_self: AbstractNode) -> DOMString {
         match self.htmlelement.element.GetAttribute(~"sandbox") {
             Some(s) => s.to_owned(),
             None => ~"",
         }
     }
 
-    pub fn SetSandbox(&mut self, abstract_self: AbstractNode<ScriptView>, sandbox: DOMString) {
+    pub fn SetSandbox(&mut self, abstract_self: AbstractNode, sandbox: DOMString) {
         self.htmlelement.element.SetAttribute(abstract_self, ~"sandbox", sandbox);
     }
 
diff --git a/servo/src/components/script/dom/htmlimageelement.rs b/servo/src/components/script/dom/htmlimageelement.rs
index 6e8192a23499..d4f8479abe77 100644
--- a/servo/src/components/script/dom/htmlimageelement.rs
+++ b/servo/src/components/script/dom/htmlimageelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLImageElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 use extra::url::Url;
 use servo_util::geometry::to_px;
 use layout_interface::{ContentBoxQuery, ContentBoxResponse};
@@ -29,7 +29,7 @@ impl HTMLImageElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLImageElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLImageElementBinding::Wrap)
     }
@@ -74,13 +74,11 @@ impl HTMLImageElement {
         Ok(())
     }
 
-    pub fn Src(&self, _abstract_self: AbstractNode<ScriptView>) -> DOMString {
+    pub fn Src(&self, _abstract_self: AbstractNode) -> DOMString {
         ~""
     }
 
-    pub fn SetSrc(&mut self,
-                  abstract_self: AbstractNode<ScriptView>,
-                  src: DOMString) -> ErrorResult {
+    pub fn SetSrc(&mut self, abstract_self: AbstractNode, src: DOMString) -> ErrorResult {
         let node = &mut self.htmlelement.element;
         node.set_attr(abstract_self, ~"src", src.clone());
         Ok(())
@@ -110,7 +108,7 @@ impl HTMLImageElement {
         Ok(())
     }
 
-    pub fn Width(&self, abstract_self: AbstractNode<ScriptView>) -> u32 {
+    pub fn Width(&self, abstract_self: AbstractNode) -> u32 {
         let node = &self.htmlelement.element.node;
         let page = node.owner_doc().document().window.page;
         let (port, chan) = stream();
@@ -121,15 +119,13 @@ impl HTMLImageElement {
         }
     }
 
-    pub fn SetWidth(&mut self,
-                    abstract_self: AbstractNode<ScriptView>,
-                    width: u32) -> ErrorResult {
+    pub fn SetWidth(&mut self, abstract_self: AbstractNode, width: u32) -> ErrorResult {
         let node = &mut self.htmlelement.element;
         node.set_attr(abstract_self, ~"width", width.to_str());
         Ok(())
     }
 
-    pub fn Height(&self, abstract_self: AbstractNode<ScriptView>) -> u32 {
+    pub fn Height(&self, abstract_self: AbstractNode) -> u32 {
         let node = &self.htmlelement.element.node;
         let page = node.owner_doc().document().window.page;
         let (port, chan) = stream();
@@ -140,9 +136,7 @@ impl HTMLImageElement {
         }
     }
 
-    pub fn SetHeight(&mut self,
-                     abstract_self: AbstractNode<ScriptView>,
-                     height: u32) -> ErrorResult {
+    pub fn SetHeight(&mut self, abstract_self: AbstractNode, height: u32) -> ErrorResult {
         let node = &mut self.htmlelement.element;
         node.set_attr(abstract_self, ~"height", height.to_str());
         Ok(())
diff --git a/servo/src/components/script/dom/htmlinputelement.rs b/servo/src/components/script/dom/htmlinputelement.rs
index 6dac0543645f..6505fdc62b50 100644
--- a/servo/src/components/script/dom/htmlinputelement.rs
+++ b/servo/src/components/script/dom/htmlinputelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult, Fallible};
 use dom::document::AbstractDocument;
 use dom::element::HTMLInputElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLInputElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLInputElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLInputElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLInputElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmllabelelement.rs b/servo/src/components/script/dom/htmllabelelement.rs
index b1e9dffe81ac..cfba2f432560 100644
--- a/servo/src/components/script/dom/htmllabelelement.rs
+++ b/servo/src/components/script/dom/htmllabelelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::DOMString;
 use dom::document::AbstractDocument;
 use dom::element::HTMLLabelElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLLabelElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLLabelElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLLabelElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLLabelElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmllegendelement.rs b/servo/src/components/script/dom/htmllegendelement.rs
index a5893cfd224f..11e0409c0224 100644
--- a/servo/src/components/script/dom/htmllegendelement.rs
+++ b/servo/src/components/script/dom/htmllegendelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLLegendElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLLegendElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLLegendElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLLegendElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLLegendElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmllielement.rs b/servo/src/components/script/dom/htmllielement.rs
index 67643b2daab3..28ce96b2392f 100644
--- a/servo/src/components/script/dom/htmllielement.rs
+++ b/servo/src/components/script/dom/htmllielement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLLIElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLLIElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLLIElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLLIElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLLIElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmllinkelement.rs b/servo/src/components/script/dom/htmllinkelement.rs
index ce740b3394bd..905ca7109d4f 100644
--- a/servo/src/components/script/dom/htmllinkelement.rs
+++ b/servo/src/components/script/dom/htmllinkelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLLinkElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLLinkElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLLinkElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLLinkElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLLinkElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlmainelement.rs b/servo/src/components/script/dom/htmlmainelement.rs
index cbcd68d17b79..a310f139660f 100644
--- a/servo/src/components/script/dom/htmlmainelement.rs
+++ b/servo/src/components/script/dom/htmlmainelement.rs
@@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLMainElementBinding;
 use dom::document::AbstractDocument;
 use dom::element::HTMLMainElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLMainElement {
     htmlelement: HTMLElement
@@ -19,7 +19,7 @@ impl HTMLMainElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLMainElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLMainElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlmapelement.rs b/servo/src/components/script/dom/htmlmapelement.rs
index 1a05862b61e0..fc6bbc444c5c 100644
--- a/servo/src/components/script/dom/htmlmapelement.rs
+++ b/servo/src/components/script/dom/htmlmapelement.rs
@@ -8,7 +8,7 @@ use dom::htmlcollection::HTMLCollection;
 use dom::document::AbstractDocument;
 use dom::element::HTMLMapElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLMapElement {
     htmlelement: HTMLElement
@@ -21,7 +21,7 @@ impl HTMLMapElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLMapElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLMapElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlmetaelement.rs b/servo/src/components/script/dom/htmlmetaelement.rs
index f6dee84c73de..e57d3d6b5955 100644
--- a/servo/src/components/script/dom/htmlmetaelement.rs
+++ b/servo/src/components/script/dom/htmlmetaelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLMetaElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLMetaElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLMetaElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLMetaElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLMetaElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlmeterelement.rs b/servo/src/components/script/dom/htmlmeterelement.rs
index ea039682f514..30067b1d0e96 100644
--- a/servo/src/components/script/dom/htmlmeterelement.rs
+++ b/servo/src/components/script/dom/htmlmeterelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::ErrorResult;
 use dom::document::AbstractDocument;
 use dom::element::HTMLMeterElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLMeterElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLMeterElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLMeterElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLMeterElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlmodelement.rs b/servo/src/components/script/dom/htmlmodelement.rs
index 3e6365334b70..b1357875f172 100644
--- a/servo/src/components/script/dom/htmlmodelement.rs
+++ b/servo/src/components/script/dom/htmlmodelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLModElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLModElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLModElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLModElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLModElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlobjectelement.rs b/servo/src/components/script/dom/htmlobjectelement.rs
index a44d05b81ff0..eb4375be2163 100644
--- a/servo/src/components/script/dom/htmlobjectelement.rs
+++ b/servo/src/components/script/dom/htmlobjectelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLObjectElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 use dom::validitystate::ValidityState;
 use dom::windowproxy::WindowProxy;
 
@@ -22,7 +22,7 @@ impl HTMLObjectElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLObjectElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLObjectElementBinding::Wrap)
     }
@@ -61,7 +61,7 @@ impl HTMLObjectElement {
         Ok(())
     }
 
-    pub fn GetForm(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetForm(&self) -> Option<AbstractNode> {
         None
     }
 
diff --git a/servo/src/components/script/dom/htmlolistelement.rs b/servo/src/components/script/dom/htmlolistelement.rs
index ed38eb0e8710..9946f51ba3df 100644
--- a/servo/src/components/script/dom/htmlolistelement.rs
+++ b/servo/src/components/script/dom/htmlolistelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLOListElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLOListElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLOListElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLOListElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLOListElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmloptgroupelement.rs b/servo/src/components/script/dom/htmloptgroupelement.rs
index 0e9e3588ee7b..8c1d4c3922c0 100644
--- a/servo/src/components/script/dom/htmloptgroupelement.rs
+++ b/servo/src/components/script/dom/htmloptgroupelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLOptGroupElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLOptGroupElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLOptGroupElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLOptGroupElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLOptGroupElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmloptionelement.rs b/servo/src/components/script/dom/htmloptionelement.rs
index 3d46580a0805..6beb2ba3c180 100644
--- a/servo/src/components/script/dom/htmloptionelement.rs
+++ b/servo/src/components/script/dom/htmloptionelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLOptionElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLOptionElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLOptionElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLOptionElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLOptionElementBinding::Wrap)
     }
@@ -35,7 +35,7 @@ impl HTMLOptionElement {
         Ok(())
     }
 
-    pub fn GetForm(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetForm(&self) -> Option<AbstractNode> {
         None
     }
 
diff --git a/servo/src/components/script/dom/htmloutputelement.rs b/servo/src/components/script/dom/htmloutputelement.rs
index 13063193792b..26b399af8b38 100644
--- a/servo/src/components/script/dom/htmloutputelement.rs
+++ b/servo/src/components/script/dom/htmloutputelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLOutputElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 use dom::validitystate::ValidityState;
 
 pub struct HTMLOutputElement {
@@ -21,14 +21,14 @@ impl HTMLOutputElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLOutputElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLOutputElementBinding::Wrap)
     }
 }
 
 impl HTMLOutputElement {
-    pub fn GetForm(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetForm(&self) -> Option<AbstractNode> {
         None
     }
 
diff --git a/servo/src/components/script/dom/htmlparagraphelement.rs b/servo/src/components/script/dom/htmlparagraphelement.rs
index 36ef329b9fd8..3fdc422cced1 100644
--- a/servo/src/components/script/dom/htmlparagraphelement.rs
+++ b/servo/src/components/script/dom/htmlparagraphelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLParagraphElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLParagraphElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLParagraphElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLParagraphElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLParagraphElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlparamelement.rs b/servo/src/components/script/dom/htmlparamelement.rs
index 423cf6d913b5..80e1696fa4e1 100644
--- a/servo/src/components/script/dom/htmlparamelement.rs
+++ b/servo/src/components/script/dom/htmlparamelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLParamElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLParamElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLParamElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLParamElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLParamElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlpreelement.rs b/servo/src/components/script/dom/htmlpreelement.rs
index 2c736fd7d8e6..2fb9752d0960 100644
--- a/servo/src/components/script/dom/htmlpreelement.rs
+++ b/servo/src/components/script/dom/htmlpreelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLPreElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLPreElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLPreElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLPreElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLPreElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlprogresselement.rs b/servo/src/components/script/dom/htmlprogresselement.rs
index 7f7c13d63183..b3f8f49a1529 100644
--- a/servo/src/components/script/dom/htmlprogresselement.rs
+++ b/servo/src/components/script/dom/htmlprogresselement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{ErrorResult, Fallible};
 use dom::document::AbstractDocument;
 use dom::element::HTMLProgressElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLProgressElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLProgressElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLProgressElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLProgressElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlquoteelement.rs b/servo/src/components/script/dom/htmlquoteelement.rs
index dfef4b1a97b1..82992c730068 100644
--- a/servo/src/components/script/dom/htmlquoteelement.rs
+++ b/servo/src/components/script/dom/htmlquoteelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLQuoteElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLQuoteElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLQuoteElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLQuoteElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLQuoteElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlscriptelement.rs b/servo/src/components/script/dom/htmlscriptelement.rs
index 37b49fbd1acd..50f923e77182 100644
--- a/servo/src/components/script/dom/htmlscriptelement.rs
+++ b/servo/src/components/script/dom/htmlscriptelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLScriptElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 use style::TElement;
 
 pub struct HTMLScriptElement {
@@ -21,7 +21,7 @@ impl HTMLScriptElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLScriptElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLScriptElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlselectelement.rs b/servo/src/components/script/dom/htmlselectelement.rs
index 98ea62a144cc..ffdee692bee4 100644
--- a/servo/src/components/script/dom/htmlselectelement.rs
+++ b/servo/src/components/script/dom/htmlselectelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLSelectElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 use dom::validitystate::ValidityState;
 
 pub struct HTMLSelectElement {
@@ -21,7 +21,7 @@ impl HTMLSelectElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLSelectElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLSelectElementBinding::Wrap)
     }
@@ -44,7 +44,7 @@ impl HTMLSelectElement {
         Ok(())
     }
 
-    pub fn GetForm(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetForm(&self) -> Option<AbstractNode> {
         None
     }
 
@@ -92,19 +92,19 @@ impl HTMLSelectElement {
         Ok(())
     }
 
-    pub fn Item(&self, _index: u32) -> Option<AbstractNode<ScriptView>> {
+    pub fn Item(&self, _index: u32) -> Option<AbstractNode> {
         None
     }
 
-    pub fn NamedItem(&self, _name: DOMString) -> Option<AbstractNode<ScriptView>> {
+    pub fn NamedItem(&self, _name: DOMString) -> Option<AbstractNode> {
         None
     }
 
-    pub fn IndexedGetter(&self, _index: u32, _found: &mut bool) -> Option<AbstractNode<ScriptView>> {
+    pub fn IndexedGetter(&self, _index: u32, _found: &mut bool) -> Option<AbstractNode> {
         None
     }
 
-    pub fn IndexedSetter(&mut self, _index: u32, _option: Option<AbstractNode<ScriptView>>) -> ErrorResult {
+    pub fn IndexedSetter(&mut self, _index: u32, _option: Option<AbstractNode>) -> ErrorResult {
         Ok(())
     }
 
diff --git a/servo/src/components/script/dom/htmlsourceelement.rs b/servo/src/components/script/dom/htmlsourceelement.rs
index 54a83b35d0ad..ba5701e7cc1c 100644
--- a/servo/src/components/script/dom/htmlsourceelement.rs
+++ b/servo/src/components/script/dom/htmlsourceelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLSourceElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLSourceElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLSourceElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLSourceElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLSourceElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlspanelement.rs b/servo/src/components/script/dom/htmlspanelement.rs
index f1678043a62c..b63e5fc96266 100644
--- a/servo/src/components/script/dom/htmlspanelement.rs
+++ b/servo/src/components/script/dom/htmlspanelement.rs
@@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLSpanElementBinding;
 use dom::document::AbstractDocument;
 use dom::element::HTMLSpanElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLSpanElement {
     htmlelement: HTMLElement
@@ -19,7 +19,7 @@ impl HTMLSpanElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLSpanElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLSpanElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlstyleelement.rs b/servo/src/components/script/dom/htmlstyleelement.rs
index 8e8fefaabe40..b43d75d03217 100644
--- a/servo/src/components/script/dom/htmlstyleelement.rs
+++ b/servo/src/components/script/dom/htmlstyleelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLStyleElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLStyleElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLStyleElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLStyleElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLStyleElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmltablecaptionelement.rs b/servo/src/components/script/dom/htmltablecaptionelement.rs
index 0e538fe50499..5f3c6edc2f71 100644
--- a/servo/src/components/script/dom/htmltablecaptionelement.rs
+++ b/servo/src/components/script/dom/htmltablecaptionelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLTableCaptionElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLTableCaptionElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLTableCaptionElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTableCaptionElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTableCaptionElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmltablecolelement.rs b/servo/src/components/script/dom/htmltablecolelement.rs
index a50850181b1f..c640c8521409 100644
--- a/servo/src/components/script/dom/htmltablecolelement.rs
+++ b/servo/src/components/script/dom/htmltablecolelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLTableColElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLTableColElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLTableColElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTableColElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTableColElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmltabledatacellelement.rs b/servo/src/components/script/dom/htmltabledatacellelement.rs
index 4b3dda097452..52ee1d24d644 100644
--- a/servo/src/components/script/dom/htmltabledatacellelement.rs
+++ b/servo/src/components/script/dom/htmltabledatacellelement.rs
@@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLTableDataCellElementBinding;
 use dom::document::AbstractDocument;
 use dom::element::HTMLTableDataCellElementTypeId;
 use dom::htmltablecellelement::HTMLTableCellElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLTableDataCellElement {
     htmltablecellelement: HTMLTableCellElement,
@@ -19,7 +19,7 @@ impl HTMLTableDataCellElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTableDataCellElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTableDataCellElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmltableelement.rs b/servo/src/components/script/dom/htmltableelement.rs
index 2ecb39d92e9f..9c5b639cf7ba 100644
--- a/servo/src/components/script/dom/htmltableelement.rs
+++ b/servo/src/components/script/dom/htmltableelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLTableElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLTableElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLTableElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTableElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTableElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmltableheadercellelement.rs b/servo/src/components/script/dom/htmltableheadercellelement.rs
index 59a9d596aeae..20cddcc9dc16 100644
--- a/servo/src/components/script/dom/htmltableheadercellelement.rs
+++ b/servo/src/components/script/dom/htmltableheadercellelement.rs
@@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLTableHeaderCellElementBinding;
 use dom::document::AbstractDocument;
 use dom::element::HTMLTableHeaderCellElementTypeId;
 use dom::htmltablecellelement::HTMLTableCellElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLTableHeaderCellElement {
     htmltablecellelement: HTMLTableCellElement,
@@ -19,7 +19,7 @@ impl HTMLTableHeaderCellElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTableHeaderCellElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTableHeaderCellElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmltablerowelement.rs b/servo/src/components/script/dom/htmltablerowelement.rs
index e8966bdc2982..67ecfe7fd5cc 100644
--- a/servo/src/components/script/dom/htmltablerowelement.rs
+++ b/servo/src/components/script/dom/htmltablerowelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLTableRowElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLTableRowElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLTableRowElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTableRowElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTableRowElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmltablesectionelement.rs b/servo/src/components/script/dom/htmltablesectionelement.rs
index a1282bd70cc5..4d22c72a2e1a 100644
--- a/servo/src/components/script/dom/htmltablesectionelement.rs
+++ b/servo/src/components/script/dom/htmltablesectionelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLTableSectionElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLTableSectionElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLTableSectionElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTableSectionElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTableSectionElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmltemplateelement.rs b/servo/src/components/script/dom/htmltemplateelement.rs
index b42e8f5df063..389e1313631f 100644
--- a/servo/src/components/script/dom/htmltemplateelement.rs
+++ b/servo/src/components/script/dom/htmltemplateelement.rs
@@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLTemplateElementBinding;
 use dom::document::AbstractDocument;
 use dom::element::HTMLTemplateElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLTemplateElement {
     htmlelement: HTMLElement,
@@ -19,7 +19,7 @@ impl HTMLTemplateElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTemplateElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTemplateElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmltextareaelement.rs b/servo/src/components/script/dom/htmltextareaelement.rs
index c4553ec5c327..3fb59cce249f 100644
--- a/servo/src/components/script/dom/htmltextareaelement.rs
+++ b/servo/src/components/script/dom/htmltextareaelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult, Fallible};
 use dom::document::AbstractDocument;
 use dom::element::HTMLTextAreaElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLTextAreaElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLTextAreaElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTextAreaElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTextAreaElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmltimeelement.rs b/servo/src/components/script/dom/htmltimeelement.rs
index f619e6562bab..0aff5d026e49 100644
--- a/servo/src/components/script/dom/htmltimeelement.rs
+++ b/servo/src/components/script/dom/htmltimeelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLTimeElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLTimeElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLTimeElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTimeElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTimeElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmltitleelement.rs b/servo/src/components/script/dom/htmltitleelement.rs
index da30b76728a0..aa654e6086d4 100644
--- a/servo/src/components/script/dom/htmltitleelement.rs
+++ b/servo/src/components/script/dom/htmltitleelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLTitleElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLTitleElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLTitleElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTitleElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTitleElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmltrackelement.rs b/servo/src/components/script/dom/htmltrackelement.rs
index 3ca6b5ff8030..db42315564e9 100644
--- a/servo/src/components/script/dom/htmltrackelement.rs
+++ b/servo/src/components/script/dom/htmltrackelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLTrackElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLTrackElement {
     htmlelement: HTMLElement,
@@ -20,7 +20,7 @@ impl HTMLTrackElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLTrackElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLTrackElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlulistelement.rs b/servo/src/components/script/dom/htmlulistelement.rs
index eeee90fe46ac..16c4a44b6e2a 100644
--- a/servo/src/components/script/dom/htmlulistelement.rs
+++ b/servo/src/components/script/dom/htmlulistelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLUListElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLUListElement {
     htmlelement: HTMLElement
@@ -20,7 +20,7 @@ impl HTMLUListElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLUListElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLUListElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlunknownelement.rs b/servo/src/components/script/dom/htmlunknownelement.rs
index 4ff25898e13f..1ff729cc39f7 100644
--- a/servo/src/components/script/dom/htmlunknownelement.rs
+++ b/servo/src/components/script/dom/htmlunknownelement.rs
@@ -6,7 +6,7 @@ use dom::bindings::codegen::HTMLUnknownElementBinding;
 use dom::document::AbstractDocument;
 use dom::element::HTMLUnknownElementTypeId;
 use dom::htmlelement::HTMLElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLUnknownElement {
     htmlelement: HTMLElement
@@ -19,7 +19,7 @@ impl HTMLUnknownElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLUnknownElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLUnknownElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/htmlvideoelement.rs b/servo/src/components/script/dom/htmlvideoelement.rs
index 3ab2c780a665..38bb636d9d4d 100644
--- a/servo/src/components/script/dom/htmlvideoelement.rs
+++ b/servo/src/components/script/dom/htmlvideoelement.rs
@@ -7,7 +7,7 @@ use dom::bindings::utils::{DOMString, ErrorResult};
 use dom::document::AbstractDocument;
 use dom::element::HTMLVideoElementTypeId;
 use dom::htmlmediaelement::HTMLMediaElement;
-use dom::node::{AbstractNode, Node, ScriptView};
+use dom::node::{AbstractNode, Node};
 
 pub struct HTMLVideoElement {
     htmlmediaelement: HTMLMediaElement
@@ -20,7 +20,7 @@ impl HTMLVideoElement {
         }
     }
 
-    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(localName: ~str, document: AbstractDocument) -> AbstractNode {
         let element = HTMLVideoElement::new_inherited(localName, document);
         Node::reflect_node(@mut element, document, HTMLVideoElementBinding::Wrap)
     }
diff --git a/servo/src/components/script/dom/node.rs b/servo/src/components/script/dom/node.rs
index 1e71b5c2fea8..53296d12da71 100644
--- a/servo/src/components/script/dom/node.rs
+++ b/servo/src/components/script/dom/node.rs
@@ -14,9 +14,9 @@ use dom::documenttype::DocumentType;
 use dom::element::{Element, ElementTypeId, HTMLImageElementTypeId, HTMLIframeElementTypeId};
 use dom::element::{HTMLAnchorElementTypeId, HTMLStyleElementTypeId};
 use dom::eventtarget::{AbstractEventTarget, EventTarget, NodeTypeId};
-use dom::nodelist::{NodeList};
-use dom::htmlimageelement::HTMLImageElement;
 use dom::htmliframeelement::HTMLIFrameElement;
+use dom::htmlimageelement::HTMLImageElement;
+use dom::nodelist::{NodeList};
 use dom::text::Text;
 
 use js::jsapi::{JSObject, JSContext};
@@ -25,65 +25,44 @@ use std::cast::transmute;
 use std::cast;
 use std::unstable::raw::Box;
 use std::util;
-use style::TNode;
 
 //
 // The basic Node structure
 //
 
-/// A phantom type representing the script task's view of this node. Script is able to mutate
-/// nodes but may not access layout data.
-#[deriving(Eq)]
-pub struct ScriptView;
-
-/// A phantom type representing the layout task's view of the node. Layout is not allowed to mutate
-/// nodes but may access layout data.
-#[deriving(Eq)]
-pub struct LayoutView;
-
-// We shouldn't need Eq for ScriptView and LayoutView; see Rust #7671.
-
 /// This is what a Node looks like if you do not know what kind of node it is. To unpack it, use
 /// downcast().
 ///
 /// FIXME: This should be replaced with a trait once they can inherit from structs.
 #[deriving(Eq)]
-pub struct AbstractNode<View> {
-    priv obj: *mut Box<Node<View>>,
-}
-
-pub struct AbstractNodeChildrenIterator<View> {
-    priv current_node: Option<AbstractNode<View>>,
+pub struct AbstractNode {
+    priv obj: *mut Box<Node>,
 }
 
 /// An HTML node.
-///
-/// `View` describes extra data associated with this node that this task has access to. For
-/// the script task, this is the unit type `()`. For the layout task, this is
-/// `LayoutData`.
-pub struct Node<View> {
+pub struct Node {
     /// The JavaScript reflector for this node.
     eventtarget: EventTarget,
 
     /// The type of node that this is.
     type_id: NodeTypeId,
 
-    abstract: Option<AbstractNode<View>>,
+    abstract: Option<AbstractNode>,
 
     /// The parent of this node.
-    parent_node: Option<AbstractNode<View>>,
+    parent_node: Option<AbstractNode>,
 
     /// The first child of this node.
-    first_child: Option<AbstractNode<View>>,
+    first_child: Option<AbstractNode>,
 
     /// The last child of this node.
-    last_child: Option<AbstractNode<View>>,
+    last_child: Option<AbstractNode>,
 
     /// The next sibling of this node.
-    next_sibling: Option<AbstractNode<View>>,
+    next_sibling: Option<AbstractNode>,
 
     /// The previous sibling of this node.
-    prev_sibling: Option<AbstractNode<View>>,
+    prev_sibling: Option<AbstractNode>,
 
     /// The document that this node belongs to.
     priv owner_doc: Option<AbstractDocument>,
@@ -119,10 +98,10 @@ impl NodeFlags {
 bitfield!(NodeFlags, is_in_doc, set_is_in_doc, 0x01)
 
 #[unsafe_destructor]
-impl<T> Drop for Node<T> {
+impl Drop for Node {
     fn drop(&mut self) {
         unsafe {
-            let this: &mut Node<ScriptView> = cast::transmute(self);
+            let this: &mut Node = cast::transmute(self);
             this.reap_layout_data()
         }
     }
@@ -204,68 +183,53 @@ pub enum NodeTypeId {
     TextNodeTypeId,
 }
 
-impl<View> Clone for AbstractNode<View> {
-    fn clone(&self) -> AbstractNode<View> {
+impl Clone for AbstractNode {
+    fn clone(&self) -> AbstractNode {
         *self
     }
 }
 
-impl<View> TNode<Element> for AbstractNode<View> {
-    fn parent_node(&self) -> Option<AbstractNode<View>> {
+impl AbstractNode {
+    pub fn node<'a>(&'a self) -> &'a Node {
+        unsafe {
+            &(*self.obj).data
+        }
+    }
+
+    pub fn mut_node<'a>(&'a self) -> &'a mut Node {
+        unsafe {
+            &mut (*self.obj).data
+        }
+    }
+
+    pub fn parent_node(&self) -> Option<AbstractNode> {
         self.node().parent_node
     }
 
-    fn prev_sibling(&self) -> Option<AbstractNode<View>> {
-        self.node().prev_sibling
-    }
-    
-    fn next_sibling(&self) -> Option<AbstractNode<View>> {
-        self.node().next_sibling
+    pub fn first_child(&self) -> Option<AbstractNode> {
+        self.node().first_child
     }
 
-    fn is_element(&self) -> bool {
+    pub fn last_child(&self) -> Option<AbstractNode> {
+        self.node().last_child
+    }
+
+    pub fn is_element(&self) -> bool {
         match self.type_id() {
             ElementNodeTypeId(*) => true,
             _ => false
         }
     }
 
-    fn is_document(&self) -> bool {
+    pub fn is_document(&self) -> bool {
         match self.type_id() {
             DocumentNodeTypeId(*) => true,
             _ => false
         }
     }
-
-    #[inline]
-    fn with_element<R>(&self, f: &fn(&Element) -> R) -> R {
-        self.with_imm_element(f)
-    }
 }
 
-impl<View> AbstractNode<View> {
-    pub fn node<'a>(&'a self) -> &'a Node<View> {
-        unsafe {
-            &(*self.obj).data
-        }
-    }
-
-    pub fn mut_node<'a>(&'a self) -> &'a mut Node<View> {
-        unsafe {
-            &mut (*self.obj).data
-        }
-    }
-
-    pub fn first_child(&self) -> Option<AbstractNode<View>> {
-        self.node().first_child
-    }
-
-    pub fn last_child(&self) -> Option<AbstractNode<View>> {
-        self.node().last_child
-    }
-}
-
-impl<'self, View> AbstractNode<View> {
+impl<'self> AbstractNode {
     // Unsafe accessors
 
     pub unsafe fn as_cacheable_wrapper(&self) -> @mut Reflectable {
@@ -283,20 +247,22 @@ impl<'self, View> AbstractNode<View> {
     /// Allow consumers to recreate an AbstractNode from the raw boxed type.
     /// Must only be used in situations where the boxed type is in the inheritance
     /// chain for nodes.
-    pub fn from_box<T>(ptr: *mut Box<T>) -> AbstractNode<View> {
+    ///
+    /// FIXME(pcwalton): Mark unsafe?
+    pub fn from_box<T>(ptr: *mut Box<T>) -> AbstractNode {
         AbstractNode {
-            obj: ptr as *mut Box<Node<View>>
+            obj: ptr as *mut Box<Node>
         }
     }
 
     /// Allow consumers to upcast from derived classes.
-    pub fn from_document(doc: AbstractDocument) -> AbstractNode<View> {
+    pub fn from_document(doc: AbstractDocument) -> AbstractNode {
         unsafe {
             cast::transmute(doc)
         }
     }
 
-    pub fn from_eventtarget(target: AbstractEventTarget) -> AbstractNode<View> {
+    pub fn from_eventtarget(target: AbstractEventTarget) -> AbstractNode {
         assert!(target.is_node());
         unsafe {
             cast::transmute(target)
@@ -311,12 +277,12 @@ impl<'self, View> AbstractNode<View> {
     }
 
     /// Returns the previous sibling of this node. Fails if this node is borrowed mutably.
-    pub fn prev_sibling(self) -> Option<AbstractNode<View>> {
+    pub fn prev_sibling(self) -> Option<AbstractNode> {
         self.node().prev_sibling
     }
 
     /// Returns the next sibling of this node. Fails if this node is borrowed mutably.
-    pub fn next_sibling(self) -> Option<AbstractNode<View>> {
+    pub fn next_sibling(self) -> Option<AbstractNode> {
         self.node().next_sibling
     }
 
@@ -326,7 +292,7 @@ impl<'self, View> AbstractNode<View> {
 
     pub fn transmute<T, R>(self, f: &fn(&T) -> R) -> R {
         unsafe {
-            let node_box: *mut Box<Node<View>> = transmute(self.obj);
+            let node_box: *mut Box<Node> = transmute(self.obj);
             let node = &mut (*node_box).data;
             let old = node.abstract;
             node.abstract = Some(self);
@@ -339,7 +305,7 @@ impl<'self, View> AbstractNode<View> {
 
     pub fn transmute_mut<T, R>(self, f: &fn(&mut T) -> R) -> R {
         unsafe {
-            let node_box: *mut Box<Node<View>> = transmute(self.obj);
+            let node_box: *mut Box<Node> = transmute(self.obj);
             let node = &mut (*node_box).data;
             let old = node.abstract;
             node.abstract = Some(self);
@@ -446,13 +412,6 @@ impl<'self, View> AbstractNode<View> {
         }
     }
 
-    pub fn with_imm_image_element<R>(self, f: &fn(&HTMLImageElement) -> R) -> R {
-        if !self.is_image_element() {
-            fail!(~"node is not an image element");
-        }
-        self.transmute(f)
-    }
-
     pub fn with_mut_image_element<R>(self, f: &fn(&mut HTMLImageElement) -> R) -> R {
         if !self.is_image_element() {
             fail!(~"node is not an image element");
@@ -464,13 +423,6 @@ impl<'self, View> AbstractNode<View> {
         self.type_id() == ElementNodeTypeId(HTMLIframeElementTypeId)
     }
 
-    pub fn with_imm_iframe_element<R>(self, f: &fn(&HTMLIFrameElement) -> R) -> R {
-        if !self.is_iframe_element() {
-            fail!(~"node is not an iframe element");
-        }
-        self.transmute(f)
-    }
-
     pub fn with_mut_iframe_element<R>(self, f: &fn(&mut HTMLIFrameElement) -> R) -> R {
         if !self.is_iframe_element() {
             fail!(~"node is not an iframe element");
@@ -486,11 +438,11 @@ impl<'self, View> AbstractNode<View> {
         self.type_id() == ElementNodeTypeId(HTMLAnchorElementTypeId)
     }
 
-    pub unsafe fn raw_object(self) -> *mut Box<Node<View>> {
+    pub unsafe fn raw_object(self) -> *mut Box<Node> {
         self.obj
     }
 
-    pub fn from_raw(raw: *mut Box<Node<View>>) -> AbstractNode<View> {
+    pub fn from_raw(raw: *mut Box<Node>) -> AbstractNode {
         AbstractNode {
             obj: raw
         }
@@ -530,7 +482,7 @@ impl<'self, View> AbstractNode<View> {
         self.first_child().is_none()
     }
 
-    pub fn children(&self) -> AbstractNodeChildrenIterator<View> {
+    pub fn children(&self) -> AbstractNodeChildrenIterator {
         self.node().children()
     }
 
@@ -539,12 +491,12 @@ impl<'self, View> AbstractNode<View> {
     }
 }
 
-impl AbstractNode<ScriptView> {
-    pub fn AppendChild(self, node: AbstractNode<ScriptView>) -> Fallible<AbstractNode<ScriptView>> {
+impl AbstractNode {
+    pub fn AppendChild(self, node: AbstractNode) -> Fallible<AbstractNode> {
         self.node().AppendChild(self, node)
     }
 
-    pub fn RemoveChild(self, node: AbstractNode<ScriptView>) -> Fallible<AbstractNode<ScriptView>> {
+    pub fn RemoveChild(self, node: AbstractNode) -> Fallible<AbstractNode> {
         self.node().RemoveChild(self, node)
     }
 
@@ -577,9 +529,7 @@ impl AbstractNode<ScriptView> {
     /// Adds a new child to the end of this node's list of children.
     ///
     /// Fails unless `new_child` is disconnected from the tree.
-    fn add_child(&self,
-                 new_child: AbstractNode<ScriptView>,
-                 before: Option<AbstractNode<ScriptView>>) {
+    fn add_child(&self, new_child: AbstractNode, before: Option<AbstractNode>) {
         let this_node = self.mut_node();
         let new_child_node = new_child.mut_node();
         assert!(new_child_node.parent_node.is_none());
@@ -626,7 +576,7 @@ impl AbstractNode<ScriptView> {
     /// Removes the given child from this node's list of children.
     ///
     /// Fails unless `child` is a child of this node. (FIXME: This is not yet checked.)
-    fn remove_child(&self, child: AbstractNode<ScriptView>) {
+    fn remove_child(&self, child: AbstractNode) {
         let this_node = self.mut_node();
         let child_node = child.mut_node();
         assert!(child_node.parent_node.is_some());
@@ -656,27 +606,27 @@ impl AbstractNode<ScriptView> {
     // Low-level pointer stitching wrappers
     //
 
-    fn set_parent_node(&self, new_parent_node: Option<AbstractNode<ScriptView>>) {
+    fn set_parent_node(&self, new_parent_node: Option<AbstractNode>) {
         let node = self.mut_node();
         node.set_parent_node(new_parent_node)
     }
 
-    fn set_first_child(&self, new_first_child: Option<AbstractNode<ScriptView>>) {
+    fn set_first_child(&self, new_first_child: Option<AbstractNode>) {
         let node = self.mut_node();
         node.set_first_child(new_first_child)
     }
 
-    fn set_last_child(&self, new_last_child: Option<AbstractNode<ScriptView>>) {
+    fn set_last_child(&self, new_last_child: Option<AbstractNode>) {
         let node = self.mut_node();
         node.set_last_child(new_last_child)
     }
     
-    fn set_prev_sibling(&self, new_prev_sibling: Option<AbstractNode<ScriptView>>) {
+    fn set_prev_sibling(&self, new_prev_sibling: Option<AbstractNode>) {
         let node = self.mut_node();
         node.set_prev_sibling(new_prev_sibling)
     }
     
-    fn set_next_sibling(&self, new_next_sibling: Option<AbstractNode<ScriptView>>) {
+    fn set_next_sibling(&self, new_next_sibling: Option<AbstractNode>) {
         let node = self.mut_node();
         node.set_next_sibling(new_next_sibling)
     }
@@ -686,8 +636,12 @@ impl AbstractNode<ScriptView> {
 // Iteration and traversal
 //
 
-impl<View> Iterator<AbstractNode<View>> for AbstractNodeChildrenIterator<View> {
-    fn next(&mut self) -> Option<AbstractNode<View>> {
+pub struct AbstractNodeChildrenIterator {
+    priv current_node: Option<AbstractNode>,
+}
+
+impl Iterator<AbstractNode> for AbstractNodeChildrenIterator {
+    fn next(&mut self) -> Option<AbstractNode> {
         let node = self.current_node;
         self.current_node = do self.current_node.and_then |node| {
             node.next_sibling()
@@ -696,12 +650,12 @@ impl<View> Iterator<AbstractNode<View>> for AbstractNodeChildrenIterator<View> {
     }
 }
 
-pub struct AncestorIterator<View> {
-    priv current: Option<AbstractNode<View>>,
+pub struct AncestorIterator {
+    priv current: Option<AbstractNode>,
 }
 
-impl<View> Iterator<AbstractNode<View>> for AncestorIterator<View> {
-    fn next(&mut self) -> Option<AbstractNode<View>> {
+impl Iterator<AbstractNode> for AncestorIterator {
+    fn next(&mut self) -> Option<AbstractNode> {
         if self.current.is_none() {
             return None;
         }
@@ -715,13 +669,13 @@ impl<View> Iterator<AbstractNode<View>> for AncestorIterator<View> {
 
 // FIXME: Do this without precomputing a vector of refs.
 // Easy for preorder; harder for postorder.
-pub struct TreeIterator<View> {
-    priv nodes: ~[AbstractNode<View>],
+pub struct TreeIterator {
+    priv nodes: ~[AbstractNode],
     priv index: uint,
 }
 
-impl<View> TreeIterator<View> {
-    fn new(nodes: ~[AbstractNode<View>]) -> TreeIterator<View> {
+impl TreeIterator {
+    fn new(nodes: ~[AbstractNode]) -> TreeIterator {
         TreeIterator {
             nodes: nodes,
             index: 0,
@@ -729,8 +683,8 @@ impl<View> TreeIterator<View> {
     }
 }
 
-impl<View> Iterator<AbstractNode<View>> for TreeIterator<View> {
-    fn next(&mut self) -> Option<AbstractNode<View>> {
+impl Iterator<AbstractNode> for TreeIterator {
+    fn next(&mut self) -> Option<AbstractNode> {
         if self.index >= self.nodes.len() {
             None
         } else {
@@ -741,42 +695,42 @@ impl<View> Iterator<AbstractNode<View>> for TreeIterator<View> {
     }
 }
 
-fn gather<View>(cur: &AbstractNode<View>, refs: &mut ~[AbstractNode<View>], postorder: bool) {
+fn gather_abstract_nodes(cur: &AbstractNode, refs: &mut ~[AbstractNode], postorder: bool) {
     if !postorder {
         refs.push(cur.clone());
     }
     for kid in cur.children() {
-        gather(&kid, refs, postorder)
+        gather_abstract_nodes(&kid, refs, postorder)
     }
     if postorder {
         refs.push(cur.clone());
     }
 }
 
-impl<View> AbstractNode<View> {
+impl AbstractNode {
     /// Iterates over all ancestors of this node.
-    pub fn ancestors(&self) -> AncestorIterator<View> {
+    pub fn ancestors(&self) -> AncestorIterator {
         AncestorIterator {
             current: self.parent_node(),
         }
     }
 
     /// Iterates over this node and all its descendants, in preorder.
-    pub fn traverse_preorder(&self) -> TreeIterator<View> {
+    pub fn traverse_preorder(&self) -> TreeIterator {
         let mut nodes = ~[];
-        gather(self, &mut nodes, false);
+        gather_abstract_nodes(self, &mut nodes, false);
         TreeIterator::new(nodes)
     }
 
     /// Iterates over this node and all its descendants, in postorder.
-    pub fn sequential_traverse_postorder(&self) -> TreeIterator<View> {
+    pub fn sequential_traverse_postorder(&self) -> TreeIterator {
         let mut nodes = ~[];
-        gather(self, &mut nodes, true);
+        gather_abstract_nodes(self, &mut nodes, true);
         TreeIterator::new(nodes)
     }
 }
 
-impl<View> Node<View> {
+impl Node {
     pub fn owner_doc(&self) -> AbstractDocument {
         self.owner_doc.unwrap()
     }
@@ -785,19 +739,17 @@ impl<View> Node<View> {
         self.owner_doc = Some(document);
     }
 
-    pub fn children(&self) -> AbstractNodeChildrenIterator<View> {
+    pub fn children(&self) -> AbstractNodeChildrenIterator {
         AbstractNodeChildrenIterator {
             current_node: self.first_child,
         }
     }
-}
 
-impl Node<ScriptView> {
     pub fn reflect_node<N: Reflectable>
             (node:      @mut N,
              document:  AbstractDocument,
              wrap_fn:   extern "Rust" fn(*JSContext, *JSObject, @mut N) -> *JSObject)
-             -> AbstractNode<ScriptView> {
+             -> AbstractNode {
         assert!(node.reflector().get_jsobject().is_null());
         let node = reflect_dom_object(node, document.document().window, wrap_fn);
         assert!(node.reflector().get_jsobject().is_not_null());
@@ -807,15 +759,15 @@ impl Node<ScriptView> {
         }
     }
 
-    pub fn new_inherited(type_id: NodeTypeId, doc: AbstractDocument) -> Node<ScriptView> {
+    pub fn new_inherited(type_id: NodeTypeId, doc: AbstractDocument) -> Node {
         Node::new_(type_id, Some(doc))
     }
 
-    pub fn new_without_doc(type_id: NodeTypeId) -> Node<ScriptView> {
+    pub fn new_without_doc(type_id: NodeTypeId) -> Node {
         Node::new_(type_id, None)
     }
 
-    fn new_(type_id: NodeTypeId, doc: Option<AbstractDocument>) -> Node<ScriptView> {
+    fn new_(type_id: NodeTypeId, doc: Option<AbstractDocument>) -> Node {
         Node {
             eventtarget: EventTarget::new_inherited(NodeTypeId),
             type_id: type_id,
@@ -845,9 +797,7 @@ impl Node<ScriptView> {
             (*js_window).data.page.reap_dead_layout_data(layout_data)
         }
     }
-}
 
-impl Node<ScriptView> {
     // http://dom.spec.whatwg.org/#dom-node-nodetype
     pub fn NodeType(&self) -> u16 {
         match self.type_id {
@@ -860,7 +810,7 @@ impl Node<ScriptView> {
         }
     }
 
-    pub fn NodeName(&self, abstract_self: AbstractNode<ScriptView>) -> DOMString {
+    pub fn NodeName(&self, abstract_self: AbstractNode) -> DOMString {
         match self.type_id {
             ElementNodeTypeId(*) => {
                 do abstract_self.with_imm_element |element| {
@@ -894,11 +844,11 @@ impl Node<ScriptView> {
         }
     }
 
-    pub fn GetParentNode(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetParentNode(&self) -> Option<AbstractNode> {
         self.parent_node
     }
 
-    pub fn GetParentElement(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetParentElement(&self) -> Option<AbstractNode> {
         self.parent_node.filtered(|parent| parent.is_element())
     }
 
@@ -906,23 +856,23 @@ impl Node<ScriptView> {
         self.first_child.is_some()
     }
 
-    pub fn GetFirstChild(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetFirstChild(&self) -> Option<AbstractNode> {
         self.first_child
     }
 
-    pub fn GetLastChild(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetLastChild(&self) -> Option<AbstractNode> {
         self.last_child
     }
 
-    pub fn GetPreviousSibling(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetPreviousSibling(&self) -> Option<AbstractNode> {
         self.prev_sibling
     }
 
-    pub fn GetNextSibling(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetNextSibling(&self) -> Option<AbstractNode> {
         self.next_sibling
     }
 
-    pub fn GetNodeValue(&self, abstract_self: AbstractNode<ScriptView>) -> Option<DOMString> {
+    pub fn GetNodeValue(&self, abstract_self: AbstractNode) -> Option<DOMString> {
         match self.type_id {
             // ProcessingInstruction
             CommentNodeTypeId | TextNodeTypeId => {
@@ -936,11 +886,12 @@ impl Node<ScriptView> {
         }
     }
 
-    pub fn SetNodeValue(&mut self, _abstract_self: AbstractNode<ScriptView>, _val: Option<DOMString>) -> ErrorResult {
+    pub fn SetNodeValue(&mut self, _abstract_self: AbstractNode, _val: Option<DOMString>)
+                        -> ErrorResult {
         Ok(())
     }
 
-    pub fn GetTextContent(&self, abstract_self: AbstractNode<ScriptView>) -> Option<DOMString> {
+    pub fn GetTextContent(&self, abstract_self: AbstractNode) -> Option<DOMString> {
         match self.type_id {
           DocumentFragmentNodeTypeId | ElementNodeTypeId(*) => {
             let mut content = ~"";
@@ -964,7 +915,7 @@ impl Node<ScriptView> {
         }
     }
 
-    pub fn ChildNodes(&mut self, abstract_self: AbstractNode<ScriptView>) -> @mut NodeList {
+    pub fn ChildNodes(&mut self, abstract_self: AbstractNode) -> @mut NodeList {
         match self.child_list {
             None => {
                 let window = self.owner_doc().document().window;
@@ -977,7 +928,7 @@ impl Node<ScriptView> {
     }
 
     // http://dom.spec.whatwg.org/#concept-node-adopt
-    fn adopt(node: AbstractNode<ScriptView>, document: AbstractDocument) {
+    fn adopt(node: AbstractNode, document: AbstractDocument) {
         // Step 1.
         match node.parent_node() {
             Some(parent) => Node::remove(node, parent, false),
@@ -996,11 +947,9 @@ impl Node<ScriptView> {
     }
 
     // http://dom.spec.whatwg.org/#concept-node-pre-insert
-    fn pre_insert(node: AbstractNode<ScriptView>,
-                  parent: AbstractNode<ScriptView>,
-                  child: Option<AbstractNode<ScriptView>>) -> Fallible<AbstractNode<ScriptView>> {
-        fn is_inclusive_ancestor_of(node: AbstractNode<ScriptView>,
-                                    parent: AbstractNode<ScriptView>) -> bool {
+    fn pre_insert(node: AbstractNode, parent: AbstractNode, child: Option<AbstractNode>)
+                  -> Fallible<AbstractNode> {
+        fn is_inclusive_ancestor_of(node: AbstractNode, parent: AbstractNode) -> bool {
             node == parent || parent.ancestors().any(|ancestor| ancestor == node)
         }
 
@@ -1060,7 +1009,7 @@ impl Node<ScriptView> {
         // Step 6.
         match parent.type_id() {
             DocumentNodeTypeId(_) => {
-                fn inclusively_followed_by_doctype(child: Option<AbstractNode<ScriptView>>) -> bool{
+                fn inclusively_followed_by_doctype(child: Option<AbstractNode>) -> bool{
                     match child {
                         Some(child) if child.is_doctype() => true,
                         Some(child) => {
@@ -1159,9 +1108,9 @@ impl Node<ScriptView> {
     }
 
     // http://dom.spec.whatwg.org/#concept-node-insert
-    fn insert(node: AbstractNode<ScriptView>,
-              parent: AbstractNode<ScriptView>,
-              child: Option<AbstractNode<ScriptView>>,
+    fn insert(node: AbstractNode,
+              parent: AbstractNode,
+              child: Option<AbstractNode>,
               suppress_observers: bool) {
         // XXX assert owner_doc
         // Step 1-3: ranges.
@@ -1198,8 +1147,7 @@ impl Node<ScriptView> {
     }
 
     // http://dom.spec.whatwg.org/#concept-node-replace-all
-    pub fn replace_all(node: Option<AbstractNode<ScriptView>>,
-                       parent: AbstractNode<ScriptView>) {
+    pub fn replace_all(node: Option<AbstractNode>, parent: AbstractNode) {
         // Step 1.
         match node {
             Some(node) => Node::adopt(node, parent.node().owner_doc()),
@@ -1207,7 +1155,7 @@ impl Node<ScriptView> {
         }
 
         // Step 2.
-        let removedNodes: ~[AbstractNode<ScriptView>] = parent.children().collect();
+        let removedNodes: ~[AbstractNode] = parent.children().collect();
 
         // Step 3.
         let addedNodes = match node {
@@ -1241,8 +1189,7 @@ impl Node<ScriptView> {
     }
 
     // http://dom.spec.whatwg.org/#concept-node-pre-remove
-    fn pre_remove(child: AbstractNode<ScriptView>,
-                  parent: AbstractNode<ScriptView>) -> Fallible<AbstractNode<ScriptView>> {
+    fn pre_remove(child: AbstractNode, parent: AbstractNode) -> Fallible<AbstractNode> {
         // Step 1.
         if child.parent_node() != Some(parent) {
             return Err(NotFound);
@@ -1256,9 +1203,7 @@ impl Node<ScriptView> {
     }
 
     // http://dom.spec.whatwg.org/#concept-node-remove
-    fn remove(node: AbstractNode<ScriptView>,
-              parent: AbstractNode<ScriptView>,
-              suppress_observers: bool) {
+    fn remove(node: AbstractNode, parent: AbstractNode, suppress_observers: bool) {
         assert!(node.parent_node() == Some(parent));
 
         // Step 1-5: ranges.
@@ -1273,9 +1218,8 @@ impl Node<ScriptView> {
         }
     }
 
-    pub fn SetTextContent(&mut self,
-                          abstract_self: AbstractNode<ScriptView>,
-                          value: Option<DOMString>) -> ErrorResult {
+    pub fn SetTextContent(&mut self, abstract_self: AbstractNode, value: Option<DOMString>)
+                          -> ErrorResult {
         let value = null_str_as_empty(&value);
         match self.type_id {
           DocumentFragmentNodeTypeId | ElementNodeTypeId(*) => {
@@ -1305,9 +1249,8 @@ impl Node<ScriptView> {
         Ok(())
     }
 
-    pub fn InsertBefore(&self,
-                        node: AbstractNode<ScriptView>,
-                        child: Option<AbstractNode<ScriptView>>) -> Fallible<AbstractNode<ScriptView>> {
+    pub fn InsertBefore(&self, node: AbstractNode, child: Option<AbstractNode>)
+                        -> Fallible<AbstractNode> {
         Node::pre_insert(node, node, child)
     }
 
@@ -1316,38 +1259,37 @@ impl Node<ScriptView> {
         document.document().wait_until_safe_to_modify_dom();
     }
 
-    pub fn AppendChild(&self,
-                       abstract_self: AbstractNode<ScriptView>,
-                       node: AbstractNode<ScriptView>) -> Fallible<AbstractNode<ScriptView>> {
+    pub fn AppendChild(&self, abstract_self: AbstractNode, node: AbstractNode)
+                       -> Fallible<AbstractNode> {
         Node::pre_insert(node, abstract_self, None)
     }
 
-    pub fn ReplaceChild(&mut self, _node: AbstractNode<ScriptView>, _child: AbstractNode<ScriptView>) -> Fallible<AbstractNode<ScriptView>> {
+    pub fn ReplaceChild(&mut self, _node: AbstractNode, _child: AbstractNode)
+                        -> Fallible<AbstractNode> {
         fail!("stub")
     }
 
-    pub fn RemoveChild(&self,
-                       abstract_self: AbstractNode<ScriptView>,
-                       node: AbstractNode<ScriptView>) -> Fallible<AbstractNode<ScriptView>> {
+    pub fn RemoveChild(&self, abstract_self: AbstractNode, node: AbstractNode)
+                       -> Fallible<AbstractNode> {
         Node::pre_remove(node, abstract_self)
     }
 
     pub fn Normalize(&mut self) {
     }
 
-    pub fn CloneNode(&self, _deep: bool) -> Fallible<AbstractNode<ScriptView>> {
+    pub fn CloneNode(&self, _deep: bool) -> Fallible<AbstractNode> {
         fail!("stub")
     }
 
-    pub fn IsEqualNode(&self, _node: Option<AbstractNode<ScriptView>>) -> bool {
+    pub fn IsEqualNode(&self, _node: Option<AbstractNode>) -> bool {
         false
     }
 
-    pub fn CompareDocumentPosition(&self, _other: AbstractNode<ScriptView>) -> u16 {
+    pub fn CompareDocumentPosition(&self, _other: AbstractNode) -> u16 {
         0
     }
 
-    pub fn Contains(&self, _other: Option<AbstractNode<ScriptView>>) -> bool {
+    pub fn Contains(&self, _other: Option<AbstractNode>) -> bool {
         false
     }
 
@@ -1384,38 +1326,38 @@ impl Node<ScriptView> {
     // Low-level pointer stitching
     //
 
-    pub fn set_parent_node(&mut self, new_parent_node: Option<AbstractNode<ScriptView>>) {
+    pub fn set_parent_node(&mut self, new_parent_node: Option<AbstractNode>) {
         let doc = self.owner_doc();
         doc.document().wait_until_safe_to_modify_dom();
         self.parent_node = new_parent_node
     }
 
-    pub fn set_first_child(&mut self, new_first_child: Option<AbstractNode<ScriptView>>) {
+    pub fn set_first_child(&mut self, new_first_child: Option<AbstractNode>) {
         let doc = self.owner_doc();
         doc.document().wait_until_safe_to_modify_dom();
         self.first_child = new_first_child
     }
 
-    pub fn set_last_child(&mut self, new_last_child: Option<AbstractNode<ScriptView>>) {
+    pub fn set_last_child(&mut self, new_last_child: Option<AbstractNode>) {
         let doc = self.owner_doc();
         doc.document().wait_until_safe_to_modify_dom();
         self.last_child = new_last_child
     }
 
-    pub fn set_prev_sibling(&mut self, new_prev_sibling: Option<AbstractNode<ScriptView>>) {
+    pub fn set_prev_sibling(&mut self, new_prev_sibling: Option<AbstractNode>) {
         let doc = self.owner_doc();
         doc.document().wait_until_safe_to_modify_dom();
         self.prev_sibling = new_prev_sibling
     }
 
-    pub fn set_next_sibling(&mut self, new_next_sibling: Option<AbstractNode<ScriptView>>) {
+    pub fn set_next_sibling(&mut self, new_next_sibling: Option<AbstractNode>) {
         let doc = self.owner_doc();
         doc.document().wait_until_safe_to_modify_dom();
         self.next_sibling = new_next_sibling
     }
 }
 
-impl Reflectable for Node<ScriptView> {
+impl Reflectable for Node {
     fn reflector<'a>(&'a self) -> &'a Reflector {
         self.eventtarget.reflector()
     }
@@ -1425,80 +1367,3 @@ impl Reflectable for Node<ScriptView> {
     }
 }
 
-/// A bottom-up, parallelizable traversal.
-pub trait PostorderNodeTraversal {
-    /// The operation to perform. Return true to continue or false to stop.
-    fn process(&self, node: AbstractNode<LayoutView>) -> bool;
-
-    /// Returns true if this node should be pruned. If this returns true, we skip the operation
-    /// entirely and do not process any descendant nodes. This is called *before* child nodes are
-    /// visited. The default implementation never prunes any nodes.
-    fn should_prune(&self, _node: AbstractNode<LayoutView>) -> bool {
-        false
-    }
-}
-
-/// A bottom-up, parallelizable traversal.
-pub trait PostorderNodeMutTraversal {
-    /// The operation to perform. Return true to continue or false to stop.
-    fn process(&mut self, node: AbstractNode<LayoutView>) -> bool;
-
-    /// Returns true if this node should be pruned. If this returns true, we skip the operation
-    /// entirely and do not process any descendant nodes. This is called *before* child nodes are
-    /// visited. The default implementation never prunes any nodes.
-    fn should_prune(&self, _node: AbstractNode<LayoutView>) -> bool {
-        false
-    }
-}
-
-
-impl AbstractNode<LayoutView> {
-    /// Traverses the tree in postorder.
-    ///
-    /// TODO(pcwalton): Offer a parallel version with a compatible API.
-    pub fn traverse_postorder<T:PostorderNodeTraversal>(self, traversal: &T) -> bool {
-        if traversal.should_prune(self) {
-            return true
-        }
-
-        let mut opt_kid = self.first_child();
-        loop {
-            match opt_kid {
-                None => break,
-                Some(kid) => {
-                    if !kid.traverse_postorder(traversal) {
-                        return false
-                    }
-                    opt_kid = kid.next_sibling()
-                }
-            }
-        }
-
-        traversal.process(self)
-    }
-
-    /// Traverses the tree in postorder.
-    ///
-    /// TODO(pcwalton): Offer a parallel version with a compatible API.
-    pub fn traverse_postorder_mut<T:PostorderNodeMutTraversal>(mut self, traversal: &mut T) -> bool {
-        if traversal.should_prune(self) {
-            return true
-        }
-
-        let mut opt_kid = self.first_child();
-        loop {
-            match opt_kid {
-                None => break,
-                Some(kid) => {
-                    if !kid.traverse_postorder_mut(traversal) {
-                        return false
-                    }
-                    opt_kid = kid.next_sibling()
-                }
-            }
-        }
-
-        traversal.process(self)
-    }
-
-}
diff --git a/servo/src/components/script/dom/nodelist.rs b/servo/src/components/script/dom/nodelist.rs
index ce44222a6043..6857add66001 100644
--- a/servo/src/components/script/dom/nodelist.rs
+++ b/servo/src/components/script/dom/nodelist.rs
@@ -4,12 +4,12 @@
 
 use dom::bindings::codegen::NodeListBinding;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::node::{AbstractNode, ScriptView};
+use dom::node::AbstractNode;
 use dom::window::Window;
 
 enum NodeListType {
-    Simple(~[AbstractNode<ScriptView>]),
-    Children(AbstractNode<ScriptView>)
+    Simple(~[AbstractNode]),
+    Children(AbstractNode)
 }
 
 pub struct NodeList {
@@ -34,11 +34,11 @@ impl NodeList {
                            window, NodeListBinding::Wrap)
     }
 
-    pub fn new_simple_list(window: @mut Window, elements: ~[AbstractNode<ScriptView>]) -> @mut NodeList {
+    pub fn new_simple_list(window: @mut Window, elements: ~[AbstractNode]) -> @mut NodeList {
         NodeList::new(window, Simple(elements))
     }
 
-    pub fn new_child_list(window: @mut Window, node: AbstractNode<ScriptView>) -> @mut NodeList {
+    pub fn new_child_list(window: @mut Window, node: AbstractNode) -> @mut NodeList {
         NodeList::new(window, Children(node))
     }
 
@@ -49,7 +49,7 @@ impl NodeList {
         }
     }
 
-    pub fn Item(&self, index: u32) -> Option<AbstractNode<ScriptView>> {
+    pub fn Item(&self, index: u32) -> Option<AbstractNode> {
         match self.list_type {
             _ if index >= self.Length() => None,
             Simple(ref elems) => Some(elems[index]),
@@ -57,7 +57,7 @@ impl NodeList {
         }
     }
 
-    pub fn IndexedGetter(&self, index: u32, found: &mut bool) -> Option<AbstractNode<ScriptView>> {
+    pub fn IndexedGetter(&self, index: u32, found: &mut bool) -> Option<AbstractNode> {
         let item = self.Item(index);
         *found = item.is_some();
         item
diff --git a/servo/src/components/script/dom/text.rs b/servo/src/components/script/dom/text.rs
index 34f981f3a53d..2875d115245f 100644
--- a/servo/src/components/script/dom/text.rs
+++ b/servo/src/components/script/dom/text.rs
@@ -6,7 +6,7 @@ use dom::bindings::codegen::TextBinding;
 use dom::bindings::utils::{DOMString, Fallible};
 use dom::characterdata::CharacterData;
 use dom::document::AbstractDocument;
-use dom::node::{AbstractNode, ScriptView, Node, TextNodeTypeId};
+use dom::node::{AbstractNode, Node, TextNodeTypeId};
 use dom::window::Window;
 
 /// An HTML text node.
@@ -21,16 +21,16 @@ impl Text {
         }
     }
 
-    pub fn new(text: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+    pub fn new(text: ~str, document: AbstractDocument) -> AbstractNode {
         let node = Text::new_inherited(text, document);
         Node::reflect_node(@mut node, document, TextBinding::Wrap)
     }
 
-    pub fn Constructor(owner: @mut Window, text: DOMString) -> Fallible<AbstractNode<ScriptView>> {
+    pub fn Constructor(owner: @mut Window, text: DOMString) -> Fallible<AbstractNode> {
         Ok(Text::new(text.clone(), owner.Document()))
     }
 
-    pub fn SplitText(&self, _offset: u32) -> Fallible<AbstractNode<ScriptView>> {
+    pub fn SplitText(&self, _offset: u32) -> Fallible<AbstractNode> {
         fail!("unimplemented")
     }
 
diff --git a/servo/src/components/script/dom/uievent.rs b/servo/src/components/script/dom/uievent.rs
index db087a0e6e48..83503c7ee567 100644
--- a/servo/src/components/script/dom/uievent.rs
+++ b/servo/src/components/script/dom/uievent.rs
@@ -5,7 +5,7 @@
 use dom::bindings::codegen::UIEventBinding;
 use dom::bindings::utils::{DOMString, Fallible};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::node::{AbstractNode, ScriptView};
+use dom::node::AbstractNode;
 use dom::event::{AbstractEvent, Event, EventTypeId, UIEventTypeId};
 use dom::window::Window;
 use dom::windowproxy::WindowProxy;
@@ -85,7 +85,7 @@ impl UIEvent {
         0
     }
 
-    pub fn GetRangeParent(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetRangeParent(&self) -> Option<AbstractNode> {
         //TODO
         None
     }
diff --git a/servo/src/components/script/dom/window.rs b/servo/src/components/script/dom/window.rs
index 9f55e3cf3c53..54660c4286ab 100644
--- a/servo/src/components/script/dom/window.rs
+++ b/servo/src/components/script/dom/window.rs
@@ -8,7 +8,7 @@ use dom::bindings::utils::{trace_option, trace_reflector};
 use dom::bindings::utils::DOMString;
 use dom::document::AbstractDocument;
 use dom::eventtarget::{EventTarget, WindowTypeId};
-use dom::node::{AbstractNode, ScriptView};
+use dom::node::AbstractNode;
 use dom::location::Location;
 use dom::navigator::Navigator;
 
@@ -114,7 +114,7 @@ impl Window {
     pub fn Blur(&self) {
     }
 
-    pub fn GetFrameElement(&self) -> Option<AbstractNode<ScriptView>> {
+    pub fn GetFrameElement(&self) -> Option<AbstractNode> {
         None
     }
 
diff --git a/servo/src/components/script/html/hubbub_html_parser.rs b/servo/src/components/script/html/hubbub_html_parser.rs
index f854a546371b..da9adf016804 100644
--- a/servo/src/components/script/html/hubbub_html_parser.rs
+++ b/servo/src/components/script/html/hubbub_html_parser.rs
@@ -9,7 +9,7 @@ use dom::htmlheadingelement::{Heading1, Heading2, Heading3, Heading4, Heading5,
 use dom::htmliframeelement::IFrameSize;
 use dom::htmlformelement::HTMLFormElement;
 use dom::namespace;
-use dom::node::{AbstractNode, ElementNodeTypeId, ScriptView};
+use dom::node::{AbstractNode, ElementNodeTypeId};
 use dom::types::*;
 use html::cssparse::{InlineProvenance, StylesheetProvenance, UrlProvenance, spawn_css_parser};
 use script_task::page_from_context;
@@ -77,11 +77,11 @@ trait NodeWrapping {
     unsafe fn from_hubbub_node(n: hubbub::NodeDataPtr) -> Self;
 }
 
-impl NodeWrapping for AbstractNode<ScriptView> {
+impl NodeWrapping for AbstractNode {
     unsafe fn to_hubbub_node(self) -> hubbub::NodeDataPtr {
         cast::transmute(self)
     }
-    unsafe fn from_hubbub_node(n: hubbub::NodeDataPtr) -> AbstractNode<ScriptView> {
+    unsafe fn from_hubbub_node(n: hubbub::NodeDataPtr) -> AbstractNode {
         cast::transmute(n)
     }
 }
@@ -159,7 +159,7 @@ fn js_script_listener(to_parent: SharedChan<HtmlDiscoveryMessage>,
 // Silly macros to handle constructing      DOM nodes. This produces bad code and should be optimized
 // via atomization (issue #85).
 
-pub fn build_element_from_tag(tag: ~str, document: AbstractDocument) -> AbstractNode<ScriptView> {
+pub fn build_element_from_tag(tag: ~str, document: AbstractDocument) -> AbstractNode {
     // TODO (Issue #85): use atoms
     handle_element!(document, tag, "a",         HTMLAnchorElement);
     handle_element!(document, tag, "applet",    HTMLAppletElement);
@@ -299,7 +299,7 @@ pub fn parse_html(cx: *JSContext,
     let mut parser = hubbub::Parser("UTF-8", false);
     debug!("created parser");
 
-    let document_node = AbstractNode::<ScriptView>::from_document(document);
+    let document_node = AbstractNode::from_document(document);
     parser.set_document_node(unsafe { document_node.to_hubbub_node() });
     parser.enable_scripting(true);
     parser.enable_styling(true);
@@ -415,8 +415,8 @@ pub fn parse_html(cx: *JSContext,
         append_child: |parent: hubbub::NodeDataPtr, child: hubbub::NodeDataPtr| {
             unsafe {
                 debug!("append child {:x} {:x}", parent, child);
-                let parent: AbstractNode<ScriptView> = NodeWrapping::from_hubbub_node(parent);
-                let child: AbstractNode<ScriptView> = NodeWrapping::from_hubbub_node(child);
+                let parent: AbstractNode = NodeWrapping::from_hubbub_node(parent);
+                let child: AbstractNode = NodeWrapping::from_hubbub_node(child);
                 parent.AppendChild(child);
             }
             child
@@ -460,7 +460,7 @@ pub fn parse_html(cx: *JSContext,
         },
         complete_script: |script| {
             unsafe {
-                let scriptnode: AbstractNode<ScriptView> = NodeWrapping::from_hubbub_node(script);
+                let scriptnode: AbstractNode = NodeWrapping::from_hubbub_node(script);
                 do scriptnode.with_imm_element |script| {
                     match script.get_attr(None, "src") {
                         Some(src) => {
@@ -489,7 +489,7 @@ pub fn parse_html(cx: *JSContext,
         complete_style: |style| {
             // We've reached the end of a <style> so we can submit all the text to the parser.
             unsafe {
-                let style: AbstractNode<ScriptView> = NodeWrapping::from_hubbub_node(style);
+                let style: AbstractNode = NodeWrapping::from_hubbub_node(style);
                 let url = FromStr::from_str("http://example.com/"); // FIXME
                 let url_cell = Cell::new(url);
 
diff --git a/servo/src/components/script/layout_interface.rs b/servo/src/components/script/layout_interface.rs
index 8de94f8a04ed..c0b35ef6a3f8 100644
--- a/servo/src/components/script/layout_interface.rs
+++ b/servo/src/components/script/layout_interface.rs
@@ -6,7 +6,7 @@
 /// coupling between these two components, and enables the DOM to be placed in a separate crate
 /// from layout.
 
-use dom::node::{AbstractNode, LayoutDataRef, LayoutView, ScriptView};
+use dom::node::{AbstractNode, LayoutDataRef};
 
 use extra::url::Url;
 use geom::point::Point2D;
@@ -51,16 +51,16 @@ pub enum Msg {
 /// Synchronous messages that script can send to layout.
 pub enum LayoutQuery {
     /// Requests the dimensions of the content box, as in the `getBoundingClientRect()` call.
-    ContentBoxQuery(AbstractNode<ScriptView>, Chan<ContentBoxResponse>),
+    ContentBoxQuery(AbstractNode, Chan<ContentBoxResponse>),
     /// Requests the dimensions of all the content boxes, as in the `getClientRects()` call.
-    ContentBoxesQuery(AbstractNode<ScriptView>, Chan<ContentBoxesResponse>),
+    ContentBoxesQuery(AbstractNode, Chan<ContentBoxesResponse>),
     /// Requests the node containing the point of interest
-    HitTestQuery(AbstractNode<ScriptView>, Point2D<f32>, Chan<Result<HitTestResponse, ()>>),
+    HitTestQuery(AbstractNode, Point2D<f32>, Chan<Result<HitTestResponse, ()>>),
 }
 
 pub struct ContentBoxResponse(Rect<Au>);
 pub struct ContentBoxesResponse(~[Rect<Au>]);
-pub struct HitTestResponse(AbstractNode<LayoutView>);
+pub struct HitTestResponse(AbstractNode);
 
 /// Determines which part of the 
 #[deriving(Eq, Ord)]
@@ -85,7 +85,7 @@ impl DocumentDamageLevel {
 /// Note that this is fairly coarse-grained and is separate from layout's notion of the document
 pub struct DocumentDamage {
     /// The topmost node in the tree that has changed.
-    root: AbstractNode<ScriptView>,
+    root: AbstractNode,
     /// The amount of damage that occurred.
     level: DocumentDamageLevel,
 }
@@ -102,7 +102,7 @@ pub enum ReflowGoal {
 /// Information needed for a reflow.
 pub struct Reflow {
     /// The document node.
-    document_root: AbstractNode<ScriptView>,
+    document_root: AbstractNode,
     /// The style changes that need to be done.
     damage: DocumentDamage,
     /// The goal of reflow: either to render to the screen or to flush layout info for script.
diff --git a/servo/src/components/script/script_task.rs b/servo/src/components/script/script_task.rs
index 746b7afa03f5..38803bb4456f 100644
--- a/servo/src/components/script/script_task.rs
+++ b/servo/src/components/script/script_task.rs
@@ -26,7 +26,6 @@ use layout_interface::{Reflow, ReflowDocumentDamage, ReflowForDisplay, ReflowGoa
 use layout_interface::ContentChangedDocumentDamage;
 use layout_interface;
 
-use dom::node::ScriptView;
 use extra::url::Url;
 use geom::point::Point2D;
 use geom::size::Size2D;
@@ -53,7 +52,6 @@ use std::ptr;
 use std::str::eq_slice;
 use std::task::{spawn_sched, SingleThreaded};
 use std::util::replace;
-use style::{TElement, TNode};
 
 /// Messages used to control the script task.
 pub enum ScriptMsg {
@@ -133,7 +131,7 @@ pub struct Page {
     resize_event: Option<Size2D<uint>>,
 
     /// Pending scroll to fragment event, if any
-    fragment_node: Option<AbstractNode<ScriptView>>
+    fragment_node: Option<AbstractNode>
 }
 
 pub struct PageTree {
@@ -804,7 +802,7 @@ impl ScriptTask {
         page.fragment_node = fragment.map_default(None, |fragid| self.find_fragment_node(page, fragid));
     }
 
-    fn find_fragment_node(&self, page: &mut Page, fragid: ~str) -> Option<AbstractNode<ScriptView>> {
+    fn find_fragment_node(&self, page: &mut Page, fragid: ~str) -> Option<AbstractNode> {
         let document = page.frame.expect("root frame is None").document; 
         match document.document().GetElementById(fragid.to_owned()) {
             Some(node) => Some(node),
@@ -823,7 +821,7 @@ impl ScriptTask {
         }
     }
 
-    fn scroll_fragment_point(&self, pipeline_id: PipelineId, page: &mut Page, node: AbstractNode<ScriptView>) {
+    fn scroll_fragment_point(&self, pipeline_id: PipelineId, page: &mut Page, node: AbstractNode) {
         let (port, chan) = comm::stream();
         match page.query_layout(ContentBoxQuery(node, chan), port) {
             ContentBoxResponse(rect) => {
diff --git a/servo/src/components/style/node.rs b/servo/src/components/style/node.rs
index f585ff86e9b8..fef83d75810b 100644
--- a/servo/src/components/style/node.rs
+++ b/servo/src/components/style/node.rs
@@ -2,11 +2,9 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-//! Traits that nodes must implement. Breaks the otherwise-cyclic dependency between script and
+//! Traits that nodes must implement. Breaks the otherwise-cyclic dependency between layout and
 //! style.
 
-/// FIXME(pcwalton): Should not require `Clone` and should instead return references. When this
-/// happens this will need to only be implemented for `AbstractNode<LayoutView>`.
 pub trait TNode<E:TElement> : Clone {
     fn parent_node(&self) -> Option<Self>;
     fn prev_sibling(&self) -> Option<Self>;