Introduce abstractions for global scopes.

Part of #2811.

41 files changed, 227 insertions, 112 deletions

diff --git a/src/components/script/dom/attr.rs b/src/components/script/dom/attr.rs
index 0a2fba8893e..3ff369bbba8 100644
--- a/src/components/script/dom/attr.rs
+++ b/src/components/script/dom/attr.rs
@@ -4,6 +4,7 @@
 
 use dom::bindings::codegen::Bindings::AttrBinding;
 use dom::bindings::codegen::InheritTypes::NodeCast;
+use dom::bindings::global::Window;
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::trace::Traceable;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
@@ -94,7 +95,7 @@ impl Attr {
                name: DOMString, namespace: Namespace,
                prefix: Option<DOMString>, owner: &JSRef<Element>) -> Temporary<Attr> {
         let attr = Attr::new_inherited(local_name, value, name, namespace, prefix, owner);
-        reflect_dom_object(box attr, window, AttrBinding::Wrap)
+        reflect_dom_object(box attr, &Window(*window), AttrBinding::Wrap)
     }
 
     pub fn set_value(&self, set_type: AttrSettingType, value: AttrValue) {
diff --git a/src/components/script/dom/attrlist.rs b/src/components/script/dom/attrlist.rs
index 1ccae05b53a..8f4c309ab54 100644
--- a/src/components/script/dom/attrlist.rs
+++ b/src/components/script/dom/attrlist.rs
@@ -4,6 +4,7 @@
 
 use dom::attr::Attr;
 use dom::bindings::codegen::Bindings::AttrListBinding;
+use dom::bindings::global::Window;
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::element::Element;
@@ -25,7 +26,7 @@ impl AttrList {
 
     pub fn new(window: &JSRef<Window>, elem: &JSRef<Element>) -> Temporary<AttrList> {
         reflect_dom_object(box AttrList::new_inherited(elem),
-                           window, AttrListBinding::Wrap)
+                           &Window(*window), AttrListBinding::Wrap)
     }
 }
 
diff --git a/src/components/script/dom/bindings/callback.rs b/src/components/script/dom/bindings/callback.rs
index 3cfb3257e5b..865bd9d3ef7 100644
--- a/src/components/script/dom/bindings/callback.rs
+++ b/src/components/script/dom/bindings/callback.rs
@@ -115,7 +115,7 @@ pub struct CallSetup {
 impl CallSetup {
     pub fn new<T: CallbackContainer>(callback: &T, handling: ExceptionHandling) -> CallSetup {
         let global = global_object_for_js_object(callback.callback()).root();
-        let cx = global.deref().get_cx();
+        let cx = global.root_ref().get_cx();
         CallSetup {
             cx: cx,
             _handling: handling
diff --git a/src/components/script/dom/bindings/codegen/CodegenRust.py b/src/components/script/dom/bindings/codegen/CodegenRust.py
index 43c5ac3f169..525c77b6419 100644
--- a/src/components/script/dom/bindings/codegen/CodegenRust.py
+++ b/src/components/script/dom/bindings/codegen/CodegenRust.py
@@ -1792,7 +1792,7 @@ class CGWrapMethod(CGAbstractMethod):
     def __init__(self, descriptor):
         assert descriptor.interface.hasInterfacePrototypeObject()
         if not descriptor.createGlobal:
-            args = [Argument('*mut JSContext', 'aCx'), Argument('&JSRef<Window>', 'aScope'),
+            args = [Argument('*mut JSContext', 'aCx'), Argument('&GlobalRef', 'aScope'),
                     Argument("Box<%s>" % descriptor.concreteType, 'aObject', mutable=True)]
         else:
             args = [Argument('*mut JSContext', 'aCx'),
@@ -2185,7 +2185,7 @@ class CGCallGenerator(CGThing):
                 "    Ok(result) => result,\n"
                 "    Err(e) => {\n"
                 "%s"
-                "        throw_dom_exception(cx, &*global, e);\n"
+                "        throw_dom_exception(cx, &global.root_ref(), e);\n"
                 "        return%s;\n"
                 "    },\n"
                 "};\n" % (glob, errorResult)))
@@ -4405,6 +4405,7 @@ class CGBindingRoot(CGThing):
             'js::rust::with_compartment',
             'dom::types::*',
             'dom::bindings',
+            'dom::bindings::global::GlobalRef',
             'dom::bindings::js::{JS, JSRef, Root, RootedReference, Temporary}',
             'dom::bindings::js::{OptionalRootable, OptionalRootedRootable, ResultRootable}',
             'dom::bindings::js::{OptionalRootedReference, OptionalOptionalRootedRootable}',
diff --git a/src/components/script/dom/bindings/error.rs b/src/components/script/dom/bindings/error.rs
index 7b021bbae2d..f204dc5859a 100644
--- a/src/components/script/dom/bindings/error.rs
+++ b/src/components/script/dom/bindings/error.rs
@@ -3,9 +3,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::conversions::ToJSValConvertible;
-use dom::bindings::js::JSRef;
+use dom::bindings::global::GlobalRef;
 use dom::domexception::DOMException;
-use dom::window::Window;
 
 use js::jsapi::{JSContext, JSBool};
 use js::jsapi::{JS_IsExceptionPending, JS_SetPendingException};
@@ -37,7 +36,7 @@ pub type Fallible<T> = Result<T, Error>;
 
 pub type ErrorResult = Fallible<()>;
 
-pub fn throw_dom_exception(cx: *mut JSContext, global: &JSRef<Window>,
+pub fn throw_dom_exception(cx: *mut JSContext, global: &GlobalRef,
                            result: Error) {
     assert!(unsafe { JS_IsExceptionPending(cx) } == 0);
     let exception = DOMException::new_from_error(global, result).root();
diff --git a/src/components/script/dom/bindings/global.rs b/src/components/script/dom/bindings/global.rs
new file mode 100644
index 00000000000..cf69b82517b
--- /dev/null
+++ b/src/components/script/dom/bindings/global.rs
@@ -0,0 +1,82 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+//! Abstractions for global scopes.
+
+use dom::bindings::js::{JS, JSRef, Root};
+use dom::bindings::utils::{Reflectable, Reflector};
+use dom::window::Window;
+use page::Page;
+use script_task::ScriptChan;
+
+use js::jsapi::JSContext;
+
+use url::Url;
+
+pub enum GlobalRef<'a> {
+    Window(JSRef<'a, Window>),
+}
+
+pub enum GlobalRoot<'a, 'b> {
+    WindowRoot(Root<'a, 'b, Window>),
+}
+
+#[deriving(Encodable)]
+pub enum GlobalField {
+    WindowField(JS<Window>),
+}
+
+impl<'a> GlobalRef<'a> {
+    pub fn get_cx(&self) -> *mut JSContext {
+        match *self {
+            Window(ref window) => window.get_cx(),
+        }
+    }
+
+    pub fn as_window<'b>(&'b self) -> &'b JSRef<'b, Window> {
+        match *self {
+            Window(ref window) => window,
+        }
+    }
+
+    pub fn page<'b>(&'b self) -> &'b Page {
+        self.as_window().page()
+    }
+    pub fn get_url(&self) -> Url {
+        self.as_window().get_url()
+    }
+    pub fn script_chan<'b>(&'b self) -> &'b ScriptChan {
+        &self.as_window().script_chan
+    }
+}
+
+impl<'a> Reflectable for GlobalRef<'a> {
+    fn reflector<'b>(&'b self) -> &'b Reflector {
+        match *self {
+            Window(ref window) => window.reflector(),
+        }
+    }
+}
+
+impl<'a, 'b> GlobalRoot<'a, 'b> {
+    pub fn root_ref<'c>(&'c self) -> GlobalRef<'c> {
+        match *self {
+            WindowRoot(ref window) => Window(window.root_ref()),
+        }
+    }
+}
+
+impl GlobalField {
+    pub fn from_rooted(global: &GlobalRef) -> GlobalField {
+        match *global {
+            Window(ref window) => WindowField(JS::from_rooted(window)),
+        }
+    }
+
+    pub fn root(&self) -> GlobalRoot {
+        match *self {
+            WindowField(ref window) => WindowRoot(window.root()),
+        }
+    }
+}
diff --git a/src/components/script/dom/bindings/utils.rs b/src/components/script/dom/bindings/utils.rs
index 4200cec0b20..628debb24ea 100644
--- a/src/components/script/dom/bindings/utils.rs
+++ b/src/components/script/dom/bindings/utils.rs
@@ -5,7 +5,8 @@
 use dom::bindings::codegen::PrototypeList;
 use dom::bindings::codegen::PrototypeList::MAX_PROTO_CHAIN_LENGTH;
 use dom::bindings::conversions::{FromJSValConvertible, IDLInterface};
-use dom::bindings::js::{JS, JSRef, Temporary, Root};
+use dom::bindings::global::{GlobalRef, GlobalField, WindowField};
+use dom::bindings::js::{JS, Temporary, Root};
 use dom::bindings::trace::Untraceable;
 use dom::browsercontext;
 use dom::window;
@@ -373,8 +374,8 @@ pub trait Reflectable {
 
 pub fn reflect_dom_object<T: Reflectable>
         (obj:     Box<T>,
-         global:  &JSRef<window::Window>,
-         wrap_fn: extern "Rust" fn(*mut JSContext, &JSRef<window::Window>, Box<T>) -> Temporary<T>)
+         global:  &GlobalRef,
+         wrap_fn: extern "Rust" fn(*mut JSContext, &GlobalRef, Box<T>) -> Temporary<T>)
          -> Temporary<T> {
     wrap_fn(global.get_cx(), global, obj)
 }
@@ -580,19 +581,23 @@ pub extern fn outerize_global(_cx: *mut JSContext, obj: JSHandleObject) -> *mut
 }
 
 /// Returns the global object of the realm that the given JS object was created in.
-pub fn global_object_for_js_object(obj: *mut JSObject) -> JS<window::Window> {
+pub fn global_object_for_js_object(obj: *mut JSObject) -> GlobalField {
     unsafe {
         let global = GetGlobalForObjectCrossCompartment(obj);
         let clasp = JS_GetClass(global);
         assert!(((*clasp).flags & (JSCLASS_IS_DOMJSCLASS | JSCLASS_IS_GLOBAL)) != 0);
-        FromJSValConvertible::from_jsval(ptr::mut_null(), ObjectOrNullValue(global), ())
-            .ok().expect("found DOM global that doesn't unwrap to Window")
+        match FromJSValConvertible::from_jsval(ptr::mut_null(), ObjectOrNullValue(global), ()) {
+            Ok(window) => return WindowField(window),
+            Err(_) => (),
+        }
+
+        fail!("found DOM global that doesn't unwrap to Window")
     }
 }
 
 fn cx_for_dom_reflector(obj: *mut JSObject) -> *mut JSContext {
     let global = global_object_for_js_object(obj).root();
-    global.get_cx()
+    global.root_ref().get_cx()
 }
 
 pub fn cx_for_dom_object<T: Reflectable>(obj: &T) -> *mut JSContext {
diff --git a/src/components/script/dom/blob.rs b/src/components/script/dom/blob.rs
index 6128b1c8ce2..f78c3e2f5f5 100644
--- a/src/components/script/dom/blob.rs
+++ b/src/components/script/dom/blob.rs
@@ -3,11 +3,11 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::InheritTypes::FileDerived;
-use dom::bindings::js::{JS, JSRef, Temporary};
+use dom::bindings::global::{GlobalRef, GlobalField};
+use dom::bindings::js::Temporary;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::error::Fallible;
 use dom::bindings::codegen::Bindings::BlobBinding;
-use dom::window::Window;
 
 #[deriving(Encodable)]
 pub enum BlobType {
@@ -18,26 +18,26 @@ pub enum BlobType {
 #[deriving(Encodable)]
 pub struct Blob {
     reflector_: Reflector,
-    global: JS<Window>,
+    global: GlobalField,
     type_: BlobType
 }
 
 impl Blob {
-    pub fn new_inherited(global: &JSRef<Window>) -> Blob {
+    pub fn new_inherited(global: &GlobalRef) -> Blob {
         Blob {
             reflector_: Reflector::new(),
-            global: JS::from_rooted(global),
+            global: GlobalField::from_rooted(global),
             type_: BlobTypeId
         }
     }
 
-    pub fn new(global: &JSRef<Window>) -> Temporary<Blob> {
+    pub fn new(global: &GlobalRef) -> Temporary<Blob> {
         reflect_dom_object(box Blob::new_inherited(global),
                            global,
                            BlobBinding::Wrap)
     }
 
-    pub fn Constructor(global: &JSRef<Window>) -> Fallible<Temporary<Blob>> {
+    pub fn Constructor(global: &GlobalRef) -> Fallible<Temporary<Blob>> {
         Ok(Blob::new(global))
     }
 }
diff --git a/src/components/script/dom/clientrect.rs b/src/components/script/dom/clientrect.rs
index 8ab22663136..cf6eaee67fc 100644
--- a/src/components/script/dom/clientrect.rs
+++ b/src/components/script/dom/clientrect.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::ClientRectBinding;
+use dom::bindings::global::Window;
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::window::Window;
@@ -36,7 +37,7 @@ impl ClientRect {
                top: Au, bottom: Au,
                left: Au, right: Au) -> Temporary<ClientRect> {
         let rect = ClientRect::new_inherited(window, top, bottom, left, right);
-        reflect_dom_object(box rect, window, ClientRectBinding::Wrap)
+        reflect_dom_object(box rect, &Window(*window), ClientRectBinding::Wrap)
     }
 }
 
diff --git a/src/components/script/dom/clientrectlist.rs b/src/components/script/dom/clientrectlist.rs
index eccca831a03..ded917213d8 100644
--- a/src/components/script/dom/clientrectlist.rs
+++ b/src/components/script/dom/clientrectlist.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::ClientRectListBinding;
+use dom::bindings::global::Window;
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::clientrect::ClientRect;
@@ -29,7 +30,7 @@ impl ClientRectList {
     pub fn new(window: &JSRef<Window>,
                rects: Vec<JSRef<ClientRect>>) -> Temporary<ClientRectList> {
         reflect_dom_object(box ClientRectList::new_inherited(window, rects),
-                           window, ClientRectListBinding::Wrap)
+                           &Window(*window), ClientRectListBinding::Wrap)
     }
 }
 
diff --git a/src/components/script/dom/comment.rs b/src/components/script/dom/comment.rs
index 3bc9344b4eb..fe200cf9d48 100644
--- a/src/components/script/dom/comment.rs
+++ b/src/components/script/dom/comment.rs
@@ -5,13 +5,14 @@
 use dom::bindings::codegen::InheritTypes::CommentDerived;
 use dom::bindings::codegen::Bindings::CommentBinding;
 use dom::bindings::error::Fallible;
+use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::characterdata::CharacterData;
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, NodeTargetTypeId};
 use dom::node::{CommentNodeTypeId, Node};
-use dom::window::{Window, WindowMethods};
+use dom::window::WindowMethods;
 use servo_util::str::DOMString;
 
 /// An HTML comment.
@@ -38,8 +39,8 @@ impl Comment {
         Node::reflect_node(box node, document, CommentBinding::Wrap)
     }
 
-    pub fn Constructor(global: &JSRef<Window>, data: DOMString) -> Fallible<Temporary<Comment>> {
-        let document = global.Document().root();
+    pub fn Constructor(global: &GlobalRef, data: DOMString) -> Fallible<Temporary<Comment>> {
+        let document = global.as_window().Document().root();
         Ok(Comment::new(data, &*document))
     }
 }
diff --git a/src/components/script/dom/console.rs b/src/components/script/dom/console.rs
index 52e108ea649..341ab20f8be 100644
--- a/src/components/script/dom/console.rs
+++ b/src/components/script/dom/console.rs
@@ -3,9 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::ConsoleBinding;
+use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::window::Window;
 use servo_util::str::DOMString;
 
 #[deriving(Encodable)]
@@ -20,7 +20,7 @@ impl Console {
         }
     }
 
-    pub fn new(global: &JSRef<Window>) -> Temporary<Console> {
+    pub fn new(global: &GlobalRef) -> Temporary<Console> {
         reflect_dom_object(box Console::new_inherited(), global, ConsoleBinding::Wrap)
     }
 }
diff --git a/src/components/script/dom/customevent.rs b/src/components/script/dom/customevent.rs
index 965decf2e55..5485391ec0c 100644
--- a/src/components/script/dom/customevent.rs
+++ b/src/components/script/dom/customevent.rs
@@ -5,11 +5,11 @@
 use dom::bindings::codegen::Bindings::CustomEventBinding;
 use dom::bindings::codegen::InheritTypes::{EventCast, CustomEventDerived};
 use dom::bindings::error::Fallible;
+use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::trace::Traceable;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::event::{Event, EventMethods, EventTypeId, CustomEventTypeId};
-use dom::window::Window;
 use js::jsapi::JSContext;
 use js::jsval::{JSVal, NullValue};
 use servo_util::str::DOMString;
@@ -43,17 +43,17 @@ impl CustomEvent {
         }
     }
 
-    pub fn new_uninitialized(global: &JSRef<Window>) -> Temporary<CustomEvent> {
+    pub fn new_uninitialized(global: &GlobalRef) -> Temporary<CustomEvent> {
         reflect_dom_object(box CustomEvent::new_inherited(CustomEventTypeId),
                            global,
                            CustomEventBinding::Wrap)
     }
-    pub fn new(global: &JSRef<Window>, type_: DOMString, bubbles: bool, cancelable: bool, detail: JSVal) -> Temporary<CustomEvent> {
+    pub fn new(global: &GlobalRef, type_: DOMString, bubbles: bool, cancelable: bool, detail: JSVal) -> Temporary<CustomEvent> {
         let ev = CustomEvent::new_uninitialized(global).root();
         ev.deref().InitCustomEvent(global.get_cx(), type_, bubbles, cancelable, detail);
         Temporary::from_rooted(&*ev)
     }
-    pub fn Constructor(global: &JSRef<Window>,
+    pub fn Constructor(global: &GlobalRef,
                        type_: DOMString,
                        init: &CustomEventBinding::CustomEventInit) -> Fallible<Temporary<CustomEvent>>{
         Ok(CustomEvent::new(global, type_, init.parent.bubbles, init.parent.cancelable, init.detail))
diff --git a/src/components/script/dom/document.rs b/src/components/script/dom/document.rs
index 499165e5a26..bee7494ed73 100644
--- a/src/components/script/dom/document.rs
+++ b/src/components/script/dom/document.rs
@@ -10,6 +10,7 @@ use dom::bindings::codegen::InheritTypes::{DocumentTypeCast, HTMLHtmlElementCast
 use dom::bindings::codegen::InheritTypes::EventTargetCast;
 use dom::bindings::error::{ErrorResult, Fallible, NotSupported, InvalidCharacter};
 use dom::bindings::error::{HierarchyRequest, NamespaceError};
+use dom::bindings::global::{GlobalRef, Window};
 use dom::bindings::js::{JS, JSRef, Temporary, OptionalSettable, TemporaryPushable};
 use dom::bindings::js::OptionalRootable;
 use dom::bindings::trace::{Traceable, Untraceable};
@@ -222,13 +223,13 @@ impl Document {
     }
 
     // http://dom.spec.whatwg.org/#dom-document
-    pub fn Constructor(global: &JSRef<Window>) -> Fallible<Temporary<Document>> {
-        Ok(Document::new(global, None, NonHTMLDocument, None))
+    pub fn Constructor(global: &GlobalRef) -> Fallible<Temporary<Document>> {
+        Ok(Document::new(global.as_window(), None, NonHTMLDocument, None))
     }
 
     pub fn new(window: &JSRef<Window>, url: Option<Url>, doctype: IsHTMLDocument, content_type: Option<DOMString>) -> Temporary<Document> {
         let document = Document::new_inherited(window, url, doctype, content_type);
-        let document = reflect_dom_object(box document, window,
+        let document = reflect_dom_object(box document, &Window(*window),
                                           DocumentBinding::Wrap).root();
 
         let node: &JSRef<Node> = NodeCast::from_ref(&*document);
@@ -540,8 +541,8 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
             // FIXME: Implement CustomEvent (http://dom.spec.whatwg.org/#customevent)
             "uievents" | "uievent" => Ok(EventCast::from_temporary(UIEvent::new_uninitialized(&*window))),
             "mouseevents" | "mouseevent" => Ok(EventCast::from_temporary(MouseEvent::new_uninitialized(&*window))),
-            "customevent" => Ok(EventCast::from_temporary(CustomEvent::new_uninitialized(&*window))),
-            "htmlevents" | "events" | "event" => Ok(Event::new_uninitialized(&*window)),
+            "customevent" => Ok(EventCast::from_temporary(CustomEvent::new_uninitialized(&Window(*window)))),
+            "htmlevents" | "events" | "event" => Ok(Event::new_uninitialized(&Window(*window))),
             _ => Err(NotSupported)
         }
     }
diff --git a/src/components/script/dom/documentfragment.rs b/src/components/script/dom/documentfragment.rs
index 0af2c79a0b1..c840815f5ca 100644
--- a/src/components/script/dom/documentfragment.rs
+++ b/src/components/script/dom/documentfragment.rs
@@ -6,6 +6,7 @@ use dom::bindings::codegen::InheritTypes::{DocumentFragmentDerived, NodeCast};
 use dom::bindings::codegen::Bindings::DocumentFragmentBinding;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::error::Fallible;
+use dom::bindings::global::GlobalRef;
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::document::Document;
 use dom::element::Element;
@@ -13,7 +14,7 @@ use dom::eventtarget::{EventTarget, NodeTargetTypeId};
 use dom::htmlcollection::HTMLCollection;
 use dom::node::{DocumentFragmentNodeTypeId, Node, NodeHelpers, window_from_node};
 use dom::nodelist::NodeList;
-use dom::window::{Window, WindowMethods};
+use dom::window::WindowMethods;
 use servo_util::str::DOMString;
 
 #[deriving(Encodable)]
@@ -40,8 +41,8 @@ impl DocumentFragment {
         Node::reflect_node(box node, document, DocumentFragmentBinding::Wrap)
     }
 
-    pub fn Constructor(global: &JSRef<Window>) -> Fallible<Temporary<DocumentFragment>> {
-        let document = global.Document();
+    pub fn Constructor(global: &GlobalRef) -> Fallible<Temporary<DocumentFragment>> {
+        let document = global.as_window().Document();
         let document = document.root();
 
         Ok(DocumentFragment::new(&document.root_ref()))
diff --git a/src/components/script/dom/domexception.rs b/src/components/script/dom/domexception.rs
index 297f8011781..e2b771742b5 100644
--- a/src/components/script/dom/domexception.rs
+++ b/src/components/script/dom/domexception.rs
@@ -6,9 +6,9 @@ use dom::bindings::codegen::Bindings::DOMExceptionBinding;
 use dom::bindings::codegen::Bindings::DOMExceptionBinding::DOMExceptionConstants;
 use dom::bindings::error;
 use dom::bindings::error::Error;
+use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::window::Window;
 use servo_util::str::DOMString;
 
 #[repr(uint)]
@@ -72,11 +72,11 @@ impl DOMException {
         }
     }
 
-    pub fn new(global: &JSRef<Window>, code: DOMErrorName) -> Temporary<DOMException> {
+    pub fn new(global: &GlobalRef, code: DOMErrorName) -> Temporary<DOMException> {
         reflect_dom_object(box DOMException::new_inherited(code), global, DOMExceptionBinding::Wrap)
     }
 
-    pub fn new_from_error(global: &JSRef<Window>, code: Error) -> Temporary<DOMException> {
+    pub fn new_from_error(global: &GlobalRef, code: Error) -> Temporary<DOMException> {
         DOMException::new(global, DOMErrorName::from_error(code))
     }
 }
diff --git a/src/components/script/dom/domimplementation.rs b/src/components/script/dom/domimplementation.rs
index afdd89ffd6a..6603488e106 100644
--- a/src/components/script/dom/domimplementation.rs
+++ b/src/components/script/dom/domimplementation.rs
@@ -5,6 +5,7 @@
 use dom::bindings::codegen::Bindings::DOMImplementationBinding;
 use dom::bindings::codegen::InheritTypes::NodeCast;
 use dom::bindings::error::{Fallible, InvalidCharacter, NamespaceError};
+use dom::bindings::global::Window;
 use dom::bindings::js::{JS, JSRef, Root, Temporary, OptionalRootable};
 use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object};
 use dom::bindings::utils::{QName, Name, InvalidXMLName, xml_name_type};
@@ -35,7 +36,7 @@ impl DOMImplementation {
     pub fn new(document: &JSRef<Document>) -> Temporary<DOMImplementation> {
         let window = document.window.root();
         reflect_dom_object(box DOMImplementation::new_inherited(document),
-                           &*window,
+                           &Window(*window),
                            DOMImplementationBinding::Wrap)
     }
 }
diff --git a/src/components/script/dom/domparser.rs b/src/components/script/dom/domparser.rs
index 014d1373a0b..44f34bc5d75 100644
--- a/src/components/script/dom/domparser.rs
+++ b/src/components/script/dom/domparser.rs
@@ -5,6 +5,7 @@
 use dom::bindings::codegen::Bindings::DOMParserBinding;
 use dom::bindings::codegen::Bindings::DOMParserBinding::SupportedTypeValues::{Text_html, Text_xml};
 use dom::bindings::error::{Fallible, FailureUnknown};
+use dom::bindings::global::{GlobalRef, Window};
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object};
 use dom::document::{Document, HTMLDocument, NonHTMLDocument};
@@ -26,12 +27,12 @@ impl DOMParser {
     }
 
     pub fn new(window: &JSRef<Window>) -> Temporary<DOMParser> {
-        reflect_dom_object(box DOMParser::new_inherited(window), window,
+        reflect_dom_object(box DOMParser::new_inherited(window), &Window(*window),
                            DOMParserBinding::Wrap)
     }
 
-    pub fn Constructor(global: &JSRef<Window>) -> Fallible<Temporary<DOMParser>> {
-        Ok(DOMParser::new(global))
+    pub fn Constructor(global: &GlobalRef) -> Fallible<Temporary<DOMParser>> {
+        Ok(DOMParser::new(global.as_window()))
     }
 }
 
diff --git a/src/components/script/dom/domtokenlist.rs b/src/components/script/dom/domtokenlist.rs
index a02ad1a59e3..ebbbd73e3ba 100644
--- a/src/components/script/dom/domtokenlist.rs
+++ b/src/components/script/dom/domtokenlist.rs
@@ -4,6 +4,7 @@
 
 use dom::attr::{Attr, TokenListAttrValue};
 use dom::bindings::codegen::Bindings::DOMTokenListBinding;
+use dom::bindings::global::Window;
 use dom::bindings::js::{JS, JSRef, Temporary, OptionalRootable};
 use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object};
 use dom::element::{Element, AttributeHandlers};
@@ -33,7 +34,7 @@ impl DOMTokenList {
                local_name: &'static str) -> Temporary<DOMTokenList> {
         let window = window_from_node(element).root();
         reflect_dom_object(box DOMTokenList::new_inherited(element, local_name),
-                           &*window, DOMTokenListBinding::Wrap)
+                           &Window(*window), DOMTokenListBinding::Wrap)
     }
 }
 
diff --git a/src/components/script/dom/event.rs b/src/components/script/dom/event.rs
index 7ede8ca21c8..e68f04f2821 100644
--- a/src/components/script/dom/event.rs
+++ b/src/components/script/dom/event.rs
@@ -5,11 +5,11 @@
 use dom::bindings::codegen::Bindings::EventBinding;
 use dom::bindings::codegen::Bindings::EventBinding::EventConstants;
 use dom::bindings::error::Fallible;
+use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::trace::Traceable;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::eventtarget::EventTarget;
-use dom::window::Window;
 use servo_msg::constellation_msg::WindowSizeData;
 use servo_util::str::DOMString;
 use std::cell::{Cell, RefCell};
@@ -85,13 +85,13 @@ impl Event {
         }
     }
 
-    pub fn new_uninitialized(global: &JSRef<Window>) -> Temporary<Event> {
+    pub fn new_uninitialized(global: &GlobalRef) -> Temporary<Event> {
         reflect_dom_object(box Event::new_inherited(HTMLEventTypeId),
                            global,
                            EventBinding::Wrap)
     }
 
-    pub fn new(global: &JSRef<Window>,
+    pub fn new(global: &GlobalRef,
                type_: DOMString,
                can_bubble: bool,
                cancelable: bool) -> Temporary<Event> {
@@ -100,7 +100,7 @@ impl Event {
         Temporary::from_rooted(&*event)
     }
 
-    pub fn Constructor(global: &JSRef<Window>,
+    pub fn Constructor(global: &GlobalRef,
                        type_: DOMString,
                        init: &EventBinding::EventInit) -> Fallible<Temporary<Event>> {
         Ok(Event::new(global, type_, init.bubbles, init.cancelable))
diff --git a/src/components/script/dom/file.rs b/src/components/script/dom/file.rs
index ea2610c1f2f..4cf46e013af 100644
--- a/src/components/script/dom/file.rs
+++ b/src/components/script/dom/file.rs
@@ -3,10 +3,10 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::FileBinding;
+use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::blob::{Blob, BlobType, FileTypeId};
-use dom::window::Window;
 use servo_util::str::DOMString;
 
 #[deriving(Encodable)]
@@ -17,7 +17,7 @@ pub struct File {
 }
 
 impl File {
-    pub fn new_inherited(global: &JSRef<Window>, _file_bits: &JSRef<Blob>, name: DOMString) -> File {
+    pub fn new_inherited(global: &GlobalRef, _file_bits: &JSRef<Blob>, name: DOMString) -> File {
         File {
             blob: Blob::new_inherited(global),
             name: name,
@@ -27,7 +27,7 @@ impl File {
         // the relevant subfields of file_bits should be copied over
     }
 
-    pub fn new(global: &JSRef<Window>, file_bits: &JSRef<Blob>, name: DOMString) -> Temporary<File> {
+    pub fn new(global: &GlobalRef, file_bits: &JSRef<Blob>, name: DOMString) -> Temporary<File> {
         reflect_dom_object(box File::new_inherited(global, file_bits, name),
                            global,
                            FileBinding::Wrap)
diff --git a/src/components/script/dom/formdata.rs b/src/components/script/dom/formdata.rs
index a3a9d7d7fa9..8f5c2cfcd19 100644
--- a/src/components/script/dom/formdata.rs
+++ b/src/components/script/dom/formdata.rs
@@ -6,6 +6,7 @@ use dom::bindings::codegen::Bindings::FormDataBinding;
 use dom::bindings::codegen::InheritTypes::FileCast;
 use dom::bindings::codegen::UnionTypes::FileOrString::{FileOrString, eFile, eString};
 use dom::bindings::error::{Fallible};
+use dom::bindings::global::{GlobalRef, Window};
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::trace::Traceable;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
@@ -42,11 +43,12 @@ impl FormData {
     }
 
     pub fn new(form: Option<JSRef<HTMLFormElement>>, window: &JSRef<Window>) -> Temporary<FormData> {
-        reflect_dom_object(box FormData::new_inherited(form, window), window, FormDataBinding::Wrap)
+        reflect_dom_object(box FormData::new_inherited(form, window),
+                           &Window(*window), FormDataBinding::Wrap)
     }
 
-    pub fn Constructor(global: &JSRef<Window>, form: Option<JSRef<HTMLFormElement>>) -> Fallible<Temporary<FormData>> {
-        Ok(FormData::new(form, global))
+    pub fn Constructor(global: &GlobalRef, form: Option<JSRef<HTMLFormElement>>) -> Fallible<Temporary<FormData>> {
+        Ok(FormData::new(form, global.as_window()))
     }
 }
 
@@ -118,6 +120,6 @@ impl PrivateFormDataHelpers for FormData {
         let window = self.window.root();
         let f: Option<&JSRef<File>> = FileCast::to_ref(value);
         let name = filename.unwrap_or(f.map(|inner| inner.name.clone()).unwrap_or("blob".to_string()));
-        File::new(&*window, value, name)
+        File::new(&Window(*window), value, name)
     }
 }
diff --git a/src/components/script/dom/htmlcollection.rs b/src/components/script/dom/htmlcollection.rs
index 2438d745518..ed47802324b 100644
--- a/src/components/script/dom/htmlcollection.rs
+++ b/src/components/script/dom/htmlcollection.rs
@@ -4,6 +4,7 @@
 
 use dom::bindings::codegen::InheritTypes::{ElementCast, NodeCast};
 use dom::bindings::codegen::Bindings::HTMLCollectionBinding;
+use dom::bindings::global::Window;
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::element::{Element, AttributeHandlers};
@@ -46,7 +47,7 @@ impl HTMLCollection {
 
     pub fn new(window: &JSRef<Window>, collection: CollectionTypeId) -> Temporary<HTMLCollection> {
         reflect_dom_object(box HTMLCollection::new_inherited(collection),
-                           window, HTMLCollectionBinding::Wrap)
+                           &Window(*window), HTMLCollectionBinding::Wrap)
     }
 }
 
diff --git a/src/components/script/dom/location.rs b/src/components/script/dom/location.rs
index 36a58a4a7ec..d8a1fac08c0 100644
--- a/src/components/script/dom/location.rs
+++ b/src/components/script/dom/location.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::LocationBinding;
+use dom::bindings::global::Window;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::window::Window;
@@ -30,7 +31,7 @@ impl Location {
 
     pub fn new(window: &JSRef<Window>, page: Rc<Page>) -> Temporary<Location> {
         reflect_dom_object(box Location::new_inherited(page),
-                           window,
+                           &Window(*window),
                            LocationBinding::Wrap)
     }
 }
diff --git a/src/components/script/dom/mouseevent.rs b/src/components/script/dom/mouseevent.rs
index 57b1688cc06..aa164c1eafb 100644
--- a/src/components/script/dom/mouseevent.rs
+++ b/src/components/script/dom/mouseevent.rs
@@ -5,6 +5,7 @@
 use dom::bindings::codegen::Bindings::MouseEventBinding;
 use dom::bindings::codegen::InheritTypes::{UIEventCast, MouseEventDerived};
 use dom::bindings::error::Fallible;
+use dom::bindings::global::{GlobalRef, Window};
 use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, OptionalSettable};
 use dom::bindings::trace::Traceable;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
@@ -55,7 +56,7 @@ impl MouseEvent {
 
     pub fn new_uninitialized(window: &JSRef<Window>) -> Temporary<MouseEvent> {
         reflect_dom_object(box MouseEvent::new_inherited(),
-                           window,
+                           &Window(*window),
                            MouseEventBinding::Wrap)
     }
 
@@ -83,10 +84,10 @@ impl MouseEvent {
         Temporary::from_rooted(&*ev)
     }
 
-    pub fn Constructor(global: &JSRef<Window>,
+    pub fn Constructor(global: &GlobalRef,
                        type_: DOMString,
                        init: &MouseEventBinding::MouseEventInit) -> Fallible<Temporary<MouseEvent>> {
-        let event = MouseEvent::new(global, type_,
+        let event = MouseEvent::new(global.as_window(), type_,
                                     init.parent.parent.bubbles,
                                     init.parent.parent.cancelable,
                                     init.parent.view.root_ref(),
diff --git a/src/components/script/dom/navigator.rs b/src/components/script/dom/navigator.rs
index dd85a33be0d..06ccc910dc9 100644
--- a/src/components/script/dom/navigator.rs
+++ b/src/components/script/dom/navigator.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::NavigatorBinding;
+use dom::bindings::global::Window;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::window::Window;
@@ -22,7 +23,7 @@ impl Navigator {
 
     pub fn new(window: &JSRef<Window>) -> Temporary<Navigator> {
         reflect_dom_object(box Navigator::new_inherited(),
-                           window,
+                           &Window(*window),
                            NavigatorBinding::Wrap)
     }
 }
diff --git a/src/components/script/dom/node.rs b/src/components/script/dom/node.rs
index aacaa9bbedb..52b23c3b3e2 100644
--- a/src/components/script/dom/node.rs
+++ b/src/components/script/dom/node.rs
@@ -12,6 +12,7 @@ use dom::bindings::codegen::InheritTypes::{CharacterDataCast, NodeBase, NodeDeri
 use dom::bindings::codegen::InheritTypes::{ProcessingInstructionCast, EventTargetCast};
 use dom::bindings::codegen::Bindings::NodeBinding::NodeConstants;
 use dom::bindings::error::{ErrorResult, Fallible, NotFound, HierarchyRequest, Syntax};
+use dom::bindings::global::{GlobalRef, Window};
 use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, Root, OptionalUnrootable};
 use dom::bindings::js::{OptionalSettable, TemporaryPushable, OptionalRootedRootable};
 use dom::bindings::js::{ResultRootable, OptionalRootable};
@@ -907,10 +908,10 @@ impl Node {
     pub fn reflect_node<N: Reflectable+NodeBase>
             (node:      Box<N>,
              document:  &JSRef<Document>,
-             wrap_fn:   extern "Rust" fn(*mut JSContext, &JSRef<Window>, Box<N>) -> Temporary<N>)
+             wrap_fn:   extern "Rust" fn(*mut JSContext, &GlobalRef, Box<N>) -> Temporary<N>)
              -> Temporary<N> {
         let window = document.window.root();
-        reflect_dom_object(node, &*window, wrap_fn)
+        reflect_dom_object(node, &Window(*window), wrap_fn)
     }
 
     pub fn new_inherited(type_id: NodeTypeId, doc: &JSRef<Document>) -> Node {
diff --git a/src/components/script/dom/nodelist.rs b/src/components/script/dom/nodelist.rs
index b3fbd578fe6..ebd7a2f6ae9 100644
--- a/src/components/script/dom/nodelist.rs
+++ b/src/components/script/dom/nodelist.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::NodeListBinding;
+use dom::bindings::global::Window;
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::node::{Node, NodeHelpers};
@@ -31,7 +32,7 @@ impl NodeList {
     pub fn new(window: &JSRef<Window>,
                list_type: NodeListType) -> Temporary<NodeList> {
         reflect_dom_object(box NodeList::new_inherited(list_type),
-                           window, NodeListBinding::Wrap)
+                           &Window(*window), NodeListBinding::Wrap)
     }
 
     pub fn new_simple_list(window: &JSRef<Window>, elements: Vec<JSRef<Node>>) -> Temporary<NodeList> {
diff --git a/src/components/script/dom/performance.rs b/src/components/script/dom/performance.rs
index eeab8ad282c..86c431a948e 100644
--- a/src/components/script/dom/performance.rs
+++ b/src/components/script/dom/performance.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::PerformanceBinding;
+use dom::bindings::global::Window;
 use dom::bindings::js::{JS, JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::performancetiming::{PerformanceTiming, PerformanceTimingMethods};
@@ -27,7 +28,8 @@ impl Performance {
 
     pub fn new(window: &JSRef<Window>) -> Temporary<Performance> {
         let performance = Performance::new_inherited(window);
-        reflect_dom_object(box performance, window, PerformanceBinding::Wrap)
+        reflect_dom_object(box performance, &Window(*window),
+                           PerformanceBinding::Wrap)
     }
 }
 
diff --git a/src/components/script/dom/performancetiming.rs b/src/components/script/dom/performancetiming.rs
index 328b351844f..646dd9b087b 100644
--- a/src/components/script/dom/performancetiming.rs
+++ b/src/components/script/dom/performancetiming.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::PerformanceTimingBinding;
+use dom::bindings::global::Window;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::window::Window;
@@ -27,7 +28,8 @@ impl PerformanceTiming {
     pub fn new(window: &JSRef<Window>) -> Temporary<PerformanceTiming> {
         let timing = PerformanceTiming::new_inherited(window.navigationStart,
                                                       window.navigationStartPrecise);
-        reflect_dom_object(box timing, window, PerformanceTimingBinding::Wrap)
+        reflect_dom_object(box timing, &Window(*window),
+                           PerformanceTimingBinding::Wrap)
     }
 }
 
diff --git a/src/components/script/dom/progressevent.rs b/src/components/script/dom/progressevent.rs
index 4434a74020b..a9e380ba989 100644
--- a/src/components/script/dom/progressevent.rs
+++ b/src/components/script/dom/progressevent.rs
@@ -5,10 +5,10 @@
 use dom::bindings::codegen::Bindings::ProgressEventBinding;
 use dom::bindings::codegen::InheritTypes::{EventCast, ProgressEventDerived};
 use dom::bindings::error::Fallible;
+use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::event::{Event, EventMethods, ProgressEventTypeId};
-use dom::window::Window;
 use servo_util::str::DOMString;
 
 #[deriving(Encodable)]
@@ -34,7 +34,7 @@ impl ProgressEvent {
             total: total
         }
     }
-    pub fn new(global: &JSRef<Window>, type_: DOMString,
+    pub fn new(global: &GlobalRef, type_: DOMString,
                can_bubble: bool, cancelable: bool,
                length_computable: bool, loaded: u64, total: u64) -> Temporary<ProgressEvent> {
         let ev = reflect_dom_object(box ProgressEvent::new_inherited(length_computable, loaded, total),
@@ -44,7 +44,7 @@ impl ProgressEvent {
         event.InitEvent(type_, can_bubble, cancelable);
         Temporary::from_rooted(&*ev)
     }
-    pub fn Constructor(global: &JSRef<Window>,
+    pub fn Constructor(global: &GlobalRef,
                        type_: DOMString,
                        init: &ProgressEventBinding::ProgressEventInit)
                        -> Fallible<Temporary<ProgressEvent>> {
diff --git a/src/components/script/dom/testbinding.rs b/src/components/script/dom/testbinding.rs
index e0da2b0734a..bf3e5f2d232 100644
--- a/src/components/script/dom/testbinding.rs
+++ b/src/components/script/dom/testbinding.rs
@@ -7,11 +7,11 @@ use dom::bindings::codegen::Bindings::TestBindingBinding::TestEnumValues::_empty
 use dom::bindings::codegen::UnionTypes::BlobOrString::BlobOrString;
 use dom::bindings::codegen::UnionTypes::EventOrString::{EventOrString, eString};
 use dom::bindings::codegen::UnionTypes::HTMLElementOrLong::{HTMLElementOrLong, eLong};
-use dom::bindings::js::{JS, JSRef, Temporary};
+use dom::bindings::global::GlobalField;
+use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::str::ByteString;
 use dom::bindings::utils::{Reflector, Reflectable};
 use dom::blob::Blob;
-use dom::window::Window;
 use servo_util::str::DOMString;
 
 use js::jsapi::JSContext;
@@ -20,7 +20,7 @@ use js::jsval::{JSVal, NullValue};
 #[deriving(Encodable)]
 pub struct TestBinding {
     reflector: Reflector,
-    global: JS<Window>,
+    global: GlobalField,
 }
 
 pub trait TestBindingMethods {
@@ -278,19 +278,19 @@ pub trait TestBindingMethods {
 impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
     fn InterfaceAttribute(&self) -> Temporary<Blob> {
         let global = self.global.root();
-        Blob::new(&*global)
+        Blob::new(&global.root_ref())
     }
     fn GetInterfaceAttributeNullable(&self) -> Option<Temporary<Blob>> {
         let global = self.global.root();
-        Some(Blob::new(&*global))
+        Some(Blob::new(&global.root_ref()))
     }
     fn ReceiveInterface(&self) -> Temporary<Blob> {
         let global = self.global.root();
-        Blob::new(&*global)
+        Blob::new(&global.root_ref())
     }
     fn ReceiveNullableInterface(&self) -> Option<Temporary<Blob>> {
         let global = self.global.root();
-        Some(Blob::new(&*global))
+        Some(Blob::new(&global.root_ref()))
     }
 }
 
diff --git a/src/components/script/dom/text.rs b/src/components/script/dom/text.rs
index ece96559640..bc05fcb7e39 100644
--- a/src/components/script/dom/text.rs
+++ b/src/components/script/dom/text.rs
@@ -5,13 +5,14 @@
 use dom::bindings::codegen::Bindings::TextBinding;
 use dom::bindings::codegen::InheritTypes::TextDerived;
 use dom::bindings::error::Fallible;
+use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::characterdata::CharacterData;
 use dom::document::Document;
 use dom::eventtarget::{EventTarget, NodeTargetTypeId};
 use dom::node::{Node, TextNodeTypeId};
-use dom::window::{Window, WindowMethods};
+use dom::window::WindowMethods;
 use servo_util::str::DOMString;
 
 /// An HTML text node.
@@ -38,8 +39,8 @@ impl Text {
         Node::reflect_node(box node, document, TextBinding::Wrap)
     }
 
-    pub fn Constructor(global: &JSRef<Window>, text: DOMString) -> Fallible<Temporary<Text>> {
-        let document = global.Document().root();
+    pub fn Constructor(global: &GlobalRef, text: DOMString) -> Fallible<Temporary<Text>> {
+        let document = global.as_window().Document().root();
         Ok(Text::new(text, &*document))
     }
 }
diff --git a/src/components/script/dom/uievent.rs b/src/components/script/dom/uievent.rs
index 9ed8f80e757..026e6045747 100644
--- a/src/components/script/dom/uievent.rs
+++ b/src/components/script/dom/uievent.rs
@@ -5,6 +5,7 @@
 use dom::bindings::codegen::Bindings::UIEventBinding;
 use dom::bindings::codegen::InheritTypes::{EventCast, UIEventDerived};
 use dom::bindings::error::Fallible;
+use dom::bindings::global::{GlobalRef, Window};
 use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, OptionalSettable};
 use dom::bindings::trace::Traceable;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
@@ -39,7 +40,7 @@ impl UIEvent {
 
     pub fn new_uninitialized(window: &JSRef<Window>) -> Temporary<UIEvent> {
         reflect_dom_object(box UIEvent::new_inherited(UIEventTypeId),
-                           window,
+                           &Window(*window),
                            UIEventBinding::Wrap)
     }
 
@@ -54,10 +55,10 @@ impl UIEvent {
         Temporary::from_rooted(&*ev)
     }
 
-    pub fn Constructor(global: &JSRef<Window>,
+    pub fn Constructor(global: &GlobalRef,
                        type_: DOMString,
                        init: &UIEventBinding::UIEventInit) -> Fallible<Temporary<UIEvent>> {
-        let event = UIEvent::new(global, type_,
+        let event = UIEvent::new(global.as_window(), type_,
                                  init.parent.bubbles, init.parent.cancelable,
                                  init.view.root_ref(), init.detail);
         Ok(event)
diff --git a/src/components/script/dom/urlsearchparams.rs b/src/components/script/dom/urlsearchparams.rs
index 9458b7a7226..1baebd376ac 100644
--- a/src/components/script/dom/urlsearchparams.rs
+++ b/src/components/script/dom/urlsearchparams.rs
@@ -6,10 +6,10 @@ use std::collections::hashmap::HashMap;
 use dom::bindings::codegen::Bindings::URLSearchParamsBinding;
 use dom::bindings::codegen::UnionTypes::StringOrURLSearchParams::{StringOrURLSearchParams, eURLSearchParams, eString};
 use dom::bindings::error::{Fallible};
+use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::trace::Traceable;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
-use dom::window::Window;
 use encoding::all::UTF_8;
 use encoding::types::{Encoding, EncodeReplace};
 use servo_util::str::DOMString;
@@ -31,11 +31,11 @@ impl URLSearchParams {
         }
     }
 
-    pub fn new(global: &JSRef<Window>) -> Temporary<URLSearchParams> {
+    pub fn new(global: &GlobalRef) -> Temporary<URLSearchParams> {
         reflect_dom_object(box URLSearchParams::new_inherited(), global, URLSearchParamsBinding::Wrap)
     }
 
-    pub fn Constructor(global: &JSRef<Window>, init: Option<StringOrURLSearchParams>) -> Fallible<Temporary<URLSearchParams>> {
+    pub fn Constructor(global: &GlobalRef, init: Option<StringOrURLSearchParams>) -> Fallible<Temporary<URLSearchParams>> {
         let usp = URLSearchParams::new(global).root();
         match init {
             Some(eString(_s)) => {
diff --git a/src/components/script/dom/validitystate.rs b/src/components/script/dom/validitystate.rs
index 15566170a3a..a8d0311f047 100644
--- a/src/components/script/dom/validitystate.rs
+++ b/src/components/script/dom/validitystate.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::ValidityStateBinding;
+use dom::bindings::global::Window;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::window::Window;
@@ -23,7 +24,7 @@ impl ValidityState {
 
     pub fn new(window: &JSRef<Window>) -> Temporary<ValidityState> {
         reflect_dom_object(box ValidityState::new_inherited(),
-                           window,
+                           &Window(*window),
                            ValidityStateBinding::Wrap)
     }
 }
diff --git a/src/components/script/dom/window.rs b/src/components/script/dom/window.rs
index 029303a960e..a92daa312d7 100644
--- a/src/components/script/dom/window.rs
+++ b/src/components/script/dom/window.rs
@@ -5,6 +5,7 @@
 use dom::bindings::codegen::Bindings::EventHandlerBinding::{OnErrorEventHandlerNonNull, EventHandlerNonNull};
 use dom::bindings::codegen::Bindings::WindowBinding;
 use dom::bindings::codegen::InheritTypes::EventTargetCast;
+use dom::bindings::global;
 use dom::bindings::js::{JS, JSRef, Temporary, OptionalSettable};
 use dom::bindings::trace::{Traceable, Untraceable};
 use dom::bindings::utils::{Reflectable, Reflector};
@@ -169,7 +170,7 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
 
     fn Console(&self) -> Temporary<Console> {
         if self.console.get().is_none() {
-            let console = Console::new(self);
+            let console = Console::new(&global::Window(*self));
             self.console.assign(Some(console));
         }
         Temporary::new(self.console.get().get_ref().clone())
diff --git a/src/components/script/dom/xmlhttprequest.rs b/src/components/script/dom/xmlhttprequest.rs
index 50cc71b3513..6d93c5a95da 100644
--- a/src/components/script/dom/xmlhttprequest.rs
+++ b/src/components/script/dom/xmlhttprequest.rs
@@ -10,6 +10,7 @@ use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast, XMLHttpRe
 use dom::bindings::conversions::ToJSValConvertible;
 use dom::bindings::error::{Error, ErrorResult, Fallible, InvalidState, InvalidAccess};
 use dom::bindings::error::{Network, Syntax, Security, Abort, Timeout};
+use dom::bindings::global::{GlobalField, GlobalRef};
 use dom::bindings::js::{JS, JSRef, Temporary, OptionalRootedRootable};
 use dom::bindings::str::ByteString;
 use dom::bindings::trace::{Traceable, Untraceable};
@@ -19,7 +20,6 @@ use dom::event::Event;
 use dom::eventtarget::{EventTarget, EventTargetHelpers, XMLHttpRequestTargetTypeId};
 use dom::progressevent::ProgressEvent;
 use dom::urlsearchparams::URLSearchParamsHelpers;
-use dom::window::Window;
 use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTarget;
 use dom::xmlhttprequestupload::XMLHttpRequestUpload;
 
@@ -121,7 +121,7 @@ pub struct XMLHttpRequest {
     upload_events: Traceable<Cell<bool>>,
     send_flag: Traceable<Cell<bool>>,
 
-    global: JS<Window>,
+    global: GlobalField,
     pinned_count: Traceable<Cell<uint>>,
     timer: Untraceable<RefCell<Timer>>,
     fetch_time: Traceable<Cell<i64>>,
@@ -130,7 +130,7 @@ pub struct XMLHttpRequest {
 }
 
 impl XMLHttpRequest {
-    pub fn new_inherited(global: &JSRef<Window>) -> XMLHttpRequest {
+    pub fn new_inherited(global: &GlobalRef) -> XMLHttpRequest {
         let xhr = XMLHttpRequest {
             eventtarget: XMLHttpRequestEventTarget::new_inherited(XMLHttpRequestTypeId),
             ready_state: Traceable::new(Cell::new(Unsent)),
@@ -155,7 +155,7 @@ impl XMLHttpRequest {
             upload_complete: Traceable::new(Cell::new(false)),
             upload_events: Traceable::new(Cell::new(false)),
 
-            global: JS::from_rooted(global),
+            global: GlobalField::from_rooted(global),
             pinned_count: Traceable::new(Cell::new(0)),
             timer: Untraceable::new(RefCell::new(Timer::new().unwrap())),
             fetch_time: Traceable::new(Cell::new(0)),
@@ -164,12 +164,12 @@ impl XMLHttpRequest {
         };
         xhr
     }
-    pub fn new(global: &JSRef<Window>) -> Temporary<XMLHttpRequest> {
+    pub fn new(global: &GlobalRef) -> Temporary<XMLHttpRequest> {
         reflect_dom_object(box XMLHttpRequest::new_inherited(global),
                            global,
                            XMLHttpRequestBinding::Wrap)
     }
-    pub fn Constructor(global: &JSRef<Window>) -> Fallible<Temporary<XMLHttpRequest>> {
+    pub fn Constructor(global: &GlobalRef) -> Fallible<Temporary<XMLHttpRequest>> {
         Ok(XMLHttpRequest::new(global))
     }
 
@@ -293,7 +293,7 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
             Method::from_str_or_new(s.as_slice())
         });
         // Step 2
-        let base: Option<Url> = Some(self.global.root().get_url());
+        let base: Option<Url> = Some(self.global.root().root_ref().get_url());
         match maybe_method {
             // Step 4
             Some(Connect) | Some(Trace) => Err(Security),
@@ -486,7 +486,7 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
         }
 
         let global = self.global.root();
-        let resource_task = global.deref().page().resource_task.deref().clone();
+        let resource_task = global.root_ref().page().resource_task.deref().clone();
         let mut load_data = LoadData::new(self.request_url.deref().borrow().clone());
         load_data.data = extracted;
 
@@ -516,7 +516,7 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
         }
 
         // XXXManishearth this is to be replaced with Origin for CORS (with no path)
-        let referer_url = self.global.root().get_url();
+        let referer_url = self.global.root().root_ref().get_url();
         let mut buf = String::new();
         buf.push_str(referer_url.scheme.as_slice());
         buf.push_str("://".as_slice());
@@ -537,7 +537,7 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
         } else {
             let builder = TaskBuilder::new().named("XHRTask");
             self.fetch_time.deref().set(time::now().to_timespec().sec);
-            let script_chan = global.deref().script_chan.clone();
+            let script_chan = global.root_ref().script_chan().clone();
             builder.spawn(proc() {
                 let _ = XMLHttpRequest::fetch(&mut Async(addr.unwrap(), script_chan), resource_task, load_data, terminate_receiver);
             });
@@ -692,7 +692,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
     // Creates a trusted address to the object, and roots it. Always pair this with a release()
     unsafe fn to_trusted(&self) -> TrustedXHRAddress {
         if self.pinned_count.deref().get() == 0 {
-            JS_AddObjectRoot(self.global.root().get_cx(), self.reflector().rootable());
+            JS_AddObjectRoot(self.global.root().root_ref().get_cx(), self.reflector().rootable());
         }
         let pinned_count = self.pinned_count.deref().get();
         self.pinned_count.deref().set(pinned_count + 1);
@@ -711,7 +711,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
         self.pinned_count.deref().set(pinned_count - 1);
         if self.pinned_count.deref().get() == 0 {
             unsafe {
-                JS_RemoveObjectRoot(self.global.root().get_cx(), self.reflector().rootable());
+                JS_RemoveObjectRoot(self.global.root().root_ref().get_cx(), self.reflector().rootable());
             }
         }
     }
@@ -720,7 +720,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
         assert!(self.ready_state.deref().get() != rs)
         self.ready_state.deref().set(rs);
         let global = self.global.root();
-        let event = Event::new(&*global,
+        let event = Event::new(&global.root_ref(),
                                "readystatechange".to_string(),
                                false, true).root();
         let target: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
@@ -842,7 +842,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
     fn dispatch_progress_event(&self, upload: bool, type_: DOMString, loaded: u64, total: Option<u64>) {
         let global = self.global.root();
         let upload_target = &*self.upload.root();
-        let progressevent = ProgressEvent::new(&*global,
+        let progressevent = ProgressEvent::new(&global.root_ref(),
                                                type_, false, false,
                                                total.is_some(), loaded,
                                                total.unwrap_or(0)).root();
@@ -880,7 +880,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
         }
         self.timeout_pinned.deref().set(true);
         let global = self.global.root();
-        let script_chan = global.deref().script_chan.clone();
+        let script_chan = global.root_ref().script_chan().clone();
         let terminate_sender = (*self.terminate_sender.deref().borrow()).clone();
         spawn_named("XHR:Timer", proc () {
             match oneshot.recv_opt() {
diff --git a/src/components/script/dom/xmlhttprequestupload.rs b/src/components/script/dom/xmlhttprequestupload.rs
index e4d26c7f017..cf444d6c70b 100644
--- a/src/components/script/dom/xmlhttprequestupload.rs
+++ b/src/components/script/dom/xmlhttprequestupload.rs
@@ -4,10 +4,10 @@
 
 use dom::bindings::codegen::InheritTypes::XMLHttpRequestUploadDerived;
 use dom::bindings::codegen::Bindings::XMLHttpRequestUploadBinding;
-use dom::bindings::js::{Temporary, JSRef};
+use dom::bindings::global::GlobalRef;
+use dom::bindings::js::Temporary;
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::eventtarget::{EventTarget, XMLHttpRequestTargetTypeId};
-use dom::window::Window;
 use dom::xmlhttprequest::{XMLHttpRequestUploadTypeId};
 use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTarget;
 
@@ -22,7 +22,7 @@ impl XMLHttpRequestUpload {
             eventtarget:XMLHttpRequestEventTarget::new_inherited(XMLHttpRequestUploadTypeId)
         }
     }
-    pub fn new(global: &JSRef<Window>) -> Temporary<XMLHttpRequestUpload> {
+    pub fn new(global: &GlobalRef) -> Temporary<XMLHttpRequestUpload> {
         reflect_dom_object(box XMLHttpRequestUpload::new_inherited(),
                            global,
                            XMLHttpRequestUploadBinding::Wrap)
diff --git a/src/components/script/script.rs b/src/components/script/script.rs
index 5ebbc4cbb92..e5a3ab69867 100644
--- a/src/components/script/script.rs
+++ b/src/components/script/script.rs
@@ -43,6 +43,7 @@ extern crate url;
 
 pub mod dom {
     pub mod bindings {
+        pub mod global;
         pub mod js;
         pub mod utils;
         pub mod callback;
diff --git a/src/components/script/script_task.rs b/src/components/script/script_task.rs
index dfd121091cf..5551e9d6869 100644
--- a/src/components/script/script_task.rs
+++ b/src/components/script/script_task.rs
@@ -6,6 +6,7 @@
 //! and layout tasks.
 
 use dom::bindings::codegen::InheritTypes::{EventTargetCast, NodeCast, EventCast};
+use dom::bindings::global::Window;
 use dom::bindings::js::{JS, JSRef, RootCollection, Temporary, OptionalSettable};
 use dom::bindings::js::OptionalRootable;
 use dom::bindings::utils::Reflectable;
@@ -621,7 +622,7 @@ impl ScriptTask {
         // We have no concept of a document loader right now, so just dispatch the
         // "load" event as soon as we've finished executing all scripts parsed during
         // the initial load.
-        let event = Event::new(&*window, "load".to_string(), false, false).root();
+        let event = Event::new(&Window(*window), "load".to_string(), false, false).root();
         let doctarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*document);
         let wintarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*window);
         let _ = wintarget.dispatch_event_with_target(Some((*doctarget).clone()),
@@ -719,7 +720,7 @@ impl ScriptTask {
                                     Some(ref frame) => {
                                         let window = frame.window.root();
                                         let event =
-                                            Event::new(&*window,
+                                            Event::new(&Window(*window),
                                                        "click".to_string(),
                                                        true, true).root();
                                         let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&node);