Merge in servo/master

25 files changed, 1014 insertions, 853 deletions

diff --git a/components/script/devtools.rs b/components/script/devtools.rs
index 5333b9a4cee..051002c7478 100644
--- a/components/script/devtools.rs
+++ b/components/script/devtools.rs
@@ -11,7 +11,7 @@ use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
 use dom::bindings::codegen::Bindings::DOMRectBinding::{DOMRectMethods};
 use dom::bindings::codegen::Bindings::ElementBinding::{ElementMethods};
 use dom::node::{Node, NodeHelpers};
-use dom::window::{ScriptHelpers};
+use dom::window::{WindowHelpers, ScriptHelpers};
 use dom::element::Element;
 use dom::document::DocumentHelpers;
 use page::Page;
@@ -24,8 +24,7 @@ use std::rc::Rc;
 
 pub fn handle_evaluate_js(page: &Rc<Page>, pipeline: PipelineId, eval: String, reply: Sender<EvaluateJSReply>){
     let page = get_page(&*page, pipeline);
-    let frame = page.frame();
-    let window = frame.as_ref().unwrap().window.root();
+    let window = page.window().root();
     let cx = window.r().get_cx();
     let rval = window.r().evaluate_js_on_global_with_result(eval.as_slice());
 
@@ -49,8 +48,7 @@ pub fn handle_evaluate_js(page: &Rc<Page>, pipeline: PipelineId, eval: String, r
 
 pub fn handle_get_root_node(page: &Rc<Page>, pipeline: PipelineId, reply: Sender<NodeInfo>) {
     let page = get_page(&*page, pipeline);
-    let frame = page.frame();
-    let document = frame.as_ref().unwrap().document.root();
+    let document = page.document().root();
 
     let node: JSRef<Node> = NodeCast::from_ref(document.r());
     reply.send(node.summarize()).unwrap();
@@ -58,8 +56,7 @@ pub fn handle_get_root_node(page: &Rc<Page>, pipeline: PipelineId, reply: Sender
 
 pub fn handle_get_document_element(page: &Rc<Page>, pipeline: PipelineId, reply: Sender<NodeInfo>) {
     let page = get_page(&*page, pipeline);
-    let frame = page.frame();
-    let document = frame.as_ref().unwrap().document.root();
+    let document = page.document().root();
     let document_element = document.r().GetDocumentElement().root().unwrap();
 
     let node: JSRef<Node> = NodeCast::from_ref(document_element.r());
@@ -68,8 +65,7 @@ pub fn handle_get_document_element(page: &Rc<Page>, pipeline: PipelineId, reply:
 
 fn find_node_by_unique_id(page: &Rc<Page>, pipeline: PipelineId, node_id: String) -> Temporary<Node> {
     let page = get_page(&*page, pipeline);
-    let frame = page.frame();
-    let document = frame.as_ref().unwrap().document.root();
+    let document = page.document().root();
     let node: JSRef<Node> = NodeCast::from_ref(document.r());
 
     for candidate in node.traverse_preorder() {
@@ -110,5 +106,6 @@ pub fn handle_modify_attribute(page: &Rc<Page>, pipeline: PipelineId, node_id: S
 
 pub fn handle_wants_live_notifications(page: &Rc<Page>, pipeline_id: PipelineId, send_notifications: bool) {
     let page = get_page(&*page, pipeline_id);
-    page.devtools_wants_updates.set(send_notifications);
+    let window = page.window().root();
+    window.r().set_devtools_wants_updates(send_notifications);
 }
diff --git a/components/script/dom/bindings/codegen/CodegenRust.py b/components/script/dom/bindings/codegen/CodegenRust.py
index 203bf60f340..9274c6cafb7 100644
--- a/components/script/dom/bindings/codegen/CodegenRust.py
+++ b/components/script/dom/bindings/codegen/CodegenRust.py
@@ -4643,7 +4643,6 @@ class CGBindingRoot(CGThing):
             'dom::bindings::proxyhandler::{fill_property_descriptor, get_expando_object}',
             'dom::bindings::proxyhandler::{get_property_descriptor}',
             'dom::bindings::str::ByteString',
-            'page::JSPageInfo',
             'libc',
             'util::str::DOMString',
             'std::borrow::ToOwned',
diff --git a/components/script/dom/bindings/global.rs b/components/script/dom/bindings/global.rs
index dc42d0da6e0..3d17778c6b1 100644
--- a/components/script/dom/bindings/global.rs
+++ b/components/script/dom/bindings/global.rs
@@ -11,7 +11,7 @@ use dom::bindings::conversions::FromJSValConvertible;
 use dom::bindings::js::{JS, JSRef, Root, Unrooted};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::workerglobalscope::{WorkerGlobalScope, WorkerGlobalScopeHelpers};
-use dom::window;
+use dom::window::{self, WindowHelpers};
 use script_task::ScriptChan;
 
 use net::resource_task::ResourceTask;
@@ -84,7 +84,7 @@ impl<'a> GlobalRef<'a> {
     /// Get the `ResourceTask` for this global scope.
     pub fn resource_task(&self) -> ResourceTask {
         match *self {
-            GlobalRef::Window(ref window) => window.page().resource_task.clone(),
+            GlobalRef::Window(ref window) => window.resource_task().clone(),
             GlobalRef::Worker(ref worker) => worker.resource_task().clone(),
         }
     }
diff --git a/components/script/dom/bindings/js.rs b/components/script/dom/bindings/js.rs
index b370b3a073f..7ada9f45d14 100644
--- a/components/script/dom/bindings/js.rs
+++ b/components/script/dom/bindings/js.rs
@@ -727,7 +727,7 @@ impl<'a, T> Clone for JSRef<'a, T> {
     }
 }
 
-impl<'a, T> PartialEq for JSRef<'a, T> {
+impl<'a, 'b, T> PartialEq<JSRef<'b, T>> for JSRef<'a, T> {
     fn eq(&self, other: &JSRef<T>) -> bool {
         self.ptr == other.ptr
     }
diff --git a/components/script/dom/browsercontext.rs b/components/script/dom/browsercontext.rs
index e21533bbfe0..a3af0a8b02a 100644
--- a/components/script/dom/browsercontext.rs
+++ b/components/script/dom/browsercontext.rs
@@ -71,14 +71,12 @@ impl BrowserContext {
     fn create_window_proxy(&mut self) {
         let win = self.active_window().root();
         let win = win.r();
-        let page = win.page();
-        let js_info = page.js_info();
 
-        let WindowProxyHandler(handler) = js_info.as_ref().unwrap().dom_static.windowproxy_handler;
+        let WindowProxyHandler(handler) = win.windowproxy_handler();
         assert!(!handler.is_null());
 
         let parent = win.reflector().get_jsobject();
-        let cx = js_info.as_ref().unwrap().js_context.ptr;
+        let cx = win.get_cx();
         let wrapper = with_compartment(cx, parent, || unsafe {
             WrapperNew(cx, parent, handler)
         });
diff --git a/components/script/dom/canvasrenderingcontext2d.rs b/components/script/dom/canvasrenderingcontext2d.rs
index d0ae869d847..8367e27d05e 100644
--- a/components/script/dom/canvasrenderingcontext2d.rs
+++ b/components/script/dom/canvasrenderingcontext2d.rs
@@ -151,7 +151,7 @@ impl<'a> CanvasRenderingContext2DMethods for JSRef<'a, CanvasRenderingContext2D>
     }
 
     fn LineTo(self, x: f64, y: f64) {
-        self.renderer.send(CanvasMsg::LineTo(Point2D(x as f32, y as f32)));
+        self.renderer.send(CanvasMsg::LineTo(Point2D(x as f32, y as f32))).unwrap();
     }
 
     fn BezierCurveTo(self, cp1x: f64, cp1y: f64, cp2x: f64, cp2y: f64, x: f64, y: f64) {
diff --git a/components/script/dom/console.rs b/components/script/dom/console.rs
index 4dec1c3bd45..6308556ef2e 100644
--- a/components/script/dom/console.rs
+++ b/components/script/dom/console.rs
@@ -7,6 +7,7 @@ use dom::bindings::codegen::Bindings::ConsoleBinding::ConsoleMethods;
 use dom::bindings::global::{GlobalRef, GlobalField};
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
+use dom::window::WindowHelpers;
 use devtools_traits::{DevtoolsControlMsg, ConsoleMessage};
 use util::str::DOMString;
 
@@ -66,8 +67,8 @@ fn propagate_console_msg(console: &JSRef<Console>, console_message: ConsoleMessa
     let global = console.global.root();
     match global.r() {
         GlobalRef::Window(window_ref) => {
-            let pipelineId = window_ref.page().id;
-            console.global.root().r().as_window().page().devtools_chan.as_ref().map(|chan| {
+            let pipelineId = window_ref.pipeline();
+            console.global.root().r().as_window().devtools_chan().as_ref().map(|chan| {
                 chan.send(DevtoolsControlMsg::SendConsoleMessage(
                     pipelineId, console_message.clone())).unwrap();
             });
diff --git a/components/script/dom/cssstyledeclaration.rs b/components/script/dom/cssstyledeclaration.rs
index 2337e6c061a..b41adcb8b06 100644
--- a/components/script/dom/cssstyledeclaration.rs
+++ b/components/script/dom/cssstyledeclaration.rs
@@ -14,7 +14,7 @@ use dom::document::DocumentHelpers;
 use dom::element::{Element, ElementHelpers, StylePriority};
 use dom::htmlelement::HTMLElement;
 use dom::node::{window_from_node, document_from_node, NodeDamage, Node};
-use dom::window::Window;
+use dom::window::{Window, WindowHelpers};
 use util::str::DOMString;
 use string_cache::Atom;
 use style::properties::{is_supported_property, longhands_from_shorthand, parse_style_attribute};
@@ -221,10 +221,8 @@ impl<'a> CSSStyleDeclarationMethods for JSRef<'a, CSSStyleDeclaration> {
 
         let owner = self.owner.root();
         let window = window_from_node(owner.r()).root();
-        let window = window.r();
-        let page = window.page();
         let decl_block = parse_style_attribute(synthesized_declaration.as_slice(),
-                                               &page.get_url());
+                                               &window.r().get_url());
 
         // Step 7
         if decl_block.normal.len() == 0 {
@@ -270,10 +268,8 @@ impl<'a> CSSStyleDeclarationMethods for JSRef<'a, CSSStyleDeclaration> {
 
         let owner = self.owner.root();
         let window = window_from_node(owner.r()).root();
-        let window = window.r();
-        let page = window.page();
         let decl_block = parse_style_attribute(property.as_slice(),
-                                               &page.get_url());
+                                               &window.r().get_url());
         let element: JSRef<Element> = ElementCast::from_ref(owner.r());
 
         // Step 5
diff --git a/components/script/dom/document.rs b/components/script/dom/document.rs
index 6e5413ebdc8..ffa22a48182 100644
--- a/components/script/dom/document.rs
+++ b/components/script/dom/document.rs
@@ -11,7 +11,6 @@ use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::Bindings::EventTargetBinding::EventTargetMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
 use dom::bindings::codegen::Bindings::NodeFilterBinding::NodeFilter;
-use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::codegen::InheritTypes::{DocumentDerived, EventCast, HTMLElementCast};
 use dom::bindings::codegen::InheritTypes::{HTMLHeadElementCast, TextCast, ElementCast};
 use dom::bindings::codegen::InheritTypes::{DocumentTypeCast, HTMLHtmlElementCast, NodeCast};
@@ -59,12 +58,14 @@ use dom::treewalker::TreeWalker;
 use dom::uievent::UIEvent;
 use dom::window::{Window, WindowHelpers};
 
+use layout_interface::{HitTestResponse, MouseOverResponse};
 use msg::compositor_msg::ScriptListener;
 use msg::constellation_msg::{Key, KeyState, KeyModifiers};
 use msg::constellation_msg::{SUPER, ALT, SHIFT, CONTROL};
 use net::resource_task::ControlMsg::{SetCookiesForUrl, GetCookiesForUrl};
 use net::cookie_storage::CookieSource::NonHTTP;
 use script_task::Runnable;
+use script_traits::UntrustedNodeAddress;
 use util::namespace;
 use util::str::{DOMString, split_html_space_chars};
 use layout_interface::{ReflowGoal, ReflowQueryType};
@@ -201,6 +202,8 @@ pub trait DocumentHelpers<'a> {
     fn register_named_element(self, element: JSRef<Element>, id: Atom);
     fn load_anchor_href(self, href: DOMString);
     fn find_fragment_node(self, fragid: DOMString) -> Option<Temporary<Element>>;
+    fn hit_test(self, point: &Point2D<f32>) -> Option<UntrustedNodeAddress>;
+    fn get_nodes_under_mouse(self, point: &Point2D<f32>) -> Vec<UntrustedNodeAddress>;
     fn set_ready_state(self, state: DocumentReadyState);
     fn get_focused_element(self) -> Option<Temporary<Element>>;
     fn begin_focus_transaction(self);
@@ -241,7 +244,7 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
         let browser_context = browser_context.as_ref().unwrap();
         let active_document = browser_context.active_document().root();
 
-        if self.clone() != active_document.r() {
+        if self != active_document.r() {
             return false;
         }
         // FIXME: It should also check whether the browser context is top-level or not
@@ -264,7 +267,7 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
             Quirks => {
                 let window = self.window.root();
                 let window = window.r();
-                let LayoutChan(ref layout_chan) = window.page().layout_chan;
+                let LayoutChan(ref layout_chan) = window.layout_chan();
                 layout_chan.send(Msg::SetQuirksMode).unwrap();
             }
             NoQuirks | LimitedQuirks => {}
@@ -377,6 +380,44 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
         })
     }
 
+    fn hit_test(self, point: &Point2D<f32>) -> Option<UntrustedNodeAddress> {
+        let root = self.GetDocumentElement().root();
+        let root = match root.r() {
+            Some(root) => root,
+            None => return None,
+        };
+        let root = NodeCast::from_ref(root);
+        let win = self.window.root();
+        let address = match win.r().layout().hit_test(root.to_trusted_node_address(), *point) {
+            Ok(HitTestResponse(node_address)) => {
+                Some(node_address)
+            }
+            Err(()) => {
+                debug!("layout query error");
+                None
+            }
+        };
+        address
+    }
+
+    fn get_nodes_under_mouse(self, point: &Point2D<f32>) -> Vec<UntrustedNodeAddress> {
+        let root = self.GetDocumentElement().root();
+        let root = match root.r() {
+            Some(root) => root,
+            None => return vec!(),
+        };
+        let root: JSRef<Node> = NodeCast::from_ref(root);
+        let win = self.window.root();
+        match win.r().layout().mouse_over(root.to_trusted_node_address(), *point) {
+            Ok(MouseOverResponse(node_address)) => {
+                node_address
+            }
+            Err(()) => {
+                vec!()
+            }
+        }
+    }
+
     // https://html.spec.whatwg.org/multipage/dom.html#current-document-readiness
     fn set_ready_state(self, state: DocumentReadyState) {
         self.ready_state.set(state);
@@ -416,7 +457,7 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
     /// Sends this document's title to the compositor.
     fn send_title_to_compositor(self) {
         let window = self.window().root();
-        window.r().page().send_title_to_compositor();
+        window.r().compositor().set_title(window.r().pipeline(), Some(self.Title()));
     }
 
     fn dirty_all_nodes(self) {
@@ -428,10 +469,7 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
 
     fn handle_click_event(self, js_runtime: *mut JSRuntime, _button: uint, point: Point2D<f32>) {
         debug!("ClickEvent: clicked at {:?}", point);
-        let window = self.window.root();
-        let window = window.r();
-        let page = window.page();
-        let node = match page.hit_test(&point) {
+        let node = match self.hit_test(&point) {
             Some(node_address) => {
                 debug!("node address is {:?}", node_address.0);
                 node::from_untrusted_node_address(js_runtime, node_address)
@@ -460,48 +498,40 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
             return;
         }
 
-        match *page.frame() {
-            Some(ref frame) => {
-                let window = frame.window.root();
-                let doc = window.r().Document().root();
-                doc.r().begin_focus_transaction();
-
-                // https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#event-type-click
-                let x = point.x as i32;
-                let y = point.y as i32;
-                let event = MouseEvent::new(window.r(),
-                                            "click".to_owned(),
-                                            true,
-                                            true,
-                                            Some(window.r()),
-                                            0i32,
-                                            x, y, x, y,
-                                            false, false, false, false,
-                                            0i16,
-                                            None).root();
-                let event: JSRef<Event> = EventCast::from_ref(event.r());
-
-                // https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#trusted-events
-                event.set_trusted(true);
-                // https://html.spec.whatwg.org/multipage/interaction.html#run-authentic-click-activation-steps
-                el.authentic_click_activation(event);
-
-                doc.r().commit_focus_transaction();
-                window.r().flush_layout(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery);
-            }
-            None => {}
-        }
+        self.begin_focus_transaction();
+
+        let window = self.window.root();
+
+        // https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#event-type-click
+        let x = point.x as i32;
+        let y = point.y as i32;
+        let event = MouseEvent::new(window.r(),
+                                    "click".to_owned(),
+                                    true,
+                                    true,
+                                    Some(window.r()),
+                                    0i32,
+                                    x, y, x, y,
+                                    false, false, false, false,
+                                    0i16,
+                                    None).root();
+        let event: JSRef<Event> = EventCast::from_ref(event.r());
+
+        // https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#trusted-events
+        event.set_trusted(true);
+        // https://html.spec.whatwg.org/multipage/interaction.html#run-authentic-click-activation-steps
+        el.authentic_click_activation(event);
+
+        self.commit_focus_transaction();
+        window.r().reflow(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery);
     }
 
     /// Return need force reflow or not
     fn handle_mouse_move_event(self, js_runtime: *mut JSRuntime, point: Point2D<f32>,
                                prev_mouse_over_targets: &mut Vec<JS<Node>>) -> bool {
-        let window = self.window.root();
-        let window = window.r();
-        let page = window.page();
         let mut needs_reflow = false;
         // Build a list of elements that are currently under the mouse.
-        let mouse_over_addresses = page.get_nodes_under_mouse(&point);
+        let mouse_over_addresses = self.get_nodes_under_mouse(&point);
         let mouse_over_targets: Vec<JS<Node>> = mouse_over_addresses.iter()
                                                                     .filter_map(|node_address| {
             let node = node::from_untrusted_node_address(js_runtime, *node_address);
@@ -534,27 +564,24 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
             let top_most_node =
                 node::from_untrusted_node_address(js_runtime, mouse_over_addresses[0]).root();
 
-            if let Some(ref frame) = *page.frame() {
-                let window = frame.window.root();
-
-                let x = point.x.to_i32().unwrap_or(0);
-                let y = point.y.to_i32().unwrap_or(0);
-
-                let mouse_event = MouseEvent::new(window.r(),
-                    "mousemove".to_owned(),
-                    true,
-                    true,
-                    Some(window.r()),
-                    0i32,
-                    x, y, x, y,
-                    false, false, false, false,
-                    0i16,
-                    None).root();
-
-                let event: JSRef<Event> = EventCast::from_ref(mouse_event.r());
-                let target: JSRef<EventTarget> = EventTargetCast::from_ref(top_most_node.r());
-                event.fire(target);
-            }
+            let x = point.x.to_i32().unwrap_or(0);
+            let y = point.y.to_i32().unwrap_or(0);
+
+            let window = self.window.root();
+            let mouse_event = MouseEvent::new(window.r(),
+                                              "mousemove".to_owned(),
+                                              true,
+                                              true,
+                                              Some(window.r()),
+                                              0i32,
+                                              x, y, x, y,
+                                              false, false, false, false,
+                                              0i16,
+                                              None).root();
+
+            let event: JSRef<Event> = EventCast::from_ref(mouse_event.r());
+            let target: JSRef<EventTarget> = EventTargetCast::from_ref(top_most_node.r());
+            event.fire(target);
         }
 
         // Store the current mouse over targets for next frame
@@ -637,7 +664,7 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
             _ => ()
         }
 
-        window.r().flush_layout(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery);
+        window.r().reflow(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery);
     }
 
     fn set_current_script(self, script: Option<JSRef<HTMLScriptElement>>) {
@@ -1259,7 +1286,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
     fn Location(self) -> Temporary<Location> {
         let window = self.window.root();
         let window = window.r();
-        self.location.or_init(|| Location::new(window, window.page_clone()))
+        self.location.or_init(|| Location::new(window))
     }
 
     // http://dom.spec.whatwg.org/#dom-parentnode-children
@@ -1298,10 +1325,8 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
             return Err(Security);
         }
         let window = self.window.root();
-        let window = window.r();
-        let page = window.page();
         let (tx, rx) = channel();
-        let _ = page.resource_task.send(GetCookiesForUrl(url, tx, NonHTTP));
+        let _ = window.r().resource_task().send(GetCookiesForUrl(url, tx, NonHTTP));
         let cookies = rx.recv().unwrap();
         Ok(cookies.unwrap_or("".to_owned()))
     }
@@ -1314,9 +1339,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
             return Err(Security);
         }
         let window = self.window.root();
-        let window = window.r();
-        let page = window.page();
-        let _ = page.resource_task.send(SetCookiesForUrl(url, cookie, NonHTTP));
+        let _ = window.r().resource_task().send(SetCookiesForUrl(url, cookie, NonHTTP));
         Ok(())
     }
 
diff --git a/components/script/dom/domparser.rs b/components/script/dom/domparser.rs
index 91d5d96a615..88429277f19 100644
--- a/components/script/dom/domparser.rs
+++ b/components/script/dom/domparser.rs
@@ -12,7 +12,7 @@ use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::document::{Document, DocumentHelpers, IsHTMLDocument};
 use dom::document::DocumentSource;
-use dom::window::Window;
+use dom::window::{Window, WindowHelpers};
 use parse::html::{HTMLInput, parse_html};
 use util::str::DOMString;
 
diff --git a/components/script/dom/htmlbodyelement.rs b/components/script/dom/htmlbodyelement.rs
index e609169ff05..eaf683ce3bd 100644
--- a/components/script/dom/htmlbodyelement.rs
+++ b/components/script/dom/htmlbodyelement.rs
@@ -16,6 +16,7 @@ use dom::eventtarget::{EventTarget, EventTargetTypeId, EventTargetHelpers};
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId, window_from_node};
 use dom::virtualmethods::VirtualMethods;
+use dom::window::WindowHelpers;
 
 use cssparser::RGBA;
 use util::str::{self, DOMString};
diff --git a/components/script/dom/htmlelement.rs b/components/script/dom/htmlelement.rs
index dd5cd1cb7e0..f3528185211 100644
--- a/components/script/dom/htmlelement.rs
+++ b/components/script/dom/htmlelement.rs
@@ -26,6 +26,7 @@ use dom::htmlmediaelement::HTMLMediaElementTypeId;
 use dom::htmltablecellelement::HTMLTableCellElementTypeId;
 use dom::node::{Node, NodeTypeId, window_from_node};
 use dom::virtualmethods::VirtualMethods;
+use dom::window::WindowHelpers;
 
 use util::str::DOMString;
 
diff --git a/components/script/dom/htmlformelement.rs b/components/script/dom/htmlformelement.rs
index ddc8d42b661..9c2148334e2 100644
--- a/components/script/dom/htmlformelement.rs
+++ b/components/script/dom/htmlformelement.rs
@@ -215,7 +215,7 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
         }
 
         // This is wrong. https://html.spec.whatwg.org/multipage/forms.html#planned-navigation
-        win.r().script_chan().send(ScriptMsg::TriggerLoad(win.r().page().id, load_data)).unwrap();
+        win.r().script_chan().send(ScriptMsg::TriggerLoad(win.r().pipeline(), load_data)).unwrap();
     }
 
     fn get_form_dataset<'b>(self, submitter: Option<FormSubmitter<'b>>) -> Vec<FormDatum> {
diff --git a/components/script/dom/htmliframeelement.rs b/components/script/dom/htmliframeelement.rs
index b4f9b577b7b..35cc68c3da5 100644
--- a/components/script/dom/htmliframeelement.rs
+++ b/components/script/dom/htmliframeelement.rs
@@ -20,8 +20,8 @@ use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
 use dom::urlhelper::UrlHelper;
 use dom::virtualmethods::VirtualMethods;
-use dom::window::Window;
-use page::{IterablePage, Page};
+use dom::window::{Window, WindowHelpers};
+use page::IterablePage;
 
 use msg::constellation_msg::{PipelineId, SubpageId, ConstellationChan};
 use msg::constellation_msg::IFrameSandboxState::{IFrameSandboxed, IFrameUnsandboxed};
@@ -62,7 +62,7 @@ pub trait HTMLIFrameElementHelpers {
     fn get_url(self) -> Option<Url>;
     /// http://www.whatwg.org/html/#process-the-iframe-attributes
     fn process_the_iframe_attributes(self);
-    fn generate_new_subpage_id(self, page: &Page) -> (SubpageId, Option<SubpageId>);
+    fn generate_new_subpage_id(self) -> (SubpageId, Option<SubpageId>);
 }
 
 impl<'a> HTMLIFrameElementHelpers for JSRef<'a, HTMLIFrameElement> {
@@ -78,15 +78,16 @@ impl<'a> HTMLIFrameElementHelpers for JSRef<'a, HTMLIFrameElement> {
                 None
             } else {
                 let window = window_from_node(self).root();
-                UrlParser::new().base_url(&window.r().page().get_url())
+                UrlParser::new().base_url(&window.r().get_url())
                     .parse(url.as_slice()).ok()
             }
         })
     }
 
-    fn generate_new_subpage_id(self, page: &Page) -> (SubpageId, Option<SubpageId>) {
+    fn generate_new_subpage_id(self) -> (SubpageId, Option<SubpageId>) {
         let old_subpage_id = self.subpage_id.get();
-        let subpage_id = page.get_next_subpage_id();
+        let win = window_from_node(self).root();
+        let subpage_id = win.r().get_next_subpage_id();
         self.subpage_id.set(Some(subpage_id));
         (subpage_id, old_subpage_id)
     }
@@ -105,14 +106,13 @@ impl<'a> HTMLIFrameElementHelpers for JSRef<'a, HTMLIFrameElement> {
 
         let window = window_from_node(self).root();
         let window = window.r();
-        let page = window.page();
-        let (new_subpage_id, old_subpage_id) = self.generate_new_subpage_id(page);
+        let (new_subpage_id, old_subpage_id) = self.generate_new_subpage_id();
 
-        self.containing_page_pipeline_id.set(Some(page.id));
+        self.containing_page_pipeline_id.set(Some(window.pipeline()));
 
-        let ConstellationChan(ref chan) = page.constellation_chan;
+        let ConstellationChan(ref chan) = window.constellation_chan();
     chan.send(ConstellationMsg::ScriptLoadedURLInIFrame(url,
-                                                        page.id,
+                                                        window.pipeline(),
                                                         new_subpage_id,
                                                         old_subpage_id,
                                                         sandboxed)).unwrap();
@@ -172,14 +172,10 @@ impl<'a> HTMLIFrameElementMethods for JSRef<'a, HTMLIFrameElement> {
             let window = window_from_node(self).root();
             let window = window.r();
             let children = window.page().children.borrow();
-            let child = children.iter().find(|child| {
-                child.subpage_id.unwrap() == subpage_id
-            });
-            child.and_then(|page| {
-                page.frame.borrow().as_ref().map(|frame| {
-                    Temporary::new(frame.window.clone())
-                })
-            })
+            children.iter().find(|page| {
+                let window = page.window().root();
+                window.r().subpage() == Some(subpage_id)
+            }).map(|page| page.window())
         })
     }
 
@@ -189,7 +185,7 @@ impl<'a> HTMLIFrameElementMethods for JSRef<'a, HTMLIFrameElement> {
                 Some(self_url) => self_url,
                 None => return None,
             };
-            let win_url = window_from_node(self).root().r().page().get_url();
+            let win_url = window_from_node(self).root().r().get_url();
 
             if UrlHelper::SameOrigin(&self_url, &win_url) {
                 Some(window.r().Document())
diff --git a/components/script/dom/htmlimageelement.rs b/components/script/dom/htmlimageelement.rs
index 2f8d09bb759..6b2f0b3dc2f 100644
--- a/components/script/dom/htmlimageelement.rs
+++ b/components/script/dom/htmlimageelement.rs
@@ -17,6 +17,7 @@ use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeTypeId, NodeHelpers, NodeDamage, window_from_node};
 use dom::virtualmethods::VirtualMethods;
+use dom::window::WindowHelpers;
 use net::image_cache_task;
 use util::geometry::to_px;
 use util::str::DOMString;
diff --git a/components/script/dom/htmllinkelement.rs b/components/script/dom/htmllinkelement.rs
index 4f8f2aa14b8..ab0c45a22d5 100644
--- a/components/script/dom/htmllinkelement.rs
+++ b/components/script/dom/htmllinkelement.rs
@@ -17,6 +17,7 @@ use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
 use dom::virtualmethods::VirtualMethods;
+use dom::window::WindowHelpers;
 use layout_interface::{LayoutChan, Msg};
 use util::str::{DOMString, HTML_SPACE_CHARACTERS};
 
@@ -130,9 +131,9 @@ impl<'a> PrivateHTMLLinkElementHelpers for JSRef<'a, HTMLLinkElement> {
     fn handle_stylesheet_url(self, href: &str) {
         let window = window_from_node(self).root();
         let window = window.r();
-        match UrlParser::new().base_url(&window.page().get_url()).parse(href) {
+        match UrlParser::new().base_url(&window.get_url()).parse(href) {
             Ok(url) => {
-                let LayoutChan(ref layout_chan) = window.page().layout_chan;
+                let LayoutChan(ref layout_chan) = window.layout_chan();
                 layout_chan.send(Msg::LoadStylesheet(url)).unwrap();
             }
             Err(e) => debug!("Parsing url {} failed: {}", href, e)
diff --git a/components/script/dom/htmlscriptelement.rs b/components/script/dom/htmlscriptelement.rs
index 853d6709fcb..e9809a6e2cb 100644
--- a/components/script/dom/htmlscriptelement.rs
+++ b/components/script/dom/htmlscriptelement.rs
@@ -25,7 +25,7 @@ use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeHelpers, NodeTypeId, document_from_node, window_from_node, CloneChildrenFlag};
 use dom::virtualmethods::VirtualMethods;
-use dom::window::ScriptHelpers;
+use dom::window::{WindowHelpers, ScriptHelpers};
 use script_task::{ScriptMsg, Runnable};
 
 use encoding::all::UTF_8;
@@ -214,8 +214,7 @@ impl<'a> HTMLScriptElementHelpers for JSRef<'a, HTMLScriptElement> {
         // Step 14.
         let window = window_from_node(self).root();
         let window = window.r();
-        let page = window.page();
-        let base_url = page.get_url();
+        let base_url = window.get_url();
 
         let load = match element.get_attribute(ns!(""), &atom!("src")).root() {
             // Step 14.
@@ -243,7 +242,7 @@ impl<'a> HTMLScriptElementHelpers for JSRef<'a, HTMLScriptElement> {
                         // state of the element's `crossorigin` content attribute, the origin being
                         // the origin of the script element's node document, and the default origin
                         // behaviour set to taint.
-                        ScriptOrigin::External(load_whole_resource(&page.resource_task, url))
+                        ScriptOrigin::External(load_whole_resource(&window.resource_task(), url))
                     }
                 }
             },
diff --git a/components/script/dom/htmlstyleelement.rs b/components/script/dom/htmlstyleelement.rs
index 6fc3e1a2039..945831a35b1 100644
--- a/components/script/dom/htmlstyleelement.rs
+++ b/components/script/dom/htmlstyleelement.rs
@@ -12,6 +12,7 @@ use dom::element::ElementTypeId;
 use dom::htmlelement::{HTMLElement, HTMLElementTypeId};
 use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
 use dom::virtualmethods::VirtualMethods;
+use dom::window::WindowHelpers;
 use layout_interface::{LayoutChan, Msg};
 use util::str::DOMString;
 use style::stylesheets::{Origin, Stylesheet};
@@ -52,11 +53,11 @@ impl<'a> StyleElementHelpers for JSRef<'a, HTMLStyleElement> {
 
         let win = window_from_node(node).root();
         let win = win.r();
-        let url = win.page().get_url();
+        let url = win.get_url();
 
         let data = node.GetTextContent().expect("Element.textContent must be a string");
         let sheet = Stylesheet::from_str(data.as_slice(), url, Origin::Author);
-        let LayoutChan(ref layout_chan) = win.page().layout_chan;
+        let LayoutChan(ref layout_chan) = win.layout_chan();
         layout_chan.send(Msg::AddStylesheet(sheet)).unwrap();
     }
 }
diff --git a/components/script/dom/location.rs b/components/script/dom/location.rs
index 614b623e5b9..13cc1a05c65 100644
--- a/components/script/dom/location.rs
+++ b/components/script/dom/location.rs
@@ -5,33 +5,31 @@
 use dom::bindings::codegen::Bindings::LocationBinding;
 use dom::bindings::codegen::Bindings::LocationBinding::LocationMethods;
 use dom::bindings::global::GlobalRef;
-use dom::bindings::js::{JSRef, Temporary};
+use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::urlhelper::UrlHelper;
 use dom::window::Window;
 use dom::window::WindowHelpers;
-use page::Page;
 
 use util::str::DOMString;
-
-use std::rc::Rc;
+use url::Url;
 
 #[dom_struct]
 pub struct Location {
     reflector_: Reflector,
-    page: Rc<Page>,
+    window: JS<Window>,
 }
 
 impl Location {
-    fn new_inherited(page: Rc<Page>) -> Location {
+    fn new_inherited(window: JSRef<Window>) -> Location {
         Location {
             reflector_: Reflector::new(),
-            page: page
+            window: JS::from_rooted(window)
         }
     }
 
-    pub fn new(window: JSRef<Window>, page: Rc<Page>) -> Temporary<Location> {
-        reflect_dom_object(box Location::new_inherited(page),
+    pub fn new(window: JSRef<Window>) -> Temporary<Location> {
+        reflect_dom_object(box Location::new_inherited(window),
                            GlobalRef::Window(window),
                            LocationBinding::Wrap)
     }
@@ -40,11 +38,11 @@ impl Location {
 impl<'a> LocationMethods for JSRef<'a, Location> {
     // https://html.spec.whatwg.org/multipage/browsers.html#dom-location-assign
     fn Assign(self, url: DOMString) {
-        self.page.frame().as_ref().unwrap().window.root().r().load_url(url);
+        self.window.root().r().load_url(url);
     }
 
     fn Href(self) -> DOMString {
-        UrlHelper::Href(&self.page.get_url())
+        UrlHelper::Href(&self.get_url())
     }
 
     fn Stringify(self) -> DOMString {
@@ -52,11 +50,21 @@ impl<'a> LocationMethods for JSRef<'a, Location> {
     }
 
     fn Search(self) -> DOMString {
-        UrlHelper::Search(&self.page.get_url())
+        UrlHelper::Search(&self.get_url())
     }
 
     fn Hash(self) -> DOMString {
-        UrlHelper::Hash(&self.page.get_url())
+        UrlHelper::Hash(&self.get_url())
     }
 }
 
+trait PrivateLocationHelpers {
+    fn get_url(self) -> Url;
+}
+
+impl<'a> PrivateLocationHelpers for JSRef<'a, Location> {
+    fn get_url(self) -> Url {
+        let window = self.window.root();
+        window.r().get_url()
+    }
+}
diff --git a/components/script/dom/macros.rs b/components/script/dom/macros.rs
index d00aa9961b1..b1cba9ccd3e 100644
--- a/components/script/dom/macros.rs
+++ b/components/script/dom/macros.rs
@@ -80,6 +80,7 @@ macro_rules! make_url_or_base_getter(
         fn $attr(self) -> DOMString {
             use dom::element::{Element, AttributeHandlers};
             use dom::bindings::codegen::InheritTypes::ElementCast;
+            use dom::window::WindowHelpers;
             #[allow(unused_imports)]
             use std::ascii::AsciiExt;
             let element: JSRef<Element> = ElementCast::from_ref(self);
diff --git a/components/script/dom/node.rs b/components/script/dom/node.rs
index a7b5e5484d6..b6f4e86307b 100644
--- a/components/script/dom/node.rs
+++ b/components/script/dom/node.rs
@@ -41,7 +41,7 @@ use dom::nodelist::NodeList;
 use dom::processinginstruction::ProcessingInstruction;
 use dom::text::Text;
 use dom::virtualmethods::{VirtualMethods, vtable_for};
-use dom::window::Window;
+use dom::window::{Window, WindowHelpers};
 use geom::rect::Rect;
 use layout_interface::{LayoutChan, Msg};
 use devtools_traits::NodeInfo;
@@ -409,7 +409,7 @@ pub trait NodeHelpers<'a> {
     fn child_elements(self) -> ChildElementIterator<'a>;
     fn following_siblings(self) -> NodeChildrenIterator<'a>;
     fn is_in_doc(self) -> bool;
-    fn is_inclusive_ancestor_of(self, parent: JSRef<'a, Node>) -> bool;    // FIXME: See #3960
+    fn is_inclusive_ancestor_of(self, parent: JSRef<Node>) -> bool;
     fn is_parent_of(self, child: JSRef<Node>) -> bool;
 
     fn type_id(self) -> NodeTypeId;
@@ -490,9 +490,18 @@ pub trait NodeHelpers<'a> {
 
     fn get_unique_id(self) -> String;
     fn summarize(self) -> NodeInfo;
+
+    fn teardown(self);
 }
 
 impl<'a> NodeHelpers<'a> for JSRef<'a, Node> {
+    fn teardown(self) {
+        self.layout_data.dispose();
+        for kid in self.children() {
+            kid.teardown();
+        }
+    }
+
     /// Dumps the subtree rooted at this node, for debugging.
     fn dump(self) {
         self.dump_indent(0);
@@ -715,7 +724,7 @@ impl<'a> NodeHelpers<'a> for JSRef<'a, Node> {
         }
     }
 
-    fn is_inclusive_ancestor_of(self, parent: JSRef<'a, Node>) -> bool {
+    fn is_inclusive_ancestor_of(self, parent: JSRef<Node>) -> bool {
         self == parent || parent.ancestors().any(|ancestor| ancestor == self)
     }
 
@@ -737,11 +746,11 @@ impl<'a> NodeHelpers<'a> for JSRef<'a, Node> {
     }
 
     fn get_bounding_content_box(self) -> Rect<Au> {
-        window_from_node(self).root().r().page().content_box_query(self.to_trusted_node_address())
+        window_from_node(self).root().r().content_box_query(self.to_trusted_node_address())
     }
 
     fn get_content_boxes(self) -> Vec<Rect<Au>> {
-        window_from_node(self).root().r().page().content_boxes_query(self.to_trusted_node_address())
+        window_from_node(self).root().r().content_boxes_query(self.to_trusted_node_address())
     }
 
     // http://dom.spec.whatwg.org/#dom-parentnode-queryselector
@@ -1376,7 +1385,7 @@ impl Node {
 
         // Step 7-8.
         let reference_child = match child {
-            Some(child) if child.clone() == node => node.next_sibling().map(|node| node.root().get_unsound_ref_forever()),
+            Some(child) if child == node => node.next_sibling().map(|node| node.root().get_unsound_ref_forever()),
             _ => child
         };
 
@@ -1946,7 +1955,7 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
         }
 
         // Ok if not caught by previous error checks.
-        if node.clone() == child {
+        if node == child {
             return Ok(Temporary::from_rooted(child));
         }
 
@@ -2106,7 +2115,7 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
 
     // http://dom.spec.whatwg.org/#dom-node-comparedocumentposition
     fn CompareDocumentPosition(self, other: JSRef<Node>) -> u16 {
-        if self.clone() == other {    // FIXME: See issue #3960
+        if self == other {
             // step 2.
             0
         } else {
diff --git a/components/script/dom/webidls/CSSStyleDeclaration.webidl b/components/script/dom/webidls/CSSStyleDeclaration.webidl
index 1d642acf17c..46ca8424b70 100644
--- a/components/script/dom/webidls/CSSStyleDeclaration.webidl
+++ b/components/script/dom/webidls/CSSStyleDeclaration.webidl
@@ -38,6 +38,7 @@ partial interface CSSStyleDeclaration {
   [TreatNullAs=EmptyString] attribute DOMString backgroundRepeat;
   [TreatNullAs=EmptyString] attribute DOMString backgroundImage;
   [TreatNullAs=EmptyString] attribute DOMString backgroundAttachment;
+  [TreatNullAs=EmptyString] attribute DOMString backgroundSize;
 
   [TreatNullAs=EmptyString] attribute DOMString border;
   [TreatNullAs=EmptyString] attribute DOMString borderColor;
@@ -103,6 +104,8 @@ partial interface CSSStyleDeclaration {
   [TreatNullAs=EmptyString] attribute DOMString listStyleImage;
 
   [TreatNullAs=EmptyString] attribute DOMString overflow;
+  [TreatNullAs=EmptyString] attribute DOMString overflowX;
+  [TreatNullAs=EmptyString] attribute DOMString overflowY;
   [TreatNullAs=EmptyString] attribute DOMString overflowWrap;
 
   [TreatNullAs=EmptyString] attribute DOMString tableLayout;
@@ -171,4 +174,6 @@ partial interface CSSStyleDeclaration {
   [TreatNullAs=EmptyString] attribute DOMString maxWidth;
 
   [TreatNullAs=EmptyString] attribute DOMString zIndex;
+
+  [TreatNullAs=EmptyString] attribute DOMString imageRendering;
 };
diff --git a/components/script/dom/window.rs b/components/script/dom/window.rs
index 27b297e21f2..29551114315 100644
--- a/components/script/dom/window.rs
+++ b/components/script/dom/window.rs
@@ -8,50 +8,59 @@ use dom::bindings::codegen::Bindings::FunctionBinding::Function;
 use dom::bindings::codegen::Bindings::WindowBinding;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
-use dom::bindings::codegen::InheritTypes::EventTargetCast;
+use dom::bindings::codegen::InheritTypes::{NodeCast, EventTargetCast};
 use dom::bindings::global::global_object_for_js_object;
 use dom::bindings::error::{report_pending_exception, Fallible};
 use dom::bindings::error::Error::InvalidCharacter;
 use dom::bindings::global::GlobalRef;
-use dom::bindings::js::{MutNullableJS, JSRef, Temporary};
-use dom::bindings::utils::Reflectable;
+use dom::bindings::js::{MutNullableJS, JSRef, Temporary, OptionalRootable, RootedReference};
+use dom::bindings::utils::{GlobalStaticData, Reflectable, WindowProxyHandler};
 use dom::browsercontext::BrowserContext;
 use dom::console::Console;
-use dom::document::Document;
+use dom::document::{Document, DocumentHelpers};
 use dom::element::Element;
 use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
 use dom::location::Location;
 use dom::navigator::Navigator;
-use dom::node::window_from_node;
+use dom::node::{window_from_node, Node, TrustedNodeAddress, NodeHelpers};
 use dom::performance::Performance;
 use dom::screen::Screen;
 use dom::storage::Storage;
-use layout_interface::{ReflowGoal, ReflowQueryType};
+use layout_interface::{ReflowGoal, ReflowQueryType, LayoutRPC, LayoutChan, Reflow, Msg};
+use layout_interface::{ContentBoxResponse, ContentBoxesResponse};
 use page::Page;
 use script_task::{TimerSource, ScriptChan};
 use script_task::ScriptMsg;
 use script_traits::ScriptControlChan;
 use timers::{IsInterval, TimerId, TimerManager, TimerCallback};
 
+use devtools_traits::DevtoolsControlChan;
 use msg::compositor_msg::ScriptListener;
-use msg::constellation_msg::LoadData;
+use msg::constellation_msg::{LoadData, PipelineId, SubpageId, ConstellationChan, WindowSizeData};
 use net::image_cache_task::ImageCacheTask;
+use net::resource_task::ResourceTask;
 use net::storage_task::StorageTask;
+use util::geometry::{self, Au, MAX_RECT};
 use util::str::{DOMString,HTML_SPACE_CHARACTERS};
 
+use geom::{Point2D, Rect, Size2D};
 use js::jsapi::JS_EvaluateUCScript;
 use js::jsapi::JSContext;
 use js::jsapi::{JS_GC, JS_GetRuntime};
 use js::jsval::{JSVal, UndefinedValue};
-use js::rust::with_compartment;
+use js::rust::{Cx, with_compartment};
 use url::{Url, UrlParser};
 
 use libc;
 use rustc_serialize::base64::{FromBase64, ToBase64, STANDARD};
-use std::cell::{Ref, RefMut};
+use std::cell::{Cell, Ref, RefMut};
 use std::default::Default;
 use std::ffi::CString;
+use std::mem;
+use std::num::Float;
 use std::rc::Rc;
+use std::sync::mpsc::{channel, Receiver};
+use std::sync::mpsc::TryRecvError::{Empty, Disconnected};
 use time;
 
 #[dom_struct]
@@ -71,18 +80,80 @@ pub struct Window {
     screen: MutNullableJS<Screen>,
     session_storage: MutNullableJS<Storage>,
     timers: TimerManager,
+
+    /// For providing instructions to an optional devtools server.
+    devtools_chan: Option<DevtoolsControlChan>,
+
+    /// A flag to indicate whether the developer tools have requested live updates of
+    /// page changes.
+    devtools_wants_updates: Cell<bool>,
+
+    next_subpage_id: Cell<SubpageId>,
+
+    /// Pending resize event, if any.
+    resize_event: Cell<Option<WindowSizeData>>,
+
+    /// Pipeline id associated with this page.
+    id: PipelineId,
+
+    /// Subpage id associated with this page, if any.
+    subpage_id: Option<SubpageId>,
+
+    /// Unique id for last reflow request; used for confirming completion reply.
+    last_reflow_id: Cell<uint>,
+
+    /// Global static data related to the DOM.
+    dom_static: GlobalStaticData,
+
+    /// The JavaScript context.
+    js_context: DOMRefCell<Option<Rc<Cx>>>,
+
+    /// A handle for communicating messages to the layout task.
+    layout_chan: LayoutChan,
+
+    /// A handle to perform RPC calls into the layout, quickly.
+    layout_rpc: Box<LayoutRPC+'static>,
+
+    /// The port that we will use to join layout. If this is `None`, then layout is not running.
+    layout_join_port: DOMRefCell<Option<Receiver<()>>>,
+
+    /// The current size of the window, in pixels.
+    window_size: Cell<WindowSizeData>,
+
+    /// Associated resource task for use by DOM objects like XMLHttpRequest
+    resource_task: ResourceTask,
+
+    /// A handle for communicating messages to the storage task.
+    storage_task: StorageTask,
+
+    /// A handle for communicating messages to the constellation task.
+    constellation_chan: ConstellationChan,
+
+    /// Pending scroll to fragment event, if any
+    fragment_name: DOMRefCell<Option<String>>,
+
+    /// An enlarged rectangle around the page contents visible in the viewport, used
+    /// to prevent creating display list items for content that is far away from the viewport.
+    page_clip_rect: Cell<Rect<Au>>,
 }
 
 impl Window {
     pub fn get_cx(&self) -> *mut JSContext {
-        let js_info = self.page().js_info();
-        (*js_info.as_ref().unwrap().js_context).ptr
+        self.js_context.borrow().as_ref().unwrap().ptr
     }
 
     pub fn script_chan(&self) -> Box<ScriptChan+Send> {
         self.script_chan.clone()
     }
 
+    pub fn pipeline(&self) -> PipelineId {
+        self.id.clone()
+    }
+
+    pub fn subpage(&self) -> Option<SubpageId> {
+        self.subpage_id.clone()
+    }
+
     pub fn control_chan<'a>(&'a self) -> &'a ScriptControlChan {
         &self.control_chan
     }
@@ -103,16 +174,8 @@ impl Window {
         &*self.page
     }
 
-    pub fn page_clone(&self) -> Rc<Page> {
-        self.page.clone()
-    }
-
-    pub fn get_url(&self) -> Url {
-        self.page().get_url()
-    }
-
     pub fn storage_task(&self) -> StorageTask {
-        self.page().storage_task.clone()
+        self.storage_task.clone()
     }
 }
 
@@ -197,12 +260,11 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
     }
 
     fn Close(self) {
-        self.script_chan.send(ScriptMsg::ExitWindow(self.page.id.clone())).unwrap();
+        self.script_chan.send(ScriptMsg::ExitWindow(self.id.clone())).unwrap();
     }
 
     fn Document(self) -> Temporary<Document> {
-        let frame = self.page().frame();
-        Temporary::new(frame.as_ref().unwrap().document.clone())
+        self.browser_context().as_ref().unwrap().active_document()
     }
 
     fn Location(self) -> Temporary<Location> {
@@ -230,7 +292,7 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
                                             args,
                                             timeout,
                                             IsInterval::NonInterval,
-                                            TimerSource::FromWindow(self.page.id.clone()),
+                                            TimerSource::FromWindow(self.id.clone()),
                                             self.script_chan.clone())
     }
 
@@ -239,7 +301,7 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
                                             args,
                                             timeout,
                                             IsInterval::NonInterval,
-                                            TimerSource::FromWindow(self.page.id.clone()),
+                                            TimerSource::FromWindow(self.id.clone()),
                                             self.script_chan.clone())
     }
 
@@ -252,7 +314,7 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
                                             args,
                                             timeout,
                                             IsInterval::Interval,
-                                            TimerSource::FromWindow(self.page.id.clone()),
+                                            TimerSource::FromWindow(self.id.clone()),
                                             self.script_chan.clone())
     }
 
@@ -261,7 +323,7 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
                                             args,
                                             timeout,
                                             IsInterval::Interval,
-                                            TimerSource::FromWindow(self.page.id.clone()),
+                                            TimerSource::FromWindow(self.id.clone()),
                                             self.script_chan.clone())
     }
 
@@ -330,10 +392,34 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
 }
 
 pub trait WindowHelpers {
-    fn flush_layout(self, goal: ReflowGoal, query: ReflowQueryType);
+    fn clear_js_context(self);
+    fn clear_js_context_for_script_deallocation(self);
     fn init_browser_context(self, doc: JSRef<Document>, frame_element: Option<JSRef<Element>>);
     fn load_url(self, href: DOMString);
     fn handle_fire_timer(self, timer_id: TimerId);
+    fn reflow(self, goal: ReflowGoal, query_type: ReflowQueryType);
+    fn join_layout(self);
+    fn layout(&self) -> &LayoutRPC;
+    fn content_box_query(self, content_box_request: TrustedNodeAddress) -> Rect<Au>;
+    fn content_boxes_query(self, content_boxes_request: TrustedNodeAddress) -> Vec<Rect<Au>>;
+    fn handle_reflow_complete_msg(self, reflow_id: uint);
+    fn handle_resize_inactive_msg(self, new_size: WindowSizeData);
+    fn set_fragment_name(self, fragment: Option<String>);
+    fn steal_fragment_name(self) -> Option<String>;
+    fn set_window_size(self, size: WindowSizeData);
+    fn window_size(self) -> WindowSizeData;
+    fn get_url(self) -> Url;
+    fn resource_task(self) -> ResourceTask;
+    fn devtools_chan(self) -> Option<DevtoolsControlChan>;
+    fn layout_chan(self) -> LayoutChan;
+    fn constellation_chan(self) -> ConstellationChan;
+    fn windowproxy_handler(self) -> WindowProxyHandler;
+    fn get_next_subpage_id(self) -> SubpageId;
+    fn layout_is_idle(self) -> bool;
+    fn set_resize_event(self, event: WindowSizeData);
+    fn steal_resize_event(self) -> Option<WindowSizeData>;
+    fn set_page_clip_rect_with_new_viewport(self, viewport: Rect<f32>) -> bool;
+    fn set_devtools_wants_updates(self, value: bool);
     fn IndexedGetter(self, _index: u32, _found: &mut bool) -> Option<Temporary<Window>>;
     fn thaw(self);
     fn freeze(self);
@@ -373,8 +459,131 @@ impl<'a, T: Reflectable> ScriptHelpers for JSRef<'a, T> {
 }
 
 impl<'a> WindowHelpers for JSRef<'a, Window> {
-    fn flush_layout(self, goal: ReflowGoal, query: ReflowQueryType) {
-        self.page().flush_layout(goal, query);
+    fn clear_js_context(self) {
+        let document = self.Document().root();
+        NodeCast::from_ref(document.r()).teardown();
+
+        *self.js_context.borrow_mut() = None;
+        *self.browser_context.borrow_mut() = None;
+    }
+
+    #[allow(unsafe_blocks)]
+    fn clear_js_context_for_script_deallocation(self) {
+        unsafe {
+            *self.js_context.borrow_for_script_deallocation() = None;
+            *self.browser_context.borrow_for_script_deallocation() = None;
+        }
+    }
+
+    /// Reflows the page if it's possible to do so and the page is dirty. This method will wait
+    /// for the layout thread to complete (but see the `TODO` below). If there is no window size
+    /// yet, the page is presumed invisible and no reflow is performed.
+    ///
+    /// TODO(pcwalton): Only wait for style recalc, since we have off-main-thread layout.
+    fn reflow(self, goal: ReflowGoal, query_type: ReflowQueryType) {
+        let document = self.Document().root();
+        let root = document.r().GetDocumentElement().root();
+        let root = match root.r() {
+            Some(root) => root,
+            None => return,
+        };
+
+        debug!("script: performing reflow for goal {:?}", goal);
+
+        let root: JSRef<Node> = NodeCast::from_ref(root);
+        if !root.get_has_dirty_descendants() {
+            debug!("root has no dirty descendants; avoiding reflow");
+            return
+        }
+
+        debug!("script: performing reflow for goal {:?}", goal);
+
+        // Layout will let us know when it's done.
+        let (join_chan, join_port) = channel();
+
+        {
+            let mut layout_join_port = self.layout_join_port.borrow_mut();
+            *layout_join_port = Some(join_port);
+        }
+
+        let last_reflow_id = &self.last_reflow_id;
+        last_reflow_id.set(last_reflow_id.get() + 1);
+
+        let window_size = self.window_size.get();
+
+        // Send new document and relevant styles to layout.
+        let reflow = box Reflow {
+            document_root: root.to_trusted_node_address(),
+            url: self.get_url(),
+            iframe: self.subpage_id.is_some(),
+            goal: goal,
+            window_size: window_size,
+            script_chan: self.control_chan.clone(),
+            script_join_chan: join_chan,
+            id: last_reflow_id.get(),
+            query_type: query_type,
+            page_clip_rect: self.page_clip_rect.get(),
+        };
+
+        let LayoutChan(ref chan) = self.layout_chan;
+        chan.send(Msg::Reflow(reflow)).unwrap();
+
+        debug!("script: layout forked");
+
+        self.join_layout();
+    }
+
+    // FIXME(cgaebel): join_layout is racey. What if the compositor triggers a
+    // reflow between the "join complete" message and returning from this
+    // function?
+
+    /// Sends a ping to layout and waits for the response. The response will arrive when the
+    /// layout task has finished any pending request messages.
+    fn join_layout(self) {
+        let mut layout_join_port = self.layout_join_port.borrow_mut();
+        if let Some(join_port) = mem::replace(&mut *layout_join_port, None) {
+            match join_port.try_recv() {
+                Err(Empty) => {
+                    info!("script: waiting on layout");
+                    join_port.recv().unwrap();
+                }
+                Ok(_) => {}
+                Err(Disconnected) => {
+                    panic!("Layout task failed while script was waiting for a result.");
+                }
+            }
+
+            debug!("script: layout joined")
+        }
+    }
+
+    fn layout(&self) -> &LayoutRPC {
+        &*self.layout_rpc
+    }
+
+    fn content_box_query(self, content_box_request: TrustedNodeAddress) -> Rect<Au> {
+        self.reflow(ReflowGoal::ForScriptQuery, ReflowQueryType::ContentBoxQuery(content_box_request));
+        self.join_layout(); //FIXME: is this necessary, or is layout_rpc's mutex good enough?
+        let ContentBoxResponse(rect) = self.layout_rpc.content_box();
+        rect
+    }
+
+    fn content_boxes_query(self, content_boxes_request: TrustedNodeAddress) -> Vec<Rect<Au>> {
+        self.reflow(ReflowGoal::ForScriptQuery, ReflowQueryType::ContentBoxesQuery(content_boxes_request));
+        self.join_layout(); //FIXME: is this necessary, or is layout_rpc's mutex good enough?
+        let ContentBoxesResponse(rects) = self.layout_rpc.content_boxes();
+        rects
+    }
+
+    fn handle_reflow_complete_msg(self, reflow_id: uint) {
+        let last_reflow_id = self.last_reflow_id.get();
+        if last_reflow_id == reflow_id {
+            *self.layout_join_port.borrow_mut() = None;
+        }
+    }
+
+    fn handle_resize_inactive_msg(self, new_size: WindowSizeData) {
+        self.window_size.set(new_size);
     }
 
     fn init_browser_context(self, doc: JSRef<Document>, frame_element: Option<JSRef<Element>>) {
@@ -383,26 +592,117 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
 
     /// Commence a new URL load which will either replace this window or scroll to a fragment.
     fn load_url(self, href: DOMString) {
-        let base_url = self.page().get_url();
+        let base_url = self.get_url();
         debug!("current page url is {}", base_url);
         let url = UrlParser::new().base_url(&base_url).parse(href.as_slice());
         // FIXME: handle URL parse errors more gracefully.
         let url = url.unwrap();
         match url.fragment {
             Some(fragment) => {
-                self.script_chan.send(ScriptMsg::TriggerFragment(self.page.id, fragment)).unwrap();
+                self.script_chan.send(ScriptMsg::TriggerFragment(self.id, fragment)).unwrap();
             },
             None => {
-                self.script_chan.send(ScriptMsg::TriggerLoad(self.page.id, LoadData::new(url))).unwrap();
+                self.script_chan.send(ScriptMsg::TriggerLoad(self.id, LoadData::new(url))).unwrap();
             }
         }
     }
 
     fn handle_fire_timer(self, timer_id: TimerId) {
         self.timers.fire_timer(timer_id, self);
-        self.flush_layout(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery);
+        self.reflow(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery);
+    }
+
+    fn set_fragment_name(self, fragment: Option<String>) {
+        *self.fragment_name.borrow_mut() = fragment;
+    }
+
+    fn steal_fragment_name(self) -> Option<String> {
+        self.fragment_name.borrow_mut().take()
+    }
+
+    fn set_window_size(self, size: WindowSizeData) {
+        self.window_size.set(size);
+    }
+
+    fn window_size(self) -> WindowSizeData {
+        self.window_size.get()
+    }
+
+    fn get_url(self) -> Url {
+        let doc = self.Document().root();
+        doc.r().url()
+    }
+
+    fn resource_task(self) -> ResourceTask {
+        self.resource_task.clone()
     }
 
+    fn devtools_chan(self) -> Option<DevtoolsControlChan> {
+        self.devtools_chan.clone()
+    }
+
+    fn layout_chan(self) -> LayoutChan {
+        self.layout_chan.clone()
+    }
+
+    fn constellation_chan(self) -> ConstellationChan {
+        self.constellation_chan.clone()
+    }
+
+    fn windowproxy_handler(self) -> WindowProxyHandler {
+        WindowProxyHandler(self.dom_static.windowproxy_handler.0)
+    }
+
+    fn get_next_subpage_id(self) -> SubpageId {
+        let subpage_id = self.next_subpage_id.get();
+        let SubpageId(id_num) = subpage_id;
+        self.next_subpage_id.set(SubpageId(id_num + 1));
+        subpage_id
+    }
+
+    fn layout_is_idle(self) -> bool {
+        self.layout_join_port.borrow().is_none()
+    }
+
+    fn set_resize_event(self, event: WindowSizeData) {
+        self.resize_event.set(Some(event));
+    }
+
+    fn steal_resize_event(self) -> Option<WindowSizeData> {
+        let event = self.resize_event.get();
+        self.resize_event.set(None);
+        event
+    }
+
+    fn set_page_clip_rect_with_new_viewport(self, viewport: Rect<f32>) -> bool {
+        // We use a clipping rectangle that is five times the size of the of the viewport,
+        // so that we don't collect display list items for areas too far outside the viewport,
+        // but also don't trigger reflows every time the viewport changes.
+        static VIEWPORT_EXPANSION: f32 = 2.0; // 2 lengths on each side plus original length is 5 total.
+       let proposed_clip_rect = geometry::f32_rect_to_au_rect(
+           viewport.inflate(viewport.size.width * VIEWPORT_EXPANSION,
+           viewport.size.height * VIEWPORT_EXPANSION));
+       let clip_rect = self.page_clip_rect.get();
+       if proposed_clip_rect == clip_rect {
+           return false;
+       }
+
+       let had_clip_rect = clip_rect != MAX_RECT;
+       if had_clip_rect && !should_move_clip_rect(clip_rect, viewport) {
+           return false;
+       }
+
+       self.page_clip_rect.set(proposed_clip_rect);
+
+       // If we didn't have a clip rect, the previous display doesn't need rebuilding
+       // because it was built for infinite clip (MAX_RECT).
+       had_clip_rect
+   }
+
+   fn set_devtools_wants_updates(self, value: bool) {
+       self.devtools_wants_updates.set(value);
+   }
+
     // https://html.spec.whatwg.org/multipage/browsers.html#accessing-other-browsing-contexts
     fn IndexedGetter(self, _index: u32, _found: &mut bool) -> Option<Temporary<Window>> {
         None
@@ -419,13 +719,28 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
 }
 
 impl Window {
-    pub fn new(cx: *mut JSContext,
+    pub fn new(js_context: Rc<Cx>,
                page: Rc<Page>,
                script_chan: Box<ScriptChan+Send>,
                control_chan: ScriptControlChan,
                compositor: Box<ScriptListener+'static>,
-               image_cache_task: ImageCacheTask)
+               image_cache_task: ImageCacheTask,
+               resource_task: ResourceTask,
+               storage_task: StorageTask,
+               devtools_chan: Option<DevtoolsControlChan>,
+               constellation_chan: ConstellationChan,
+               layout_chan: LayoutChan,
+               id: PipelineId,
+               subpage_id: Option<SubpageId>,
+               window_size: WindowSizeData)
                -> Temporary<Window> {
+        let layout_rpc: Box<LayoutRPC> = {
+            let (rpc_send, rpc_recv) = channel();
+            let LayoutChan(ref lchan) = layout_chan;
+            lchan.send(Msg::GetRPC(rpc_send)).unwrap();
+            rpc_recv.recv().unwrap()
+        };
+
         let win = box Window {
             eventtarget: EventTarget::new_inherited(EventTargetTypeId::Window),
             script_chan: script_chan,
@@ -435,6 +750,7 @@ impl Window {
             page: page,
             navigator: Default::default(),
             image_cache_task: image_cache_task,
+            devtools_chan: devtools_chan,
             browser_context: DOMRefCell::new(None),
             performance: Default::default(),
             navigation_start: time::get_time().sec as u64,
@@ -442,8 +758,43 @@ impl Window {
             screen: Default::default(),
             session_storage: Default::default(),
             timers: TimerManager::new(),
+            id: id,
+            subpage_id: subpage_id,
+            dom_static: GlobalStaticData::new(),
+            js_context: DOMRefCell::new(Some(js_context.clone())),
+            resource_task: resource_task,
+            storage_task: storage_task,
+            constellation_chan: constellation_chan,
+            page_clip_rect: Cell::new(MAX_RECT),
+            fragment_name: DOMRefCell::new(None),
+            last_reflow_id: Cell::new(0),
+            resize_event: Cell::new(None),
+            next_subpage_id: Cell::new(SubpageId(0)),
+            layout_chan: layout_chan,
+            layout_rpc: layout_rpc,
+            layout_join_port: DOMRefCell::new(None),
+            window_size: Cell::new(window_size),
+            devtools_wants_updates: Cell::new(false),
         };
 
-        WindowBinding::Wrap(cx, win)
+        WindowBinding::Wrap(js_context.ptr, win)
     }
 }
+
+fn should_move_clip_rect(clip_rect: Rect<Au>, new_viewport: Rect<f32>) -> bool{
+    let clip_rect = Rect(Point2D(geometry::to_frac_px(clip_rect.origin.x) as f32,
+                                 geometry::to_frac_px(clip_rect.origin.y) as f32),
+                         Size2D(geometry::to_frac_px(clip_rect.size.width) as f32,
+                                geometry::to_frac_px(clip_rect.size.height) as f32));
+
+    // We only need to move the clip rect if the viewport is getting near the edge of
+    // our preexisting clip rect. We use half of the size of the viewport as a heuristic
+    // for "close."
+    static VIEWPORT_SCROLL_MARGIN_SIZE: f32 = 0.5;
+    let viewport_scroll_margin = new_viewport.size * VIEWPORT_SCROLL_MARGIN_SIZE;
+
+    (clip_rect.origin.x - new_viewport.origin.x).abs() <= viewport_scroll_margin.width ||
+    (clip_rect.max_x() - new_viewport.max_x()).abs() <= viewport_scroll_margin.width ||
+    (clip_rect.origin.y - new_viewport.origin.y).abs() <= viewport_scroll_margin.height ||
+    (clip_rect.max_y() - new_viewport.max_y()).abs() <= viewport_scroll_margin.height
+}
diff --git a/components/script/page.rs b/components/script/page.rs
index c7ea2e44bec..ffaa25c9e14 100644
--- a/components/script/page.rs
+++ b/components/script/page.rs
@@ -3,107 +3,39 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::cell::DOMRefCell;
-use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
-use dom::bindings::codegen::InheritTypes::NodeCast;
-use dom::bindings::js::{JS, JSRef, Temporary, OptionalRootable};
-use dom::bindings::utils::GlobalStaticData;
+use dom::bindings::js::{JS, Temporary, Unrooted};
 use dom::document::{Document, DocumentHelpers};
-use dom::element::Element;
-use dom::node::{Node, NodeHelpers};
+use dom::node::NodeHelpers;
 use dom::window::Window;
-use devtools_traits::DevtoolsControlChan;
-use layout_interface::{
-    ContentBoxResponse, ContentBoxesResponse,
-    HitTestResponse, LayoutChan, LayoutRPC, MouseOverResponse, Msg, Reflow,
-    ReflowGoal, ReflowQueryType,
-    TrustedNodeAddress
-};
-use script_traits::{UntrustedNodeAddress, ScriptControlChan};
 
-use geom::{Point2D, Rect, Size2D};
-use js::rust::Cx;
-use msg::compositor_msg::ScriptListener;
-use msg::constellation_msg::{ConstellationChan, WindowSizeData};
 use msg::constellation_msg::{PipelineId, SubpageId};
-use net::resource_task::ResourceTask;
-use net::storage_task::StorageTask;
-use util::geometry::{Au, MAX_RECT};
-use util::geometry;
-use util::str::DOMString;
 use util::smallvec::SmallVec;
-use std::cell::{Cell, Ref, RefMut};
-use std::sync::mpsc::{channel, Receiver};
-use std::sync::mpsc::TryRecvError::{Empty, Disconnected};
-use std::mem::replace;
-use std::num::Float;
+use std::cell::Cell;
 use std::rc::Rc;
 use url::Url;
 
-/// Encapsulates a handle to a frame and its associated layout information.
+/// Encapsulates a handle to a frame in a frame tree.
 #[jstraceable]
 pub struct Page {
     /// Pipeline id associated with this page.
-    pub id: PipelineId,
+    id: PipelineId,
 
     /// Subpage id associated with this page, if any.
-    pub subpage_id: Option<SubpageId>,
+    subpage_id: Option<SubpageId>,
 
-    /// Unique id for last reflow request; used for confirming completion reply.
-    pub last_reflow_id: Cell<uint>,
+    /// The outermost frame containing the document and window.
+    frame: DOMRefCell<Option<Frame>>,
 
-    /// The outermost frame containing the document, window, and page URL.
-    pub frame: DOMRefCell<Option<Frame>>,
-
-    /// A handle for communicating messages to the layout task.
-    pub layout_chan: LayoutChan,
-
-    /// A handle to perform RPC calls into the layout, quickly.
-    layout_rpc: Box<LayoutRPC+'static>,
-
-    /// The port that we will use to join layout. If this is `None`, then layout is not running.
-    pub layout_join_port: DOMRefCell<Option<Receiver<()>>>,
-
-    /// The current size of the window, in pixels.
-    pub window_size: Cell<WindowSizeData>,
-
-    js_info: DOMRefCell<Option<JSPageInfo>>,
-
-    /// Cached copy of the most recent url loaded by the script
+    /// Cached copy of the most recent url loaded by the script, after all redirections.
     /// TODO(tkuehn): this currently does not follow any particular caching policy
-    /// and simply caches pages forever (!). The bool indicates if reflow is required
-    /// when reloading.
-    url: DOMRefCell<Option<(Url, bool)>>,
+    /// and simply caches pages forever (!).
+    url: Url,
 
-    next_subpage_id: Cell<SubpageId>,
-
-    /// Pending resize event, if any.
-    pub resize_event: Cell<Option<WindowSizeData>>,
-
-    /// Pending scroll to fragment event, if any
-    pub fragment_name: DOMRefCell<Option<String>>,
-
-    /// Associated resource task for use by DOM objects like XMLHttpRequest
-    pub resource_task: ResourceTask,
-
-    /// A handle for communicating messages to the storage task.
-    pub storage_task: StorageTask,
-
-    /// A handle for communicating messages to the constellation task.
-    pub constellation_chan: ConstellationChan,
+    /// Indicates if reflow is required when reloading.
+    needs_reflow: Cell<bool>,
 
     // Child Pages.
     pub children: DOMRefCell<Vec<Rc<Page>>>,
-
-    /// An enlarged rectangle around the page contents visible in the viewport, used
-    /// to prevent creating display list items for content that is far away from the viewport.
-    pub page_clip_rect: Cell<Rect<Au>>,
-
-    /// A flag to indicate whether the developer tools have requested live updates of
-    /// page changes.
-    pub devtools_wants_updates: Cell<bool>,
-
-    /// For providing instructions to an optional devtools server.
-    pub devtools_chan: Option<DevtoolsControlChan>,
 }
 
 pub struct PageIterator {
@@ -133,70 +65,27 @@ impl IterablePage for Rc<Page> {
 }
 
 impl Page {
-    pub fn new(id: PipelineId, subpage_id: Option<SubpageId>,
-               layout_chan: LayoutChan,
-               window_size: WindowSizeData,
-               resource_task: ResourceTask,
-               storage_task: StorageTask,
-               constellation_chan: ConstellationChan,
-               js_context: Rc<Cx>,
-               devtools_chan: Option<DevtoolsControlChan>) -> Page {
-        let js_info = JSPageInfo {
-            dom_static: GlobalStaticData::new(),
-            js_context: js_context,
-        };
-        let layout_rpc: Box<LayoutRPC> = {
-            let (rpc_send, rpc_recv) = channel();
-            let LayoutChan(ref lchan) = layout_chan;
-            lchan.send(Msg::GetRPC(rpc_send)).unwrap();
-            rpc_recv.recv().unwrap()
-        };
+    pub fn new(id: PipelineId, subpage_id: Option<SubpageId>, url: Url) -> Page {
         Page {
             id: id,
             subpage_id: subpage_id,
             frame: DOMRefCell::new(None),
-            layout_chan: layout_chan,
-            layout_rpc: layout_rpc,
-            layout_join_port: DOMRefCell::new(None),
-            window_size: Cell::new(window_size),
-            js_info: DOMRefCell::new(Some(js_info)),
-            url: DOMRefCell::new(None),
-            next_subpage_id: Cell::new(SubpageId(0)),
-            resize_event: Cell::new(None),
-            fragment_name: DOMRefCell::new(None),
-            last_reflow_id: Cell::new(0),
-            resource_task: resource_task,
-            storage_task: storage_task,
-            constellation_chan: constellation_chan,
+            url: url,
+            needs_reflow: Cell::new(true),
             children: DOMRefCell::new(vec!()),
-            page_clip_rect: Cell::new(MAX_RECT),
-            devtools_wants_updates: Cell::new(false),
-            devtools_chan: devtools_chan,
         }
     }
 
-    pub fn flush_layout(&self, goal: ReflowGoal, query: ReflowQueryType) {
-        let frame = self.frame();
-        let window = frame.as_ref().unwrap().window.root();
-        self.reflow(goal, window.r().control_chan().clone(), &mut **window.r().compositor(), query);
-    }
-
-    pub fn layout(&self) -> &LayoutRPC {
-        &*self.layout_rpc
+    pub fn window(&self) -> Temporary<Window> {
+        Temporary::new(self.frame.borrow().as_ref().unwrap().window.clone())
     }
 
-    pub fn content_box_query(&self, content_box_request: TrustedNodeAddress) -> Rect<Au> {
-        self.flush_layout(ReflowGoal::ForScriptQuery, ReflowQueryType::ContentBoxQuery(content_box_request));
-        self.join_layout(); //FIXME: is this necessary, or is layout_rpc's mutex good enough?
-        let ContentBoxResponse(rect) = self.layout_rpc.content_box();
-        rect
+    pub fn window_for_script_dealloation(&self) -> Unrooted<Window> {
+        Unrooted::from_js(self.frame.borrow().as_ref().unwrap().window)
     }
 
-    pub fn content_boxes_query(&self, content_boxes_request: TrustedNodeAddress) -> Vec<Rect<Au>> {
-        self.flush_layout(ReflowGoal::ForScriptQuery, ReflowQueryType::ContentBoxesQuery(content_boxes_request));
-        self.join_layout(); //FIXME: is this necessary, or is layout_rpc's mutex good enough?
-        let ContentBoxesResponse(rects) = self.layout_rpc.content_boxes();
-        rects
+    pub fn document(&self) -> Temporary<Document> {
+        Temporary::new(self.frame.borrow().as_ref().unwrap().document.clone())
     }
 
     // must handle root case separately
@@ -218,49 +107,6 @@ impl Page {
             }
         }
     }
-
-    pub fn set_page_clip_rect_with_new_viewport(&self, viewport: Rect<f32>) -> bool {
-        // We use a clipping rectangle that is five times the size of the of the viewport,
-        // so that we don't collect display list items for areas too far outside the viewport,
-        // but also don't trigger reflows every time the viewport changes.
-        static VIEWPORT_EXPANSION: f32 = 2.0; // 2 lengths on each side plus original length is 5 total.
-        let proposed_clip_rect = geometry::f32_rect_to_au_rect(
-            viewport.inflate(viewport.size.width * VIEWPORT_EXPANSION,
-            viewport.size.height * VIEWPORT_EXPANSION));
-        let clip_rect = self.page_clip_rect.get();
-        if proposed_clip_rect == clip_rect {
-            return false;
-        }
-
-        let had_clip_rect = clip_rect != MAX_RECT;
-        if had_clip_rect && !should_move_clip_rect(clip_rect, viewport) {
-            return false;
-        }
-
-        self.page_clip_rect.set(proposed_clip_rect);
-
-        // If we didn't have a clip rect, the previous display doesn't need rebuilding
-        // because it was built for infinite clip (MAX_RECT).
-        had_clip_rect
-    }
-
-    pub fn send_title_to_compositor(&self) {
-        match *self.frame() {
-            None => {}
-            Some(ref frame) => {
-                let window = frame.window.root();
-                let document = frame.document.root();
-                window.r().compositor().set_title(self.id, Some(document.r().Title()));
-            }
-        }
-    }
-
-    pub fn dirty_all_nodes(&self) {
-        match *self.frame.borrow() {
-            None => {}
-            Some(ref frame) => frame.document.root().r().dirty_all_nodes(),
-        }
-    }
 }
 
 impl Iterator for PageIterator {
@@ -280,200 +126,17 @@ impl Iterator for PageIterator {
 }
 
 impl Page {
-    pub fn mut_js_info<'a>(&'a self) -> RefMut<'a, Option<JSPageInfo>> {
-        self.js_info.borrow_mut()
-    }
-
-    pub unsafe fn unsafe_mut_js_info<'a>(&'a self) -> &'a mut Option<JSPageInfo> {
-        self.js_info.borrow_for_script_deallocation()
-    }
-
-    pub fn js_info<'a>(&'a self) -> Ref<'a, Option<JSPageInfo>> {
-        self.js_info.borrow()
+    pub fn set_reflow_status(&self, status: bool) -> bool {
+        let old = self.needs_reflow.get();
+        self.needs_reflow.set(status);
+        old
     }
 
-    pub fn url<'a>(&'a self) -> Ref<'a, Option<(Url, bool)>> {
-        self.url.borrow()
-    }
-
-    pub fn mut_url<'a>(&'a self) -> RefMut<'a, Option<(Url, bool)>> {
-        self.url.borrow_mut()
-    }
-
-    pub fn frame<'a>(&'a self) -> Ref<'a, Option<Frame>> {
-        self.frame.borrow()
-    }
-
-    pub fn mut_frame<'a>(&'a self) -> RefMut<'a, Option<Frame>> {
-        self.frame.borrow_mut()
-    }
-
-    pub fn get_next_subpage_id(&self) -> SubpageId {
-        let subpage_id = self.next_subpage_id.get();
-        let SubpageId(id_num) = subpage_id;
-        self.next_subpage_id.set(SubpageId(id_num + 1));
-        subpage_id
-    }
-
-    pub fn get_url(&self) -> Url {
-        self.url().as_ref().unwrap().0.clone()
-    }
-
-    // FIXME(cgaebel): join_layout is racey. What if the compositor triggers a
-    // reflow between the "join complete" message and returning from this
-    // function?
-
-    /// Sends a ping to layout and waits for the response. The response will arrive when the
-    /// layout task has finished any pending request messages.
-    fn join_layout(&self) {
-        let mut layout_join_port = self.layout_join_port.borrow_mut();
-        if let Some(join_port) = replace(&mut *layout_join_port, None) {
-            match join_port.try_recv() {
-                Err(Empty) => {
-                    info!("script: waiting on layout");
-                    join_port.recv().unwrap();
-                }
-                Ok(_) => {}
-                Err(Disconnected) => {
-                    panic!("Layout task failed while script was waiting for a result.");
-                }
-            }
-
-            debug!("script: layout joined")
-        }
-    }
-
-    /// Reflows the page if it's possible to do so and the page is dirty. This method will wait
-    /// for the layout thread to complete (but see the `TODO` below). If there is no window size
-    /// yet, the page is presumed invisible and no reflow is performed.
-    ///
-    /// TODO(pcwalton): Only wait for style recalc, since we have off-main-thread layout.
-    pub fn reflow(&self,
-                  goal: ReflowGoal,
-                  script_chan: ScriptControlChan,
-                  _: &mut ScriptListener,
-                  query_type: ReflowQueryType) {
-        let root = match *self.frame() {
-            None => return,
-            Some(ref frame) => {
-                frame.document.root().r().GetDocumentElement()
-            }
-        };
-
-        let root = match root.root() {
-            None => return,
-            Some(root) => root,
-        };
-
-        debug!("script: performing reflow for goal {:?}", goal);
-
-        let root: JSRef<Node> = NodeCast::from_ref(root.r());
-        if !root.get_has_dirty_descendants() {
-            debug!("root has no dirty descendants; avoiding reflow");
-            return
-        }
-
-        debug!("script: performing reflow for goal {:?}", goal);
-
-        // Layout will let us know when it's done.
-        let (join_chan, join_port) = channel();
-
-        {
-            let mut layout_join_port = self.layout_join_port.borrow_mut();
-            *layout_join_port = Some(join_port);
-        }
-
-        let last_reflow_id = &self.last_reflow_id;
-        last_reflow_id.set(last_reflow_id.get() + 1);
-
-        let window_size = self.window_size.get();
-
-        // Send new document and relevant styles to layout.
-        let reflow = box Reflow {
-            document_root: root.to_trusted_node_address(),
-            url: self.get_url(),
-            iframe: self.subpage_id.is_some(),
-            goal: goal,
-            window_size: window_size,
-            script_chan: script_chan,
-            script_join_chan: join_chan,
-            id: last_reflow_id.get(),
-            query_type: query_type,
-            page_clip_rect: self.page_clip_rect.get(),
-        };
-
-        let LayoutChan(ref chan) = self.layout_chan;
-        chan.send(Msg::Reflow(reflow)).unwrap();
-
-        debug!("script: layout forked");
-
-        self.join_layout();
-    }
-
-    /// Attempt to find a named element in this page's document.
-    pub fn find_fragment_node(&self, fragid: DOMString) -> Option<Temporary<Element>> {
-        let document = self.frame().as_ref().unwrap().document.root();
-        document.r().find_fragment_node(fragid)
-    }
-
-    pub fn hit_test(&self, point: &Point2D<f32>) -> Option<UntrustedNodeAddress> {
-        let frame = self.frame();
-        let document = frame.as_ref().unwrap().document.root();
-        let root = match document.r().GetDocumentElement().root() {
-            None => return None,
-            Some(root) => root,
-        };
-        let root: JSRef<Node> = NodeCast::from_ref(root.r());
-        let address = match self.layout().hit_test(root.to_trusted_node_address(), *point) {
-            Ok(HitTestResponse(node_address)) => {
-                Some(node_address)
-            }
-            Err(()) => {
-                debug!("layout query error");
-                None
-            }
-        };
-        address
-    }
-
-    pub fn get_nodes_under_mouse(&self, point: &Point2D<f32>) -> Vec<UntrustedNodeAddress> {
-        let mut results = vec!();
-        let frame = self.frame();
-        let document = frame.as_ref().unwrap().document.root();
-        match document.r().GetDocumentElement().root() {
-            Some(root) => {
-                let root: JSRef<Node> = NodeCast::from_ref(root.r());
-                match self.layout().mouse_over(root.to_trusted_node_address(), *point) {
-                    Ok(MouseOverResponse(node_addresses)) => {
-                        results = node_addresses;
-                    }
-                    Err(()) => {}
-                };
-            }
-            None => {}
-        }
-        results
+    pub fn set_frame(&self, frame: Option<Frame>) {
+        *self.frame.borrow_mut() = frame;
     }
 }
 
-fn should_move_clip_rect(clip_rect: Rect<Au>, new_viewport: Rect<f32>) -> bool{
-    let clip_rect = Rect(Point2D(geometry::to_frac_px(clip_rect.origin.x) as f32,
-                                 geometry::to_frac_px(clip_rect.origin.y) as f32),
-                         Size2D(geometry::to_frac_px(clip_rect.size.width) as f32,
-                                geometry::to_frac_px(clip_rect.size.height) as f32));
-
-    // We only need to move the clip rect if the viewport is getting near the edge of
-    // our preexisting clip rect. We use half of the size of the viewport as a heuristic
-    // for "close."
-    static VIEWPORT_SCROLL_MARGIN_SIZE: f32 = 0.5;
-    let viewport_scroll_margin = new_viewport.size * VIEWPORT_SCROLL_MARGIN_SIZE;
-
-    (clip_rect.origin.x - new_viewport.origin.x).abs() <= viewport_scroll_margin.width ||
-    (clip_rect.max_x() - new_viewport.max_x()).abs() <= viewport_scroll_margin.width ||
-    (clip_rect.origin.y - new_viewport.origin.y).abs() <= viewport_scroll_margin.height ||
-    (clip_rect.max_y() - new_viewport.max_y()).abs() <= viewport_scroll_margin.height
-}
-
 /// Information for one frame in the browsing context.
 #[jstraceable]
 #[must_root]
@@ -483,12 +146,3 @@ pub struct Frame {
     /// The window object for this frame.
     pub window: JS<Window>,
 }
-
-/// Encapsulation of the javascript information associated with each frame.
-#[jstraceable]
-pub struct JSPageInfo {
-    /// Global static data related to the DOM.
-    pub dom_static: GlobalStaticData,
-    /// The JavaScript context.
-    pub js_context: Rc<Cx>,
-}
diff --git a/components/script/script_task.rs b/components/script/script_task.rs
index 51361bd1436..673dc3510ef 100644
--- a/components/script/script_task.rs
+++ b/components/script/script_task.rs
@@ -3,7 +3,19 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 //! The script task is the task that owns the DOM in memory, runs JavaScript, and spawns parsing
-//! and layout tasks.
+//! and layout tasks. It's in charge of processing events for all same-origin pages in a frame
+//! tree, and manages the entire lifetime of pages in the frame tree from initial request to
+//! teardown.
+//!
+//! Page loads follow a two-step process. When a request for a new page load is received, the
+//! network request is initiated and the relevant data pertaining to the new page is stashed.
+//! While the non-blocking request is ongoing, the script task is free to process further events,
+//! noting when they pertain to ongoing loads (such as resizes/viewport adjustments). When the
+//! initial response is received for an ongoing load, the second phase starts - the frame tree
+//! entry is created, along with the Window and Document objects, and the appropriate parser
+//! takes over the response body. Once parsing is complete, the document lifecycle for loading
+//! a page runs its course and the script task returns to processing events in the main event
+//! loop.
 
 #![allow(unsafe_blocks)]
 
@@ -23,7 +35,7 @@ use dom::element::{Element, AttributeHandlers};
 use dom::event::{Event, EventHelpers};
 use dom::uievent::UIEvent;
 use dom::eventtarget::EventTarget;
-use dom::node::{self, Node, NodeHelpers, NodeDamage};
+use dom::node::{self, Node, NodeHelpers, NodeDamage, window_from_node};
 use dom::window::{Window, WindowHelpers, ScriptHelpers};
 use dom::worker::{Worker, TrustedWorkerAddress};
 use parse::html::{HTMLInput, parse_html};
@@ -49,19 +61,20 @@ use msg::constellation_msg::{LoadData, PipelineId, SubpageId};
 use msg::constellation_msg::{Failure, Msg, WindowSizeData, PipelineExitType};
 use msg::constellation_msg::Msg as ConstellationMsg;
 use net::image_cache_task::ImageCacheTask;
-use net::resource_task::{ResourceTask, ControlMsg};
+use net::resource_task::{ResourceTask, ControlMsg, LoadResponse};
 use net::resource_task::LoadData as NetLoadData;
 use net::storage_task::StorageTask;
 use string_cache::Atom;
 use util::geometry::to_frac_px;
 use util::smallvec::SmallVec;
 use util::str::DOMString;
-use util::task::spawn_named_with_send_on_failure;
+use util::task::{spawn_named, spawn_named_with_send_on_failure};
 use util::task_state;
 
+use geom::Rect;
 use geom::point::Point2D;
 use hyper::header::{LastModified, Headers};
-use js::jsapi::{JS_SetWrapObjectCallbacks, JS_SetGCZeal, JS_DEFAULT_ZEAL_FREQ, JS_GC};
+use js::jsapi::{JS_SetWrapObjectCallbacks, JS_SetGCZeal, JS_DEFAULT_ZEAL_FREQ};
 use js::jsapi::{JSContext, JSRuntime, JSObject};
 use js::jsapi::{JS_SetGCParameter, JSGC_MAX_BYTES};
 use js::jsapi::{JS_SetGCCallback, JSGCStatus, JSGC_BEGIN, JSGC_END};
@@ -73,7 +86,6 @@ use libc;
 use std::any::Any;
 use std::borrow::ToOwned;
 use std::cell::Cell;
-use std::mem::replace;
 use std::num::ToPrimitive;
 use std::rc::Rc;
 use std::result::Result;
@@ -83,6 +95,43 @@ use time::Tm;
 
 thread_local!(pub static STACK_ROOTS: Cell<Option<RootCollectionPtr>> = Cell::new(None));
 
+/// A document load that is in the process of fetching the requested resource. Contains
+/// data that will need to be present when the document and frame tree entry are created,
+/// but is only easily available at initiation of the load and on a push basis (so some
+/// data will be updated according to future resize events, viewport changes, etc.)
+struct InProgressLoad {
+    /// The pipeline which requested this load.
+    pipeline_id: PipelineId,
+    /// The parent pipeline and child subpage associated with this load, if any.
+    subpage_id: Option<(PipelineId, SubpageId)>,
+    /// The current window size associated with this pipeline.
+    window_size: WindowSizeData,
+    /// Channel to the layout task associated with this pipeline.
+    layout_chan: LayoutChan,
+    /// The current viewport clipping rectangle applying to this pipelie, if any.
+    clip_rect: Option<Rect<f32>>,
+    /// The requested URL of the load.
+    url: Url,
+}
+
+impl InProgressLoad {
+    /// Create a new InProgressLoad object.
+    fn new(id: PipelineId,
+           subpage_id: Option<(PipelineId, SubpageId)>,
+           layout_chan: LayoutChan,
+           window_size: WindowSizeData,
+           url: Url) -> InProgressLoad {
+        InProgressLoad {
+            pipeline_id: id,
+            subpage_id: subpage_id,
+            layout_chan: layout_chan,
+            window_size: window_size,
+            clip_rect: None,
+            url: url,
+        }
+    }
+}
+
 #[derive(Copy)]
 pub enum TimerSource {
     FromWindow(PipelineId),
@@ -118,6 +167,8 @@ pub enum ScriptMsg {
     RunnableMsg(Box<Runnable+Send>),
     /// A DOM object's last pinned reference was removed (dispatched to all tasks).
     RefcountCleanup(TrustedReference),
+    /// The final network response for a page has arrived.
+    PageFetchComplete(PipelineId, Option<SubpageId>, LoadResponse),
 }
 
 /// A cloneable interface for communicating with an event loop.
@@ -175,11 +226,15 @@ impl Drop for StackRootTLS {
 /// FIXME: Rename to `Page`, following WebKit?
 pub struct ScriptTask {
     /// A handle to the information pertaining to page layout
-    page: DOMRefCell<Rc<Page>>,
+    page: DOMRefCell<Option<Rc<Page>>>,
+    /// A list of data pertaining to loads that have not yet received a network response
+    incomplete_loads: DOMRefCell<Vec<InProgressLoad>>,
     /// A handle to the image cache task.
     image_cache_task: ImageCacheTask,
     /// A handle to the resource task.
     resource_task: ResourceTask,
+    /// A handle to the storage task.
+    storage_task: StorageTask,
 
     /// The port on which the script task receives messages (load URL, exit, etc.)
     port: Receiver<ScriptMsg>,
@@ -242,7 +297,8 @@ impl<'a> Drop for ScriptMemoryFailsafe<'a> {
                 unsafe {
                     let page = owner.page.borrow_for_script_deallocation();
                     for page in page.iter() {
-                        *page.unsafe_mut_js_info() = None;
+                        let window = page.window().root();
+                        window.r().clear_js_context_for_script_deallocation();
                     }
                     *owner.js_context.borrow_for_script_deallocation() = None;
                 }
@@ -274,15 +330,14 @@ impl ScriptTaskFactory for ScriptTask {
                  storage_task: StorageTask,
                  image_cache_task: ImageCacheTask,
                  devtools_chan: Option<DevtoolsControlChan>,
-                 window_size: WindowSizeData)
+                 window_size: WindowSizeData,
+                 load_data: LoadData)
                  where C: ScriptListener + Send + 'static {
         let ConstellationChan(const_chan) = constellation_chan.clone();
         let (script_chan, script_port) = channel();
         let layout_chan = LayoutChan(layout_chan.sender());
         spawn_named_with_send_on_failure("ScriptTask", task_state::SCRIPT, move || {
-            let script_task = ScriptTask::new(id,
-                                              box compositor as Box<ScriptListener>,
-                                              layout_chan,
+            let script_task = ScriptTask::new(box compositor as Box<ScriptListener>,
                                               script_port,
                                               NonWorkerScriptChan(script_chan),
                                               control_chan,
@@ -291,9 +346,13 @@ impl ScriptTaskFactory for ScriptTask {
                                               resource_task,
                                               storage_task,
                                               image_cache_task,
-                                              devtools_chan,
-                                              window_size);
+                                              devtools_chan);
             let mut failsafe = ScriptMemoryFailsafe::new(&script_task);
+
+            let new_load = InProgressLoad::new(id, None, layout_chan, window_size,
+                                               load_data.url.clone());
+            script_task.start_page_load(new_load, load_data);
+
             script_task.start();
 
             // This must always be the very last operation performed before the task completes
@@ -312,9 +371,7 @@ unsafe extern "C" fn debug_gc_callback(_rt: *mut JSRuntime, status: JSGCStatus)
 
 impl ScriptTask {
     /// Creates a new script task.
-    pub fn new(id: PipelineId,
-               compositor: Box<ScriptListener+'static>,
-               layout_chan: LayoutChan,
+    pub fn new(compositor: Box<ScriptListener+'static>,
                port: Receiver<ScriptMsg>,
                chan: NonWorkerScriptChan,
                control_chan: ScriptControlChan,
@@ -323,8 +380,7 @@ impl ScriptTask {
                resource_task: ResourceTask,
                storage_task: StorageTask,
                img_cache_task: ImageCacheTask,
-               devtools_chan: Option<DevtoolsControlChan>,
-               window_size: WindowSizeData)
+               devtools_chan: Option<DevtoolsControlChan>)
                -> ScriptTask {
         let (js_runtime, js_context) = ScriptTask::new_rt_and_cx();
         let wrap_for_same_compartment = wrap_for_same_compartment as
@@ -348,19 +404,14 @@ impl ScriptTask {
                                       Some(pre_wrap));
         }
 
-        let page = Page::new(id, None, layout_chan, window_size,
-                             resource_task.clone(),
-                             storage_task,
-                             constellation_chan.clone(),
-                             js_context.clone(),
-                             devtools_chan.clone());
-
         let (devtools_sender, devtools_receiver) = channel();
         ScriptTask {
-            page: DOMRefCell::new(Rc::new(page)),
+            page: DOMRefCell::new(None),
+            incomplete_loads: DOMRefCell::new(vec!()),
 
             image_cache_task: img_cache_task,
             resource_task: resource_task,
+            storage_task: storage_task,
 
             port: port,
             chan: chan,
@@ -417,6 +468,11 @@ impl ScriptTask {
         (js_runtime, js_context)
     }
 
+    // Return the root page in the frame tree. Panics if it doesn't exist.
+    fn root_page(&self) -> Rc<Page> {
+        self.page.borrow().as_ref().unwrap().clone()
+    }
+
     pub fn get_cx(&self) -> *mut JSContext {
         (**self.js_context.borrow().as_ref().unwrap()).ptr
     }
@@ -439,17 +495,18 @@ impl ScriptTask {
         let mut resizes = vec!();
 
         {
-            let page = self.page.borrow_mut();
-            for page in page.iter() {
-                // Only process a resize if layout is idle.
-                let layout_join_port = page.layout_join_port.borrow();
-                if layout_join_port.is_none() {
-                    let mut resize_event = page.resize_event.get();
-                    match resize_event.take() {
-                        Some(size) => resizes.push((page.id, size)),
-                        None => ()
+            let page = self.page.borrow();
+            if let Some(page) = page.as_ref() {
+                for page in page.iter() {
+                    // Only process a resize if layout is idle.
+                    let window = page.window().root();
+                    if window.r().layout_is_idle() {
+                        let resize_event = window.r().steal_resize_event();
+                        match resize_event {
+                            Some(size) => resizes.push((window.r().pipeline(), size)),
+                            None => ()
+                        }
                     }
-                    page.resize_event.set(None);
                 }
             }
         }
@@ -502,17 +559,10 @@ impl ScriptTask {
                     self.handle_new_layout(new_layout_info);
                 }
                 MixedMessage::FromConstellation(ConstellationControlMsg::Resize(id, size)) => {
-                    let page = self.page.borrow_mut();
-                    let page = page.find(id).expect("resize sent to nonexistent pipeline");
-                    page.resize_event.set(Some(size));
+                    self.handle_resize(id, size);
                 }
                 MixedMessage::FromConstellation(ConstellationControlMsg::Viewport(id, rect)) => {
-                    let page = self.page.borrow_mut();
-                    let inner_page = page.find(id).expect("Page rect message sent to nonexistent pipeline");
-                    if inner_page.set_page_clip_rect_with_new_viewport(rect) {
-                        let page = get_page(&*page, id);
-                        self.force_reflow(&*page);
-                    }
+                    self.handle_viewport(id, rect);
                 }
                 _ => {
                     sequential.push(event);
@@ -555,8 +605,8 @@ impl ScriptTask {
         match msg {
             ConstellationControlMsg::AttachLayout(_) =>
                 panic!("should have handled AttachLayout already"),
-            ConstellationControlMsg::Load(id, parent, load_data) =>
-                self.load(id, parent, load_data),
+            ConstellationControlMsg::Activate(id) =>
+                self.handle_activate(id),
             ConstellationControlMsg::SendEvent(id, event) =>
                 self.handle_event(id, event),
             ConstellationControlMsg::ReflowComplete(id, reflow_id) =>
@@ -598,98 +648,144 @@ impl ScriptTask {
                 runnable.handler(),
             ScriptMsg::RefcountCleanup(addr) =>
                 LiveDOMReferences::cleanup(self.get_cx(), addr),
+            ScriptMsg::PageFetchComplete(id, subpage, response) =>
+                self.handle_page_fetch_complete(id, subpage, response),
         }
     }
 
     fn handle_msg_from_devtools(&self, msg: DevtoolScriptControlMsg) {
+        let page = self.root_page();
         match msg {
             DevtoolScriptControlMsg::EvaluateJS(id, s, reply) =>
-                devtools::handle_evaluate_js(&*self.page.borrow(), id, s, reply),
+                devtools::handle_evaluate_js(&page, id, s, reply),
             DevtoolScriptControlMsg::GetRootNode(id, reply) =>
-                devtools::handle_get_root_node(&*self.page.borrow(), id, reply),
+                devtools::handle_get_root_node(&page, id, reply),
             DevtoolScriptControlMsg::GetDocumentElement(id, reply) =>
-                devtools::handle_get_document_element(&*self.page.borrow(), id, reply),
+                devtools::handle_get_document_element(&page, id, reply),
             DevtoolScriptControlMsg::GetChildren(id, node_id, reply) =>
-                devtools::handle_get_children(&*self.page.borrow(), id, node_id, reply),
+                devtools::handle_get_children(&page, id, node_id, reply),
             DevtoolScriptControlMsg::GetLayout(id, node_id, reply) =>
-                devtools::handle_get_layout(&*self.page.borrow(), id, node_id, reply),
+                devtools::handle_get_layout(&page, id, node_id, reply),
             DevtoolScriptControlMsg::ModifyAttribute(id, node_id, modifications) =>
-                devtools::handle_modify_attribute(&*self.page.borrow(), id, node_id, modifications),
+                devtools::handle_modify_attribute(&page, id, node_id, modifications),
             DevtoolScriptControlMsg::WantsLiveNotifications(pipeline_id, to_send) =>
-                devtools::handle_wants_live_notifications(&*self.page.borrow(), pipeline_id, to_send),
+                devtools::handle_wants_live_notifications(&page, pipeline_id, to_send),
         }
     }
 
+    fn handle_resize(&self, id: PipelineId, size: WindowSizeData) {
+        let page = self.page.borrow();
+        if let Some(ref page) = page.as_ref() {
+            if let Some(ref page) = page.find(id) {
+                let window = page.window().root();
+                window.r().set_resize_event(size);
+                return;
+            }
+        }
+        let mut loads = self.incomplete_loads.borrow_mut();
+        if let Some(ref mut load) = loads.iter_mut().find(|load| load.pipeline_id == id) {
+            load.window_size = size;
+            return;
+        }
+        panic!("resize sent to nonexistent pipeline");
+    }
+
+    fn handle_viewport(&self, id: PipelineId, rect: Rect<f32>) {
+        let page = self.page.borrow();
+        if let Some(page) = page.as_ref() {
+            if let Some(ref inner_page) = page.find(id) {
+                let window = inner_page.window().root();
+                if window.r().set_page_clip_rect_with_new_viewport(rect) {
+                    let page = get_page(page, id);
+                    self.force_reflow(&*page);
+                }
+                return;
+            }
+        }
+        let mut loads = self.incomplete_loads.borrow_mut();
+        if let Some(ref mut load) = loads.iter_mut().find(|load| load.pipeline_id == id) {
+            load.clip_rect = Some(rect);
+            return;
+        }
+        panic!("Page rect message sent to nonexistent pipeline");
+     }
+
+    /// Handle a request to load a page in a new child frame of an existing page.
     fn handle_new_layout(&self, new_layout_info: NewLayoutInfo) {
         let NewLayoutInfo {
             old_pipeline_id,
             new_pipeline_id,
             subpage_id,
-            layout_chan
+            layout_chan,
+            load_data,
         } = new_layout_info;
 
-        let page = self.page.borrow_mut();
+        let page = self.root_page();
         let parent_page = page.find(old_pipeline_id).expect("ScriptTask: received a layout
             whose parent has a PipelineId which does not correspond to a pipeline in the script
             task's page tree. This is a bug.");
-        let new_page = {
-            let window_size = parent_page.window_size.get();
-            Page::new(new_pipeline_id, Some(subpage_id),
-                      LayoutChan(layout_chan.downcast_ref::<Sender<layout_interface::Msg>>().unwrap().clone()),
-                      window_size,
-                      parent_page.resource_task.clone(),
-                      parent_page.storage_task.clone(),
-                      self.constellation_chan.clone(),
-                      self.js_context.borrow().as_ref().unwrap().clone(),
-                      self.devtools_chan.clone())
-        };
-        parent_page.children.borrow_mut().push(Rc::new(new_page));
+
+        let parent_window = parent_page.window().root();
+        let chan = layout_chan.downcast_ref::<Sender<layout_interface::Msg>>().unwrap();
+        let layout_chan = LayoutChan(chan.clone());
+        // Kick off the fetch for the new resource.
+        let new_load = InProgressLoad::new(new_pipeline_id, Some((old_pipeline_id, subpage_id)),
+                                           layout_chan, parent_window.r().window_size(),
+                                           load_data.url.clone());
+        self.start_page_load(new_load, load_data);
     }
 
     /// Handles a timer that fired.
     fn handle_fire_timer_msg(&self, id: PipelineId, timer_id: TimerId) {
-        let page = self.page.borrow_mut();
+        let page = self.root_page();
         let page = page.find(id).expect("ScriptTask: received fire timer msg for a
             pipeline ID not associated with this script task. This is a bug.");
-        let frame = page.frame();
-        let window = frame.as_ref().unwrap().window.root();
+        let window = page.window().root();
         window.r().handle_fire_timer(timer_id);
     }
 
     /// Handles freeze message
     fn handle_freeze_msg(&self, id: PipelineId) {
-        let page = self.page.borrow_mut();
+        let page = self.root_page();
         let page = page.find(id).expect("ScriptTask: received freeze msg for a
                     pipeline ID not associated with this script task. This is a bug.");
-        let frame = page.frame();
-        let window = frame.as_ref().unwrap().window.root();
+        let window = page.window().root();
         window.r().freeze();
     }
 
     /// Handles thaw message
     fn handle_thaw_msg(&self, id: PipelineId) {
-        let page = self.page.borrow_mut();
+        let page = self.root_page();
         let page = page.find(id).expect("ScriptTask: received thaw msg for a
                             pipeline ID not associated with this script task. This is a bug.");
-        let frame = page.frame();
-        let window = frame.as_ref().unwrap().window.root();
+        let window = page.window().root();
         window.r().thaw();
     }
 
+    /// Handle a request to make a previously-created pipeline active.
+    //TODO: unsuspend JS and timers, etc. when we support such things.
+    fn handle_activate(&self, pipeline_id: PipelineId) {
+        // We should only get this message when moving in history, so all pages requested
+        // should exist.
+        let page = self.root_page().find(pipeline_id).unwrap();
+
+        let needed_reflow = page.set_reflow_status(false);
+        if needed_reflow {
+            self.force_reflow(&*page);
+        }
+    }
+
     /// Handles a notification that reflow completed.
     fn handle_reflow_complete_msg(&self, pipeline_id: PipelineId, reflow_id: uint) {
         debug!("Script: Reflow {:?} complete for {:?}", reflow_id, pipeline_id);
-        let page = self.page.borrow_mut();
+        let page = self.root_page();
         let page = page.find(pipeline_id).expect(
             "ScriptTask: received a load message for a layout channel that is not associated \
              with this script task. This is a bug.");
-        let last_reflow_id = page.last_reflow_id.get();
-        if last_reflow_id == reflow_id {
-            let mut layout_join_port = page.layout_join_port.borrow_mut();
-            *layout_join_port = None;
-        }
+        let window = page.window().root();
+        window.r().handle_reflow_complete_msg(reflow_id);
 
-        let doc = page.frame().as_ref().unwrap().document.root();
+        let doc = page.document().root();
         let html_element = doc.r().GetDocumentElement().root();
         let reftest_wait = html_element.r().map_or(false, |elem| elem.has_class(&Atom::from_slice("reftest-wait")));
 
@@ -700,14 +796,12 @@ impl ScriptTask {
 
     /// Window was resized, but this script was not active, so don't reflow yet
     fn handle_resize_inactive_msg(&self, id: PipelineId, new_size: WindowSizeData) {
-        let page = self.page.borrow_mut();
+        let page = self.root_page();
         let page = page.find(id).expect("Received resize message for PipelineId not associated
             with a page in the page tree. This is a bug.");
-        page.window_size.set(new_size);
-        match &mut *page.mut_url() {
-            &mut Some((_, ref mut needs_reflow)) => *needs_reflow = true,
-            &mut None => (),
-        }
+        let window = page.window().root();
+        window.r().set_window_size(new_size);
+        page.set_reflow_status(true);
     }
 
     /// We have gotten a window.close from script, which we pass on to the compositor.
@@ -724,182 +818,199 @@ impl ScriptTask {
         self.compositor.borrow_mut().close();
     }
 
+    /// We have received notification that the response associated with a load has completed.
+    /// Kick off the document and frame tree creation process using the result.
+    fn handle_page_fetch_complete(&self, id: PipelineId, subpage: Option<SubpageId>,
+                                  response: LoadResponse) {
+        // Any notification received should refer to an existing, in-progress load that is tracked.
+        let idx = self.incomplete_loads.borrow().iter().position(|&:load| {
+            load.pipeline_id == id && load.subpage_id.map(|sub| sub.1) == subpage
+        }).unwrap();
+        let load = self.incomplete_loads.borrow_mut().remove(idx);
+        self.load(response, load);
+    }
+
     /// Handles a request for the window title.
     fn handle_get_title_msg(&self, pipeline_id: PipelineId) {
-        get_page(&*self.page.borrow(), pipeline_id).send_title_to_compositor();
+        let page = get_page(&self.root_page(), pipeline_id);
+        let document = page.document().root();
+        document.r().send_title_to_compositor();
     }
 
     /// Handles a request to exit the script task and shut down layout.
     /// Returns true if the script task should shut down and false otherwise.
     fn handle_exit_pipeline_msg(&self, id: PipelineId, exit_type: PipelineExitType) -> bool {
         // If root is being exited, shut down all pages
-        let page = self.page.borrow_mut();
-        if page.id == id {
+        let page = self.root_page();
+        let window = page.window().root();
+        if window.r().pipeline() == id {
             debug!("shutting down layout for root page {:?}", id);
+            // To ensure the elements of the DOM tree remain usable (such as the window global),
+            // don't free the JS context until all interactions with it are finished.
+            shut_down_layout(&page, exit_type);
             *self.js_context.borrow_mut() = None;
-            shut_down_layout(&*page, (*self.js_runtime).ptr, exit_type);
             return true
         }
 
         // otherwise find just the matching page and exit all sub-pages
-        match page.find(id) {
-            Some(ref mut page) => {
-                shut_down_layout(&*page, (*self.js_runtime).ptr, exit_type);
-                page.remove(id);
-                false
-            }
-            // TODO(tkuehn): pipeline closing is currently duplicated across
-            // script and constellation, which can cause this to happen. Constellation
-            // needs to be smarter about exiting pipelines.
-            None => false,
+        if let Some(ref mut child_page) = page.remove(id) {
+            shut_down_layout(&*child_page, exit_type);
         }
-
+        return false;
     }
 
     /// The entry point to document loading. Defines bindings, sets up the window and document
     /// objects, parses HTML and CSS, and kicks off initial layout.
-    fn load(&self, pipeline_id: PipelineId,
-            parent: Option<(PipelineId, SubpageId)>, load_data: LoadData) {
-        let url = load_data.url.clone();
-        debug!("ScriptTask: loading {} on page {:?}", url.serialize(), pipeline_id);
-
-        let borrowed_page = self.page.borrow_mut();
-
-        let frame_element = parent.and_then(|(parent_id, subpage_id)| {
-            // In the case a parent id exists but the matching page
-            // cannot be found, this means the page exists in a different
-            // script task (due to origin) so it shouldn't be returned.
-            // TODO: window.parent will continue to return self in that
-            // case, which is wrong. We should be returning an object that
-            // denies access to most properties (per
-            // https://github.com/servo/servo/issues/3939#issuecomment-62287025).
-            borrowed_page.find(parent_id).and_then(|page| {
-                let doc = page.frame().as_ref().unwrap().document.root();
-                let doc: JSRef<Node> = NodeCast::from_ref(doc.r());
-
-                doc.traverse_preorder()
-                   .filter_map(HTMLIFrameElementCast::to_ref)
-                   .find(|node| node.subpage_id() == Some(subpage_id))
-                   .map(ElementCast::from_ref)
-                   .map(Temporary::from_rooted)
-            })
+    fn load(&self, response: LoadResponse, incomplete: InProgressLoad) {
+        let final_url = response.metadata.final_url.clone();
+        debug!("ScriptTask: loading {} on page {:?}", incomplete.url.serialize(), incomplete.pipeline_id);
+
+        // We should either be initializing a root page or loading a child page of an
+        // existing one.
+        let root_page_exists = self.page.borrow().is_some();
+        assert!(incomplete.subpage_id.is_none() || root_page_exists);
+
+        let frame_element = incomplete.subpage_id.and_then(|(parent_id, subpage_id)| {
+            let borrowed_page = self.root_page();
+          // In the case a parent id exists but the matching page
+          // cannot be found, this means the page exists in a different
+          // script task (due to origin) so it shouldn't be returned.
+          // TODO: window.parent will continue to return self in that
+          // case, which is wrong. We should be returning an object that
+          // denies access to most properties (per
+          // https://github.com/servo/servo/issues/3939#issuecomment-62287025).
+          borrowed_page.find(parent_id).and_then(|page| {
+            let doc = page.document().root();
+            let doc: JSRef<Node> = NodeCast::from_ref(doc.r());
+
+            doc.traverse_preorder()
+               .filter_map(HTMLIFrameElementCast::to_ref)
+               .find(|node| node.subpage_id() == Some(subpage_id))
+               .map(ElementCast::from_ref)
+               .map(Temporary::from_rooted)
+          })
         }).root();
 
-        let page = borrowed_page.find(pipeline_id).expect("ScriptTask: received a load
-            message for a layout channel that is not associated with this script task. This
-            is a bug.");
+        self.compositor.borrow_mut().set_ready_state(incomplete.pipeline_id, Loading);
 
-        // Are we reloading?
-        let reloading = match *page.url() {
-            Some((ref loaded, _)) => *loaded == url,
-            _ => false,
-        };
-        if reloading {
-            // Pull out the `needs_reflow` flag explicitly because `reflow` can ask for the page's
-            // URL, and we can't be holding a borrow on that URL (#4402).
-            let needed_reflow = match &mut *page.mut_url() {
-                &mut Some((_, ref mut needs_reflow)) => replace(needs_reflow, false),
-                _ => panic!("can't reload a page with no URL!")
-            };
-            if needed_reflow {
-                self.force_reflow(&*page);
-            }
-            return
-        }
-        let last_url = replace(&mut *page.mut_url(), None).map(|(last_url, _)| last_url);
-
-        let is_javascript = url.scheme.as_slice() == "javascript";
-
-        self.compositor.borrow_mut().set_ready_state(pipeline_id, Loading);
-
-        let (mut parser_input, final_url, last_modified) = if !is_javascript {
-            // Wait for the LoadResponse so that the parser knows the final URL.
-            let (input_chan, input_port) = channel();
-            self.resource_task.send(ControlMsg::Load(NetLoadData {
-                url: url,
-                method: load_data.method,
-                headers: Headers::new(),
-                preserved_headers: load_data.headers,
-                data: load_data.data,
-                cors: None,
-                consumer: input_chan,
-            })).unwrap();
+        let cx = self.js_context.borrow();
+        let cx = cx.as_ref().unwrap();
 
-            let load_response = input_port.recv().unwrap();
+        // Create a new frame tree entry.
+        let page = Rc::new(Page::new(incomplete.pipeline_id, incomplete.subpage_id.map(|p| p.1),
+                                     final_url.clone()));
+        if !root_page_exists {
+            // We have a new root frame tree.
+            *self.page.borrow_mut() = Some(page.clone());
+        } else if let Some((parent, _)) = incomplete.subpage_id {
+            // We have a new child frame.
+            let parent_page = self.root_page();
+            parent_page.find(parent).expect("received load for subpage with missing parent");
+            parent_page.children.borrow_mut().push(page.clone());
+        }
 
-            let last_modified = load_response.metadata.headers.as_ref().and_then(|headers| {
-                headers.get().map(|&LastModified(ref tm)| tm.clone())
-            });
+        enum PageToRemove {
+            Root,
+            Child(PipelineId),
+        }
+        struct AutoPageRemover<'a> {
+            page: PageToRemove,
+            script_task: &'a ScriptTask,
+            neutered: bool,
+        }
+        impl<'a> AutoPageRemover<'a> {
+            fn new(script_task: &'a ScriptTask, page: PageToRemove) -> AutoPageRemover<'a> {
+                AutoPageRemover {
+                    page: page,
+                    script_task: script_task,
+                    neutered: false,
+                }
+            }
 
-            let final_url = load_response.metadata.final_url.clone();
+            fn neuter(&mut self) {
+                self.neutered = true;
+            }
+        }
+        #[unsafe_destructor]
+        impl<'a> Drop for AutoPageRemover<'a> {
+            fn drop(&mut self) {
+                if !self.neutered {
+                    match self.page {
+                        PageToRemove::Root => *self.script_task.page.borrow_mut() = None,
+                        PageToRemove::Child(id) => {
+                            let _ = self.script_task.root_page().remove(id);
+                        }
+                    }
+                }
+            }
+        }
 
-            (Some(HTMLInput::InputUrl(load_response)), final_url, last_modified)
+        let page_to_remove = if !root_page_exists {
+            PageToRemove::Root
         } else {
-            let doc_url = last_url.unwrap_or_else(|| {
-                Url::parse("about:blank").unwrap()
-            });
-            (None, doc_url, None)
+            PageToRemove::Child(incomplete.pipeline_id)
         };
+        let mut page_remover = AutoPageRemover::new(self, page_to_remove);
 
-        // Store the final URL before we start parsing, so that DOM routines
-        // (e.g. HTMLImageElement::update_image) can resolve relative URLs
-        // correctly.
-        {
-            *page.mut_url() = Some((final_url.clone(), true));
-        }
-
-        let cx = self.js_context.borrow();
-        let cx = cx.as_ref().unwrap();
         // Create the window and document objects.
-        let window = Window::new(cx.ptr,
+        let window = Window::new(cx.clone(),
                                  page.clone(),
                                  self.chan.clone(),
                                  self.control_chan.clone(),
                                  self.compositor.borrow_mut().dup(),
-                                 self.image_cache_task.clone()).root();
+                                 self.image_cache_task.clone(),
+                                 self.resource_task.clone(),
+                                 self.storage_task.clone(),
+                                 self.devtools_chan.clone(),
+                                 self.constellation_chan.clone(),
+                                 incomplete.layout_chan,
+                                 incomplete.pipeline_id,
+                                 incomplete.subpage_id.map(|s| s.1),
+                                 incomplete.window_size).root();
 
         let document = Document::new(window.r(), Some(final_url.clone()),
                                      IsHTMLDocument::HTMLDocument, None,
                                      DocumentSource::FromParser).root();
+
+        window.r().init_browser_context(document.r(), frame_element.r());
+
+        let last_modified = response.metadata.headers.as_ref().and_then(|headers| {
+            headers.get().map(|&LastModified(ref tm)| tm.clone())
+        });
         if let Some(tm) = last_modified {
             document.r().set_last_modified(dom_last_modified(&tm));
         }
-        window.r().init_browser_context(document.r(), frame_element.r());
 
+        // Create the root frame
+        page.set_frame(Some(Frame {
+            document: JS::from_rooted(document.r()),
+            window: JS::from_rooted(window.r()),
+        }));
 
-        {
-            // Create the root frame.
-            let mut frame = page.mut_frame();
-            *frame = Some(Frame {
-                document: JS::from_rooted(document.r()),
-                window: JS::from_rooted(window.r()),
-            });
-        }
-
-        if is_javascript {
-            let evalstr = load_data.url.non_relative_scheme_data().unwrap();
+        let is_javascript = incomplete.url.scheme.as_slice() == "javascript";
+        let parse_input = if is_javascript {
+            let evalstr = incomplete.url.non_relative_scheme_data().unwrap();
             let jsval = window.r().evaluate_js_on_global_with_result(evalstr);
             let strval = FromJSValConvertible::from_jsval(self.get_cx(), jsval,
                                                           StringificationBehavior::Empty);
-            parser_input = Some(HTMLInput::InputString(strval.unwrap_or("".to_owned())));
+            HTMLInput::InputString(strval.unwrap_or("".to_owned()))
+        } else {
+            HTMLInput::InputUrl(response)
         };
 
-        parse_html(document.r(), parser_input.unwrap(), &final_url);
+        parse_html(document.r(), parse_input, &final_url);
 
         document.r().set_ready_state(DocumentReadyState::Interactive);
-        self.compositor.borrow_mut().set_ready_state(pipeline_id, PerformingLayout);
+        self.compositor.borrow_mut().set_ready_state(incomplete.pipeline_id, PerformingLayout);
 
         // Kick off the initial reflow of the page.
         debug!("kicking off initial reflow of {:?}", final_url);
         document.r().content_changed(NodeCast::from_ref(document.r()),
                                      NodeDamage::OtherNodeDamage);
-        window.r().flush_layout(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery);
+        window.r().reflow(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery);
 
-        {
-            // No more reflow required
-            let mut page_url = page.mut_url();
-            *page_url = Some((final_url.clone(), false));
-        }
+        // No more reflow required
+        page.set_reflow_status(false);
 
         // https://html.spec.whatwg.org/multipage/#the-end step 4
         let addr: Trusted<Document> = Trusted::new(self.get_cx(), document.r(), self.chan.clone());
@@ -914,7 +1025,7 @@ impl ScriptTask {
         let handler = Box::new(DocumentProgressHandler::new(addr, DocumentProgressTask::Load));
         self.chan.send(ScriptMsg::RunnableMsg(handler)).unwrap();
 
-        *page.fragment_name.borrow_mut() = final_url.fragment.clone();
+        window.r().set_fragment_name(final_url.fragment.clone());
 
         let ConstellationChan(ref chan) = self.constellation_chan;
         chan.send(ConstellationMsg::LoadComplete).unwrap();
@@ -927,11 +1038,13 @@ impl ScriptTask {
                     title: document.r().Title(),
                     url: final_url
                 };
-                chan.send(DevtoolsControlMsg::NewGlobal(pipeline_id,
+                chan.send(DevtoolsControlMsg::NewGlobal(incomplete.pipeline_id,
                                                         self.devtools_sender.clone(),
                                                         page_info)).unwrap();
             }
         }
+
+        page_remover.neuter();
     }
 
     fn scroll_fragment_point(&self, pipeline_id: PipelineId, node: JSRef<Element>) {
@@ -948,11 +1061,10 @@ impl ScriptTask {
 
     /// Reflows non-incrementally.
     fn force_reflow(&self, page: &Page) {
-        page.dirty_all_nodes();
-        page.reflow(ReflowGoal::ForDisplay,
-                    self.control_chan.clone(),
-                    &mut **self.compositor.borrow_mut(),
-                    ReflowQueryType::NoQuery);
+        let document = page.document().root();
+        document.r().dirty_all_nodes();
+        let window = window_from_node(document.r()).root();
+        window.r().reflow(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery);
     }
 
     /// This is the main entry point for receiving and dispatching DOM events.
@@ -978,9 +1090,8 @@ impl ScriptTask {
                 for node in nodes.iter() {
                     let node_to_dirty = node::from_untrusted_node_address(self.js_runtime.ptr,
                                                                           *node).root();
-                    let page = get_page(&*self.page.borrow(), pipeline_id);
-                    let frame = page.frame();
-                    let document = frame.as_ref().unwrap().document.root();
+                    let page = get_page(&self.root_page(), pipeline_id);
+                    let document = page.document().root();
                     document.r().content_changed(node_to_dirty.r(),
                                                  NodeDamage::OtherNodeDamage);
                 }
@@ -989,18 +1100,16 @@ impl ScriptTask {
             }
 
             ClickEvent(_button, point) => {
-                let page = get_page(&*self.page.borrow(), pipeline_id);
-                let frame = page.frame();
-                let document = frame.as_ref().unwrap().document.root();
+                let page = get_page(&self.root_page(), pipeline_id);
+                let document = page.document().root();
                 document.r().handle_click_event(self.js_runtime.ptr, _button, point);
             }
 
             MouseDownEvent(..) => {}
             MouseUpEvent(..) => {}
             MouseMoveEvent(point) => {
-                let page = get_page(&*self.page.borrow(), pipeline_id);
-                let frame = page.frame();
-                let document = frame.as_ref().unwrap().document.root();
+                let page = get_page(&self.root_page(), pipeline_id);
+                let document = page.document().root();
                 let mouse_over_targets = &mut *self.mouse_over_targets.borrow_mut();
 
                 if document.r().handle_mouse_move_event(self.js_runtime.ptr, point, mouse_over_targets) {
@@ -1009,9 +1118,8 @@ impl ScriptTask {
             }
 
             KeyEvent(key, state, modifiers) => {
-                let page = get_page(&*self.page.borrow(), pipeline_id);
-                let frame = page.frame();
-                let document = frame.as_ref().unwrap().document.root();
+                let page = get_page(&self.root_page(), pipeline_id);
+                let document = page.document().root();
                 document.r().dispatch_key_event(
                     key, state, modifiers, &mut *self.compositor.borrow_mut());
             }
@@ -1028,8 +1136,9 @@ impl ScriptTask {
     /// The entry point for content to notify that a fragment url has been requested
     /// for the given pipeline.
     fn trigger_fragment(&self, pipeline_id: PipelineId, fragment: String) {
-        let page = get_page(&*self.page.borrow(), pipeline_id);
-        match page.find_fragment_node(fragment).root() {
+        let page = get_page(&self.root_page(), pipeline_id);
+        let document = page.document().root();
+        match document.r().find_fragment_node(fragment).root() {
             Some(node) => {
                 self.scroll_fragment_point(pipeline_id, node.r());
             }
@@ -1039,87 +1148,97 @@ impl ScriptTask {
 
 
     fn handle_resize_event(&self, pipeline_id: PipelineId, new_size: WindowSizeData) {
-        let window = {
-            let page = get_page(&*self.page.borrow(), pipeline_id);
-            page.window_size.set(new_size);
-
-            let frame = page.frame();
-            if frame.is_some() {
-                self.force_reflow(&*page);
-            }
-
-            let fragment_node =
-                page.fragment_name
-                    .borrow_mut()
-                    .take()
-                    .and_then(|name| page.find_fragment_node(name))
-                    .root();
-            match fragment_node {
-                Some(node) => self.scroll_fragment_point(pipeline_id, node.r()),
-                None => {}
-            }
+        let page = get_page(&self.root_page(), pipeline_id);
+        let window = page.window().root();
+        window.r().set_window_size(new_size);
+        self.force_reflow(&*page);
+
+        let document = page.document().root();
+        let fragment_node = window.r().steal_fragment_name()
+                                      .and_then(|name| document.r().find_fragment_node(name))
+                                      .root();
+        match fragment_node {
+            Some(node) => self.scroll_fragment_point(pipeline_id, node.r()),
+            None => {}
+        }
 
-            frame.as_ref().map(|frame| Temporary::new(frame.window.clone()))
-        };
+        // http://dev.w3.org/csswg/cssom-view/#resizing-viewports
+        // https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#event-type-resize
+        let uievent = UIEvent::new(window.r(),
+                                   "resize".to_owned(), false,
+                                   false, Some(window.r()),
+                                   0i32).root();
+        let event: JSRef<Event> = EventCast::from_ref(uievent.r());
 
-        match window.root() {
-            Some(window) => {
-                // http://dev.w3.org/csswg/cssom-view/#resizing-viewports
-                // https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#event-type-resize
-                let uievent = UIEvent::new(window.r(),
-                                           "resize".to_owned(), false,
-                                           false, Some(window.r()),
-                                           0i32).root();
-                let event: JSRef<Event> = EventCast::from_ref(uievent.r());
-
-                let wintarget: JSRef<EventTarget> = EventTargetCast::from_ref(window.r());
-                event.fire(wintarget);
-            }
-            None => ()
-        }
+        let wintarget: JSRef<EventTarget> = EventTargetCast::from_ref(window.r());
+        event.fire(wintarget);
     }
 
     fn handle_reflow_event(&self, pipeline_id: PipelineId) {
         debug!("script got reflow event");
-        let page = get_page(&*self.page.borrow(), pipeline_id);
-        let frame = page.frame();
-        if frame.is_some() {
-            self.force_reflow(&*page);
-        }
+        let page = get_page(&self.root_page(), pipeline_id);
+        self.force_reflow(&*page);
+    }
+
+    /// Initiate a non-blocking fetch for a specified resource. Stores the InProgressLoad
+    /// argument until a notification is received that the fetch is complete.
+    fn start_page_load(&self, incomplete: InProgressLoad, mut load_data: LoadData) {
+        let id = incomplete.pipeline_id.clone();
+        let subpage = incomplete.subpage_id.clone().map(|p| p.1);
+
+        let script_chan = self.chan.clone();
+        let resource_task = self.resource_task.clone();
+
+        spawn_named(format!("fetch for {:?}", load_data.url), move || {
+            if load_data.url.scheme.as_slice() == "javascript" {
+                load_data.url = Url::parse("about:blank").unwrap();
+            }
+
+            let (input_chan, input_port) = channel();
+            resource_task.send(ControlMsg::Load(NetLoadData {
+                url: load_data.url,
+                method: load_data.method,
+                headers: Headers::new(),
+                preserved_headers: load_data.headers,
+                data: load_data.data,
+                cors: None,
+                consumer: input_chan,
+            })).unwrap();
+
+            let load_response = input_port.recv().unwrap();
+            script_chan.send(ScriptMsg::PageFetchComplete(id, subpage, load_response)).unwrap();
+        });
+
+        self.incomplete_loads.borrow_mut().push(incomplete);
     }
 }
 
 /// Shuts down layout for the given page tree.
-fn shut_down_layout(page_tree: &Rc<Page>, rt: *mut JSRuntime, exit_type: PipelineExitType) {
+fn shut_down_layout(page_tree: &Rc<Page>, exit_type: PipelineExitType) {
+    let mut channels = vec!();
+
     for page in page_tree.iter() {
         // Tell the layout task to begin shutting down, and wait until it
         // processed this message.
         let (response_chan, response_port) = channel();
-        let LayoutChan(ref chan) = page.layout_chan;
+        let window = page.window().root();
+        let LayoutChan(chan) = window.r().layout_chan();
         if chan.send(layout_interface::Msg::PrepareToExit(response_chan)).is_ok() {
-          response_port.recv().unwrap();
+            channels.push(chan);
+            response_port.recv().unwrap();
         }
     }
 
-    // Remove our references to the DOM objects in this page tree.
-    for page in page_tree.iter() {
-        *page.mut_frame() = None;
-    }
-
-    // Drop our references to the JSContext, potentially triggering a GC.
+    // Drop our references to the JSContext and DOM objects.
     for page in page_tree.iter() {
-        *page.mut_js_info() = None;
-    }
-
-    // Force a GC to make sure that our DOM reflectors are released before we tell
-    // layout to exit.
-    unsafe {
-        JS_GC(rt);
+        let window = page.window().root();
+        window.r().clear_js_context();
+        // Sever the connection between the global and the DOM tree
+        page.set_frame(None);
     }
 
     // Destroy the layout task. If there were node leaks, layout will now crash safely.
-    for page in page_tree.iter() {
-        let LayoutChan(ref chan) = page.layout_chan;
+    for chan in channels.into_iter() {
         chan.send(layout_interface::Msg::ExitNow(exit_type)).ok();
     }
 }