Make reflect_dom_object take a &GlobalScope

132 files changed, 488 insertions, 407 deletions

diff --git a/components/script/body.rs b/components/script/body.rs
index 276d6425d2f..466523f394f 100644
--- a/components/script/body.rs
+++ b/components/script/body.rs
@@ -4,12 +4,12 @@
 
 use dom::bindings::codegen::Bindings::FormDataBinding::FormDataMethods;
 use dom::bindings::error::{Error, Fallible};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::Reflectable;
 use dom::bindings::str::USVString;
 use dom::blob::{Blob, BlobImpl};
 use dom::formdata::FormData;
+use dom::globalscope::GlobalScope;
 use dom::promise::Promise;
 use encoding::all::UTF_8;
 use encoding::types::{DecoderTrap, Encoding};
@@ -103,8 +103,8 @@ fn run_package_data_algorithm<T: BodyOperations + Reflectable>(object: &T,
     match body_type {
         BodyType::Text => run_text_data_algorithm(bytes),
         BodyType::Json => run_json_data_algorithm(cx, bytes),
-        BodyType::Blob => run_blob_data_algorithm(object.global().r(), bytes, mime),
-        BodyType::FormData => run_form_data_algorithm(object.global().r(), bytes, mime),
+        BodyType::Blob => run_blob_data_algorithm(object.global().r().as_global_scope(), bytes, mime),
+        BodyType::FormData => run_form_data_algorithm(object.global().r().as_global_scope(), bytes, mime),
     }
 }
 
@@ -132,7 +132,7 @@ fn run_json_data_algorithm(cx: *mut JSContext,
     }
 }
 
-fn run_blob_data_algorithm(root: GlobalRef,
+fn run_blob_data_algorithm(root: &GlobalScope,
                            bytes: Vec<u8>,
                            mime: &[u8]) -> Fallible<FetchedData> {
     let mime_string = if let Ok(s) = String::from_utf8(mime.to_vec()) {
@@ -144,7 +144,7 @@ fn run_blob_data_algorithm(root: GlobalRef,
     Ok(FetchedData::BlobData(blob))
 }
 
-fn run_form_data_algorithm(root: GlobalRef, bytes: Vec<u8>, mime: &[u8]) -> Fallible<FetchedData> {
+fn run_form_data_algorithm(root: &GlobalScope, bytes: Vec<u8>, mime: &[u8]) -> Fallible<FetchedData> {
     let mime_str = if let Ok(s) = str::from_utf8(mime) {
         s
     } else {
diff --git a/components/script/dom/attr.rs b/components/script/dom/attr.rs
index d5a00e6c1fa..f322204fc4b 100644
--- a/components/script/dom/attr.rs
+++ b/components/script/dom/attr.rs
@@ -5,7 +5,6 @@
 use devtools_traits::AttrInfo;
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::AttrBinding::{self, AttrMethods};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{JS, MutNullableHeap};
 use dom::bindings::js::{LayoutJS, Root, RootedReference};
@@ -66,7 +65,7 @@ impl Attr {
                                                    namespace,
                                                    prefix,
                                                    owner),
-                           GlobalRef::Window(window),
+                           window,
                            AttrBinding::Wrap)
     }
 
diff --git a/components/script/dom/beforeunloadevent.rs b/components/script/dom/beforeunloadevent.rs
index b66df9429dc..413a26a8de8 100644
--- a/components/script/dom/beforeunloadevent.rs
+++ b/components/script/dom/beforeunloadevent.rs
@@ -6,12 +6,12 @@ use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::BeforeUnloadEventBinding;
 use dom::bindings::codegen::Bindings::BeforeUnloadEventBinding::BeforeUnloadEventMethods;
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
 use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::globalscope::GlobalScope;
 use string_cache::Atom;
 
 // https://html.spec.whatwg.org/multipage/#beforeunloadevent
@@ -29,13 +29,13 @@ impl BeforeUnloadEvent {
         }
     }
 
-    pub fn new_uninitialized(global: GlobalRef) -> Root<BeforeUnloadEvent> {
+    pub fn new_uninitialized(global: &GlobalScope) -> Root<BeforeUnloadEvent> {
         reflect_dom_object(box BeforeUnloadEvent::new_inherited(),
                            global,
                            BeforeUnloadEventBinding::Wrap)
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                type_: Atom,
                bubbles: EventBubbles,
                cancelable: EventCancelable) -> Root<BeforeUnloadEvent> {
diff --git a/components/script/dom/bindings/codegen/CodegenRust.py b/components/script/dom/bindings/codegen/CodegenRust.py
index d30cee0ca93..7e7cb4144db 100644
--- a/components/script/dom/bindings/codegen/CodegenRust.py
+++ b/components/script/dom/bindings/codegen/CodegenRust.py
@@ -1927,8 +1927,10 @@ class CGImports(CGWrapper):
             if t in dictionaries or t in enums:
                 continue
             if t.isInterface() or t.isNamespace():
-                descriptor = descriptorProvider.getDescriptor(getIdentifier(t).name)
-                extras += [descriptor.path]
+                name = getIdentifier(t).name
+                descriptor = descriptorProvider.getDescriptor(name)
+                if name != 'GlobalScope':
+                    extras += [descriptor.path]
                 parentName = descriptor.getParentName()
                 if parentName:
                     descriptor = descriptorProvider.getDescriptor(parentName)
@@ -2523,7 +2525,8 @@ class CGWrapMethod(CGAbstractMethod):
     def __init__(self, descriptor):
         assert not descriptor.interface.isCallback()
         assert not descriptor.isGlobal()
-        args = [Argument('*mut JSContext', 'cx'), Argument('GlobalRef', 'scope'),
+        args = [Argument('*mut JSContext', 'cx'),
+                Argument('&GlobalScope', 'scope'),
                 Argument("Box<%s>" % descriptor.concreteType, 'object')]
         retval = 'Root<%s>' % descriptor.concreteType
         CGAbstractMethod.__init__(self, descriptor, 'Wrap', retval, args,
@@ -5594,6 +5597,7 @@ def generate_imports(config, cgthings, descriptors, callbacks=None, dictionaries
         'dom::bindings::weakref::WeakBox',
         'dom::bindings::weakref::WeakReferenceable',
         'dom::browsingcontext::BrowsingContext',
+        'dom::globalscope::GlobalScope',
         'mem::heap_size_of_raw_self_and_children',
         'libc',
         'util::prefs::PREFS',
diff --git a/components/script/dom/bindings/error.rs b/components/script/dom/bindings/error.rs
index 1c0d49c4976..14725b33303 100644
--- a/components/script/dom/bindings/error.rs
+++ b/components/script/dom/bindings/error.rs
@@ -127,7 +127,7 @@ pub unsafe fn throw_dom_exception(cx: *mut JSContext, global: GlobalRef, result:
     };
 
     assert!(!JS_IsExceptionPending(cx));
-    let exception = DOMException::new(global, code);
+    let exception = DOMException::new(global.as_global_scope(), code);
     rooted!(in(cx) let mut thrown = UndefinedValue());
     exception.to_jsval(cx, thrown.handle_mut());
     JS_SetPendingException(cx, thrown.handle());
diff --git a/components/script/dom/bindings/global.rs b/components/script/dom/bindings/global.rs
index e0341ceeb68..db90f1fbcdf 100644
--- a/components/script/dom/bindings/global.rs
+++ b/components/script/dom/bindings/global.rs
@@ -11,9 +11,11 @@ use devtools_traits::{ScriptToDevtoolsControlMsg, WorkerId};
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::conversions::root_from_object;
 use dom::bindings::error::{ErrorInfo, report_pending_exception};
+use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflectable, Reflector};
 use dom::console::TimerSet;
+use dom::globalscope::GlobalScope;
 use dom::window;
 use dom::workerglobalscope::WorkerGlobalScope;
 use ipc_channel::ipc::IpcSender;
@@ -55,6 +57,14 @@ pub enum GlobalRoot {
 }
 
 impl<'a> GlobalRef<'a> {
+    /// Returns that `GlobalRef` as a `GlobalScope` referengce.
+    pub fn as_global_scope(&self) -> &GlobalScope {
+        match *self {
+            GlobalRef::Window(window) => window.upcast(),
+            GlobalRef::Worker(worker) => worker.upcast(),
+        }
+    }
+
     /// Get the `JSContext` for the `JSRuntime` associated with the thread
     /// this global object is on.
     pub fn get_cx(&self) -> *mut JSContext {
diff --git a/components/script/dom/bindings/iterable.rs b/components/script/dom/bindings/iterable.rs
index 84381b52655..5a86dcf64d8 100644
--- a/components/script/dom/bindings/iterable.rs
+++ b/components/script/dom/bindings/iterable.rs
@@ -10,10 +10,10 @@ use core::nonzero::NonZero;
 use dom::bindings::codegen::Bindings::IterableIteratorBinding::IterableKeyAndValueResult;
 use dom::bindings::codegen::Bindings::IterableIteratorBinding::IterableKeyOrValueResult;
 use dom::bindings::error::Fallible;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, Reflectable, MutReflectable, reflect_dom_object};
 use dom::bindings::trace::JSTraceable;
+use dom::globalscope::GlobalScope;
 use js::conversions::ToJSValConvertible;
 use js::jsapi::{JSContext, JSObject, MutableHandleValue, MutableHandleObject, HandleValue};
 use js::jsval::UndefinedValue;
@@ -85,7 +85,7 @@ impl<T: Reflectable + JSTraceable + Iterable> IterableIterator<T> {
     /// Create a new iterator instance for the provided iterable DOM interface.
     pub fn new(iterable: &T,
                type_: IteratorType,
-               wrap: fn(*mut JSContext, GlobalRef, Box<IterableIterator<T>>)
+               wrap: fn(*mut JSContext, &GlobalScope, Box<IterableIterator<T>>)
                      -> Root<Self>) -> Root<Self> {
         let iterator = box IterableIterator {
             reflector: Reflector::new(),
@@ -94,7 +94,7 @@ impl<T: Reflectable + JSTraceable + Iterable> IterableIterator<T> {
             index: Cell::new(0),
         };
         let global = iterable.global();
-        reflect_dom_object(iterator, global.r(), wrap)
+        reflect_dom_object(iterator, global.r().as_global_scope(), wrap)
     }
 
     /// Return the next value from the iterable object.
diff --git a/components/script/dom/bindings/reflector.rs b/components/script/dom/bindings/reflector.rs
index d5280712a03..74c039688f7 100644
--- a/components/script/dom/bindings/reflector.rs
+++ b/components/script/dom/bindings/reflector.rs
@@ -4,19 +4,25 @@
 
 //! The `Reflector` struct.
 
-use dom::bindings::global::{GlobalRef, GlobalRoot, global_root_from_reflector};
+use dom::bindings::conversions::DerivedFrom;
+use dom::bindings::global::{GlobalRoot, global_root_from_reflector};
 use dom::bindings::js::Root;
+use dom::globalscope::GlobalScope;
 use js::jsapi::{HandleObject, JSContext, JSObject};
 use std::cell::UnsafeCell;
 use std::ptr;
 
 /// Create the reflector for a new DOM object and yield ownership to the
 /// reflector.
-pub fn reflect_dom_object<T: Reflectable>(obj: Box<T>,
-                                          global: GlobalRef,
-                                          wrap_fn: fn(*mut JSContext, GlobalRef, Box<T>) -> Root<T>)
-                                          -> Root<T> {
-    wrap_fn(global.get_cx(), global, obj)
+pub fn reflect_dom_object<T, U>(
+        obj: Box<T>,
+        global: &U,
+        wrap_fn: fn(*mut JSContext, &GlobalScope, Box<T>) -> Root<T>)
+        -> Root<T>
+    where T: Reflectable, U: DerivedFrom<GlobalScope>
+{
+    let global_scope = global.upcast();
+    wrap_fn(global_scope.get_cx(), global_scope, obj)
 }
 
 /// A struct to store a reference to the reflector of a DOM object.
diff --git a/components/script/dom/blob.rs b/components/script/dom/blob.rs
index aef31efd687..011f547c96a 100644
--- a/components/script/dom/blob.rs
+++ b/components/script/dom/blob.rs
@@ -11,6 +11,7 @@ use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
+use dom::globalscope::GlobalScope;
 use encoding::all::UTF_8;
 use encoding::types::{EncoderTrap, Encoding};
 use ipc_channel::ipc;
@@ -79,7 +80,9 @@ pub struct Blob {
 
 impl Blob {
     #[allow(unrooted_must_root)]
-    pub fn new(global: GlobalRef, blob_impl: BlobImpl, typeString: String) -> Root<Blob> {
+    pub fn new(
+            global: &GlobalScope, blob_impl: BlobImpl, typeString: String)
+            -> Root<Blob> {
         let boxed_blob = box Blob::new_inherited(blob_impl, typeString);
         reflect_dom_object(boxed_blob, global, BlobBinding::Wrap)
     }
@@ -99,7 +102,6 @@ impl Blob {
     #[allow(unrooted_must_root)]
     fn new_sliced(parent: &Blob, rel_pos: RelativePos,
                   relative_content_type: DOMString) -> Root<Blob> {
-        let global = parent.global();
         let blob_impl = match *parent.blob_impl.borrow() {
             BlobImpl::File(_) => {
                 // Create new parent node
@@ -115,7 +117,7 @@ impl Blob {
             }
         };
 
-        Blob::new(global.r(), blob_impl, relative_content_type.into())
+        Blob::new(parent.global().r().as_global_scope(), blob_impl, relative_content_type.into())
     }
 
     // https://w3c.github.io/FileAPI/#constructorBlob
@@ -132,7 +134,7 @@ impl Blob {
             }
         };
 
-        Ok(Blob::new(global, BlobImpl::new_from_bytes(bytes), blobPropertyBag.type_.to_string()))
+        Ok(Blob::new(global.as_global_scope(), BlobImpl::new_from_bytes(bytes), blobPropertyBag.type_.to_string()))
     }
 
     /// Get a slice to inner data, this might incur synchronous read and caching
diff --git a/components/script/dom/bluetooth.rs b/components/script/dom/bluetooth.rs
index 42ad4c2730a..dd5d05d4f2a 100644
--- a/components/script/dom/bluetooth.rs
+++ b/components/script/dom/bluetooth.rs
@@ -15,6 +15,7 @@ use dom::bindings::str::DOMString;
 use dom::bluetoothadvertisingdata::BluetoothAdvertisingData;
 use dom::bluetoothdevice::BluetoothDevice;
 use dom::bluetoothuuid::{BluetoothServiceUUID, BluetoothUUID};
+use dom::globalscope::GlobalScope;
 use dom::promise::Promise;
 use ipc_channel::ipc::{self, IpcSender};
 use js::conversions::ToJSValConvertible;
@@ -52,7 +53,7 @@ impl Bluetooth {
         }
     }
 
-    pub fn new(global: GlobalRef) -> Root<Bluetooth> {
+    pub fn new(global: &GlobalScope) -> Root<Bluetooth> {
         reflect_dom_object(box Bluetooth::new_inherited(),
                            global,
                            BluetoothBinding::Wrap)
@@ -105,11 +106,14 @@ impl Bluetooth {
         // Step 12-13.
         match device {
             Ok(device) => {
-                let ad_data = BluetoothAdvertisingData::new(self.global().r(),
+                let global = self.global();
+                let global = global.r();
+                let global = global.as_global_scope();
+                let ad_data = BluetoothAdvertisingData::new(global,
                                                             device.appearance,
                                                             device.tx_power,
                                                             device.rssi);
-                Ok(BluetoothDevice::new(self.global().r(),
+                Ok(BluetoothDevice::new(global,
                                         DOMString::from(device.id),
                                         device.name.map(DOMString::from),
                                         &ad_data))
diff --git a/components/script/dom/bluetoothadvertisingdata.rs b/components/script/dom/bluetoothadvertisingdata.rs
index 6cd77385a26..878f4fe82ec 100644
--- a/components/script/dom/bluetoothadvertisingdata.rs
+++ b/components/script/dom/bluetoothadvertisingdata.rs
@@ -4,9 +4,9 @@
 
 use dom::bindings::codegen::Bindings::BluetoothAdvertisingDataBinding;
 use dom::bindings::codegen::Bindings::BluetoothAdvertisingDataBinding::BluetoothAdvertisingDataMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::globalscope::GlobalScope;
 
 // https://webbluetoothcg.github.io/web-bluetooth/#bluetoothadvertisingdata
 #[dom_struct]
@@ -30,7 +30,7 @@ impl BluetoothAdvertisingData {
         }
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                appearance: Option<u16>,
                txPower: Option<i8>,
                rssi: Option<i8>)
diff --git a/components/script/dom/bluetoothcharacteristicproperties.rs b/components/script/dom/bluetoothcharacteristicproperties.rs
index fd716d72bb5..ccb5a37a6a8 100644
--- a/components/script/dom/bluetoothcharacteristicproperties.rs
+++ b/components/script/dom/bluetoothcharacteristicproperties.rs
@@ -5,9 +5,9 @@
 use dom::bindings::codegen::Bindings::BluetoothCharacteristicPropertiesBinding;
 use dom::bindings::codegen::Bindings::BluetoothCharacteristicPropertiesBinding::
     BluetoothCharacteristicPropertiesMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::globalscope::GlobalScope;
 
 // https://webbluetoothcg.github.io/web-bluetooth/#characteristicproperties
  #[dom_struct]
@@ -49,7 +49,7 @@ impl BluetoothCharacteristicProperties {
         }
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                broadcast: bool,
                read: bool,
                writeWithoutResponse: bool,
diff --git a/components/script/dom/bluetoothdevice.rs b/components/script/dom/bluetoothdevice.rs
index 1508c0382c8..04327080cd4 100644
--- a/components/script/dom/bluetoothdevice.rs
+++ b/components/script/dom/bluetoothdevice.rs
@@ -4,12 +4,12 @@
 
 use dom::bindings::codegen::Bindings::BluetoothDeviceBinding;
 use dom::bindings::codegen::Bindings::BluetoothDeviceBinding::BluetoothDeviceMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root, MutHeap, MutNullableHeap};
 use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
 use dom::bluetoothadvertisingdata::BluetoothAdvertisingData;
 use dom::bluetoothremotegattserver::BluetoothRemoteGATTServer;
+use dom::globalscope::GlobalScope;
 
 // https://webbluetoothcg.github.io/web-bluetooth/#bluetoothdevice
 #[dom_struct]
@@ -35,7 +35,7 @@ impl BluetoothDevice {
         }
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                id: DOMString,
                name: Option<DOMString>,
                adData: &BluetoothAdvertisingData)
@@ -66,6 +66,8 @@ impl BluetoothDeviceMethods for BluetoothDevice {
 
     // https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothdevice-gatt
     fn Gatt(&self) -> Root<BluetoothRemoteGATTServer> {
-        self.gatt.or_init(|| BluetoothRemoteGATTServer::new(self.global().r(), self))
+        self.gatt.or_init(|| {
+            BluetoothRemoteGATTServer::new(self.global().r().as_global_scope(), self)
+        })
     }
 }
diff --git a/components/script/dom/bluetoothremotegattcharacteristic.rs b/components/script/dom/bluetoothremotegattcharacteristic.rs
index 6b7ba1dcfad..701a6ddd2a2 100644
--- a/components/script/dom/bluetoothremotegattcharacteristic.rs
+++ b/components/script/dom/bluetoothremotegattcharacteristic.rs
@@ -14,7 +14,6 @@ use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServerBinding::Bluetoot
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServiceBinding::BluetoothRemoteGATTServiceMethods;
 use dom::bindings::error::{ErrorResult, Fallible};
 use dom::bindings::error::Error::{self, InvalidModification, Network, NotSupported, Security};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutHeap, Root};
 use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::str::{ByteString, DOMString};
@@ -23,6 +22,7 @@ use dom::bluetoothcharacteristicproperties::BluetoothCharacteristicProperties;
 use dom::bluetoothremotegattdescriptor::BluetoothRemoteGATTDescriptor;
 use dom::bluetoothremotegattservice::BluetoothRemoteGATTService;
 use dom::bluetoothuuid::{BluetoothDescriptorUUID, BluetoothUUID};
+use dom::globalscope::GlobalScope;
 use dom::promise::Promise;
 use ipc_channel::ipc::{self, IpcSender};
 use net_traits::bluetooth_thread::BluetoothMethodMsg;
@@ -59,7 +59,7 @@ impl BluetoothRemoteGATTCharacteristic {
         }
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                service: &BluetoothRemoteGATTService,
                uuid: DOMString,
                properties: &BluetoothCharacteristicProperties,
@@ -95,7 +95,7 @@ impl BluetoothRemoteGATTCharacteristic {
         let descriptor = receiver.recv().unwrap();
         match descriptor {
             Ok(descriptor) => {
-                Ok(BluetoothRemoteGATTDescriptor::new(self.global().r(),
+                Ok(BluetoothRemoteGATTDescriptor::new(self.global().r().as_global_scope(),
                                                       self,
                                                       DOMString::from(descriptor.uuid),
                                                       descriptor.instance_id))
@@ -126,7 +126,7 @@ impl BluetoothRemoteGATTCharacteristic {
         match descriptors_vec {
             Ok(descriptor_vec) => {
                 Ok(descriptor_vec.into_iter()
-                                 .map(|desc| BluetoothRemoteGATTDescriptor::new(self.global().r(),
+                                 .map(|desc| BluetoothRemoteGATTDescriptor::new(self.global().r().as_global_scope(),
                                                                                 self,
                                                                                 DOMString::from(desc.uuid),
                                                                                 desc.instance_id))
diff --git a/components/script/dom/bluetoothremotegattdescriptor.rs b/components/script/dom/bluetoothremotegattdescriptor.rs
index d036f8bd9ea..ee4c6ce1af5 100644
--- a/components/script/dom/bluetoothremotegattdescriptor.rs
+++ b/components/script/dom/bluetoothremotegattdescriptor.rs
@@ -13,12 +13,12 @@ use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServerBinding::Bluetoot
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServiceBinding::BluetoothRemoteGATTServiceMethods;
 use dom::bindings::error::{ErrorResult, Fallible};
 use dom::bindings::error::Error::{self, InvalidModification, Network, Security};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutHeap, Root};
 use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::str::{ByteString, DOMString};
 use dom::bluetooth::result_to_promise;
 use dom::bluetoothremotegattcharacteristic::{BluetoothRemoteGATTCharacteristic, MAXIMUM_ATTRIBUTE_LENGTH};
+use dom::globalscope::GlobalScope;
 use dom::promise::Promise;
 use ipc_channel::ipc::{self, IpcSender};
 use net_traits::bluetooth_thread::BluetoothMethodMsg;
@@ -48,7 +48,7 @@ impl BluetoothRemoteGATTDescriptor {
         }
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                characteristic: &BluetoothRemoteGATTCharacteristic,
                uuid: DOMString,
                instanceID: String)
diff --git a/components/script/dom/bluetoothremotegattserver.rs b/components/script/dom/bluetoothremotegattserver.rs
index 3439ba53350..3a939614d36 100644
--- a/components/script/dom/bluetoothremotegattserver.rs
+++ b/components/script/dom/bluetoothremotegattserver.rs
@@ -8,7 +8,6 @@ use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServerBinding;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServerBinding::BluetoothRemoteGATTServerMethods;
 use dom::bindings::error::{ErrorResult, Fallible};
 use dom::bindings::error::Error::{self, Security};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutHeap, Root};
 use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
@@ -16,6 +15,7 @@ use dom::bluetooth::result_to_promise;
 use dom::bluetoothdevice::BluetoothDevice;
 use dom::bluetoothremotegattservice::BluetoothRemoteGATTService;
 use dom::bluetoothuuid::{BluetoothServiceUUID, BluetoothUUID};
+use dom::globalscope::GlobalScope;
 use dom::promise::Promise;
 use ipc_channel::ipc::{self, IpcSender};
 use net_traits::bluetooth_thread::BluetoothMethodMsg;
@@ -39,10 +39,10 @@ impl BluetoothRemoteGATTServer {
         }
     }
 
-    pub fn new(global: GlobalRef, device: &BluetoothDevice) -> Root<BluetoothRemoteGATTServer> {
+    pub fn new(global: &GlobalScope, device: &BluetoothDevice) -> Root<BluetoothRemoteGATTServer> {
         reflect_dom_object(box BluetoothRemoteGATTServer::new_inherited(device),
-        global,
-        BluetoothRemoteGATTServerBinding::Wrap)
+                           global,
+                           BluetoothRemoteGATTServerBinding::Wrap)
     }
 
     fn get_bluetooth_thread(&self) -> IpcSender<BluetoothMethodMsg> {
@@ -80,7 +80,7 @@ impl BluetoothRemoteGATTServer {
         let service = receiver.recv().unwrap();
         match service {
             Ok(service) => {
-                Ok(BluetoothRemoteGATTService::new(self.global().r(),
+                Ok(BluetoothRemoteGATTService::new(self.global().r().as_global_scope(),
                                                    &self.device.get(),
                                                    DOMString::from(service.uuid),
                                                    service.is_primary,
@@ -112,7 +112,7 @@ impl BluetoothRemoteGATTServer {
         match services_vec {
             Ok(service_vec) => {
                 Ok(service_vec.into_iter()
-                              .map(|service| BluetoothRemoteGATTService::new(self.global().r(),
+                              .map(|service| BluetoothRemoteGATTService::new(self.global().r().as_global_scope(),
                                                                              &self.device.get(),
                                                                              DOMString::from(service.uuid),
                                                                              service.is_primary,
diff --git a/components/script/dom/bluetoothremotegattservice.rs b/components/script/dom/bluetoothremotegattservice.rs
index 3ece2507cd3..3a590b4738a 100644
--- a/components/script/dom/bluetoothremotegattservice.rs
+++ b/components/script/dom/bluetoothremotegattservice.rs
@@ -7,7 +7,6 @@ use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServiceBinding;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServiceBinding::BluetoothRemoteGATTServiceMethods;
 use dom::bindings::error::Error::{self, Security};
 use dom::bindings::error::Fallible;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutHeap, Root};
 use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
@@ -16,6 +15,7 @@ use dom::bluetoothcharacteristicproperties::BluetoothCharacteristicProperties;
 use dom::bluetoothdevice::BluetoothDevice;
 use dom::bluetoothremotegattcharacteristic::BluetoothRemoteGATTCharacteristic;
 use dom::bluetoothuuid::{BluetoothCharacteristicUUID, BluetoothServiceUUID, BluetoothUUID};
+use dom::globalscope::GlobalScope;
 use dom::promise::Promise;
 use ipc_channel::ipc::{self, IpcSender};
 use net_traits::bluetooth_thread::BluetoothMethodMsg;
@@ -46,7 +46,7 @@ impl BluetoothRemoteGATTService {
         }
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                device: &BluetoothDevice,
                uuid: DOMString,
                isPrimary: bool,
@@ -84,7 +84,10 @@ impl BluetoothRemoteGATTService {
         let characteristic = receiver.recv().unwrap();
         match characteristic {
             Ok(characteristic) => {
-                let properties = BluetoothCharacteristicProperties::new(self.global().r(),
+                let global = self.global();
+                let global = global.r();
+                let global = global.as_global_scope();
+                let properties = BluetoothCharacteristicProperties::new(global,
                                                                         characteristic.broadcast,
                                                                         characteristic.read,
                                                                         characteristic.write_without_response,
@@ -94,7 +97,7 @@ impl BluetoothRemoteGATTService {
                                                                         characteristic.authenticated_signed_writes,
                                                                         characteristic.reliable_write,
                                                                         characteristic.writable_auxiliaries);
-                Ok(BluetoothRemoteGATTCharacteristic::new(self.global().r(),
+                Ok(BluetoothRemoteGATTCharacteristic::new(global,
                                                           self,
                                                           DOMString::from(characteristic.uuid),
                                                           &properties,
@@ -127,7 +130,10 @@ impl BluetoothRemoteGATTService {
         match characteristics_vec {
             Ok(characteristic_vec) => {
                 for characteristic in characteristic_vec {
-                    let properties = BluetoothCharacteristicProperties::new(self.global().r(),
+                    let global = self.global();
+                    let global = global.r();
+                    let global = global.as_global_scope();
+                    let properties = BluetoothCharacteristicProperties::new(global,
                                                                             characteristic.broadcast,
                                                                             characteristic.read,
                                                                             characteristic.write_without_response,
@@ -137,7 +143,7 @@ impl BluetoothRemoteGATTService {
                                                                             characteristic.authenticated_signed_writes,
                                                                             characteristic.reliable_write,
                                                                             characteristic.writable_auxiliaries);
-                    characteristics.push(BluetoothRemoteGATTCharacteristic::new(self.global().r(),
+                    characteristics.push(BluetoothRemoteGATTCharacteristic::new(global,
                                                                                 self,
                                                                                 DOMString::from(characteristic.uuid),
                                                                                 &properties,
@@ -167,7 +173,7 @@ impl BluetoothRemoteGATTService {
         let service = receiver.recv().unwrap();
         match service {
             Ok(service) => {
-                Ok(BluetoothRemoteGATTService::new(self.global().r(),
+                Ok(BluetoothRemoteGATTService::new(self.global().r().as_global_scope(),
                                                    &self.device.get(),
                                                    DOMString::from(service.uuid),
                                                    service.is_primary,
@@ -201,7 +207,7 @@ impl BluetoothRemoteGATTService {
         match services_vec {
             Ok(service_vec) => {
                 Ok(service_vec.into_iter()
-                              .map(|service| BluetoothRemoteGATTService::new(self.global().r(),
+                              .map(|service| BluetoothRemoteGATTService::new(self.global().r().as_global_scope(),
                                                                              &self.device.get(),
                                                                              DOMString::from(service.uuid),
                                                                              service.is_primary,
diff --git a/components/script/dom/canvasgradient.rs b/components/script/dom/canvasgradient.rs
index a805b485796..0fafc1c6f0f 100644
--- a/components/script/dom/canvasgradient.rs
+++ b/components/script/dom/canvasgradient.rs
@@ -9,11 +9,11 @@ use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::CanvasGradientBinding;
 use dom::bindings::codegen::Bindings::CanvasGradientBinding::CanvasGradientMethods;
 use dom::bindings::error::{Error, ErrorResult};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::num::Finite;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
+use dom::globalscope::GlobalScope;
 
 // https://html.spec.whatwg.org/multipage/#canvasgradient
 #[dom_struct]
@@ -38,7 +38,7 @@ impl CanvasGradient {
         }
     }
 
-    pub fn new(global: GlobalRef, style: CanvasGradientStyle) -> Root<CanvasGradient> {
+    pub fn new(global: &GlobalScope, style: CanvasGradientStyle) -> Root<CanvasGradient> {
         reflect_dom_object(box CanvasGradient::new_inherited(style),
                            global,
                            CanvasGradientBinding::Wrap)
diff --git a/components/script/dom/canvaspattern.rs b/components/script/dom/canvaspattern.rs
index 059710a296b..5fdb911c73a 100644
--- a/components/script/dom/canvaspattern.rs
+++ b/components/script/dom/canvaspattern.rs
@@ -4,10 +4,10 @@
 
 use canvas_traits::{FillOrStrokeStyle, RepetitionStyle, SurfaceStyle};
 use dom::bindings::codegen::Bindings::CanvasPatternBinding;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::canvasgradient::ToFillOrStrokeStyle;
+use dom::globalscope::GlobalScope;
 use euclid::size::Size2D;
 
 // https://html.spec.whatwg.org/multipage/#canvaspattern
@@ -43,7 +43,7 @@ impl CanvasPattern {
             origin_clean: origin_clean,
         }
     }
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                surface_data: Vec<u8>,
                surface_size: Size2D<i32>,
                repeat: RepetitionStyle,
diff --git a/components/script/dom/canvasrenderingcontext2d.rs b/components/script/dom/canvasrenderingcontext2d.rs
index 4b598407829..e4815e5f472 100644
--- a/components/script/dom/canvasrenderingcontext2d.rs
+++ b/components/script/dom/canvasrenderingcontext2d.rs
@@ -140,7 +140,7 @@ impl CanvasRenderingContext2D {
                size: Size2D<i32>)
                -> Root<CanvasRenderingContext2D> {
         reflect_dom_object(box CanvasRenderingContext2D::new_inherited(global, canvas, size),
-                           global,
+                           global.as_global_scope(),
                            CanvasRenderingContext2DBinding::Wrap)
     }
 
@@ -1016,12 +1016,12 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
 
         let sw = cmp::max(1, sw.abs().to_u32().unwrap());
         let sh = cmp::max(1, sh.abs().to_u32().unwrap());
-        Ok(ImageData::new(self.global().r(), sw, sh, None))
+        Ok(ImageData::new(self.global().r().as_global_scope(), sw, sh, None))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-createimagedata
     fn CreateImageData_(&self, imagedata: &ImageData) -> Fallible<Root<ImageData>> {
-        Ok(ImageData::new(self.global().r(),
+        Ok(ImageData::new(self.global().r().as_global_scope(),
                           imagedata.Width(),
                           imagedata.Height(),
                           None))
@@ -1077,7 +1077,7 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
             chunk[2] = UNPREMULTIPLY_TABLE[256 * alpha + chunk[2] as usize];
         }
 
-        Ok(ImageData::new(self.global().r(), sw, sh, Some(data)))
+        Ok(ImageData::new(self.global().r().as_global_scope(), sw, sh, Some(data)))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-putimagedata
@@ -1121,7 +1121,7 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
                             x1: Finite<f64>,
                             y1: Finite<f64>)
                             -> Root<CanvasGradient> {
-        CanvasGradient::new(self.global().r(),
+        CanvasGradient::new(self.global().r().as_global_scope(),
                             CanvasGradientStyle::Linear(LinearGradientStyle::new(*x0,
                                                                                  *y0,
                                                                                  *x1,
@@ -1142,7 +1142,7 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
             return Err(Error::IndexSize);
         }
 
-        Ok(CanvasGradient::new(self.global().r(),
+        Ok(CanvasGradient::new(self.global().r().as_global_scope(),
                                CanvasGradientStyle::Radial(RadialGradientStyle::new(*x0,
                                                                                     *y0,
                                                                                     *r0,
@@ -1182,7 +1182,7 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
         }
 
         if let Ok(rep) = RepetitionStyle::from_str(&repetition) {
-            Ok(CanvasPattern::new(self.global().r(),
+            Ok(CanvasPattern::new(self.global().r().as_global_scope(),
                                   image_data,
                                   image_size,
                                   rep,
diff --git a/components/script/dom/client.rs b/components/script/dom/client.rs
index 74ed61a52a7..7f51b251627 100644
--- a/components/script/dom/client.rs
+++ b/components/script/dom/client.rs
@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::ClientBinding::{ClientMethods, Wrap};
 use dom::bindings::codegen::Bindings::ClientBinding::FrameType;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::JS;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
@@ -36,7 +35,9 @@ impl Client {
     }
 
     pub fn new(window: &Window) -> Root<Client> {
-        reflect_dom_object(box Client::new_inherited(window.get_url()), GlobalRef::Window(window), Wrap)
+        reflect_dom_object(box Client::new_inherited(window.get_url()),
+                           window,
+                           Wrap)
     }
 }
 
diff --git a/components/script/dom/closeevent.rs b/components/script/dom/closeevent.rs
index 07e2fbaa943..7a076df8362 100644
--- a/components/script/dom/closeevent.rs
+++ b/components/script/dom/closeevent.rs
@@ -12,6 +12,7 @@ use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
 use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::globalscope::GlobalScope;
 use string_cache::Atom;
 
 #[dom_struct]
@@ -32,13 +33,13 @@ impl CloseEvent {
         }
     }
 
-    pub fn new_uninitialized(global: GlobalRef) -> Root<CloseEvent> {
+    pub fn new_uninitialized(global: &GlobalScope) -> Root<CloseEvent> {
         reflect_dom_object(box CloseEvent::new_inherited(false, 0, DOMString::new()),
                            global,
                            CloseEventBinding::Wrap)
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                type_: Atom,
                bubbles: EventBubbles,
                cancelable: EventCancelable,
@@ -63,7 +64,7 @@ impl CloseEvent {
                        -> Fallible<Root<CloseEvent>> {
         let bubbles = EventBubbles::from(init.parent.bubbles);
         let cancelable = EventCancelable::from(init.parent.cancelable);
-        Ok(CloseEvent::new(global,
+        Ok(CloseEvent::new(global.as_global_scope(),
                            Atom::from(type_),
                            bubbles,
                            cancelable,
diff --git a/components/script/dom/crypto.rs b/components/script/dom/crypto.rs
index 165a3834227..45c1c4639d5 100644
--- a/components/script/dom/crypto.rs
+++ b/components/script/dom/crypto.rs
@@ -8,9 +8,9 @@ use dom::bindings::codegen::Bindings::CryptoBinding;
 use dom::bindings::codegen::Bindings::CryptoBinding::CryptoMethods;
 use dom::bindings::conversions::array_buffer_view_data;
 use dom::bindings::error::{Error, Fallible};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::globalscope::GlobalScope;
 use js::jsapi::{JSContext, JSObject};
 use js::jsapi::{JS_GetArrayBufferViewType, Type};
 use rand::{OsRng, Rng};
@@ -33,7 +33,7 @@ impl Crypto {
         }
     }
 
-    pub fn new(global: GlobalRef) -> Root<Crypto> {
+    pub fn new(global: &GlobalScope) -> Root<Crypto> {
         reflect_dom_object(box Crypto::new_inherited(), global, CryptoBinding::Wrap)
     }
 }
diff --git a/components/script/dom/cssstyledeclaration.rs b/components/script/dom/cssstyledeclaration.rs
index 0b8c9d8a062..77aee91ce48 100644
--- a/components/script/dom/cssstyledeclaration.rs
+++ b/components/script/dom/cssstyledeclaration.rs
@@ -5,7 +5,6 @@
 use cssparser::ToCss;
 use dom::bindings::codegen::Bindings::CSSStyleDeclarationBinding::{self, CSSStyleDeclarationMethods};
 use dom::bindings::error::{Error, ErrorResult, Fallible};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
@@ -71,7 +70,7 @@ impl CSSStyleDeclaration {
         reflect_dom_object(box CSSStyleDeclaration::new_inherited(owner,
                                                                   pseudo,
                                                                   modification_access),
-                           GlobalRef::Window(global),
+                           global,
                            CSSStyleDeclarationBinding::Wrap)
     }
 
diff --git a/components/script/dom/customevent.rs b/components/script/dom/customevent.rs
index 301c3b6f816..043fd98193c 100644
--- a/components/script/dom/customevent.rs
+++ b/components/script/dom/customevent.rs
@@ -12,6 +12,7 @@ use dom::bindings::js::{MutHeapJSVal, Root};
 use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
 use dom::event::Event;
+use dom::globalscope::GlobalScope;
 use js::jsapi::{HandleValue, JSContext};
 use js::jsval::JSVal;
 use string_cache::Atom;
@@ -32,12 +33,12 @@ impl CustomEvent {
         }
     }
 
-    pub fn new_uninitialized(global: GlobalRef) -> Root<CustomEvent> {
+    pub fn new_uninitialized(global: &GlobalScope) -> Root<CustomEvent> {
         reflect_dom_object(box CustomEvent::new_inherited(),
                            global,
                            CustomEventBinding::Wrap)
     }
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                type_: Atom,
                bubbles: bool,
                cancelable: bool,
@@ -52,7 +53,7 @@ impl CustomEvent {
                        type_: DOMString,
                        init: &CustomEventBinding::CustomEventInit)
                        -> Fallible<Root<CustomEvent>> {
-        Ok(CustomEvent::new(global,
+        Ok(CustomEvent::new(global.as_global_scope(),
                             Atom::from(type_),
                             init.parent.bubbles,
                             init.parent.cancelable,
diff --git a/components/script/dom/document.rs b/components/script/dom/document.rs
index 5e834ef52cd..7857e46ecfe 100644
--- a/components/script/dom/document.rs
+++ b/components/script/dom/document.rs
@@ -1848,7 +1848,7 @@ impl Document {
                                                                       doc_loader,
                                                                       referrer,
                                                                       referrer_policy),
-                                          GlobalRef::Window(window),
+                                          window,
                                           DocumentBinding::Wrap);
         {
             let node = document.upcast::<Node>();
@@ -2325,13 +2325,13 @@ impl DocumentMethods for Document {
             "mouseevents" | "mouseevent" =>
                 Ok(Root::upcast(MouseEvent::new_uninitialized(&self.window))),
             "customevent" =>
-                Ok(Root::upcast(CustomEvent::new_uninitialized(GlobalRef::Window(&self.window)))),
+                Ok(Root::upcast(CustomEvent::new_uninitialized(self.window.upcast()))),
             "htmlevents" | "events" | "event" | "svgevents" =>
-                Ok(Event::new_uninitialized(GlobalRef::Window(&self.window))),
+                Ok(Event::new_uninitialized(&self.window.upcast())),
             "keyboardevent" =>
                 Ok(Root::upcast(KeyboardEvent::new_uninitialized(&self.window))),
             "messageevent" =>
-                Ok(Root::upcast(MessageEvent::new_uninitialized(GlobalRef::Window(&self.window)))),
+                Ok(Root::upcast(MessageEvent::new_uninitialized(self.window.upcast()))),
             "touchevent" =>
                 Ok(Root::upcast(
                     TouchEvent::new_uninitialized(&self.window,
@@ -2341,25 +2341,25 @@ impl DocumentMethods for Document {
                     )
                 )),
             "webglcontextevent" =>
-                Ok(Root::upcast(WebGLContextEvent::new_uninitialized(GlobalRef::Window(&self.window)))),
+                Ok(Root::upcast(WebGLContextEvent::new_uninitialized(self.window.upcast()))),
             "storageevent" => {
                 let USVString(url) = self.URL();
                 Ok(Root::upcast(StorageEvent::new_uninitialized(&self.window, DOMString::from(url))))
             },
             "progressevent" =>
-                Ok(Root::upcast(ProgressEvent::new_uninitialized(&self.window))),
+                Ok(Root::upcast(ProgressEvent::new_uninitialized(self.window.upcast()))),
             "focusevent" =>
-                Ok(Root::upcast(FocusEvent::new_uninitialized(GlobalRef::Window(&self.window)))),
+                Ok(Root::upcast(FocusEvent::new_uninitialized(self.window.upcast()))),
             "errorevent" =>
-                Ok(Root::upcast(ErrorEvent::new_uninitialized(GlobalRef::Window(&self.window)))),
+                Ok(Root::upcast(ErrorEvent::new_uninitialized(self.window.upcast()))),
             "closeevent" =>
-                Ok(Root::upcast(CloseEvent::new_uninitialized(GlobalRef::Window(&self.window)))),
+                Ok(Root::upcast(CloseEvent::new_uninitialized(self.window.upcast()))),
             "popstateevent" =>
-                Ok(Root::upcast(PopStateEvent::new_uninitialized(GlobalRef::Window(&self.window)))),
+                Ok(Root::upcast(PopStateEvent::new_uninitialized(self.window.upcast()))),
             "hashchangeevent" =>
-                Ok(Root::upcast(HashChangeEvent::new_uninitialized(GlobalRef::Window(&self.window)))),
+                Ok(Root::upcast(HashChangeEvent::new_uninitialized(&self.window.upcast()))),
             "pagetransitionevent" =>
-                Ok(Root::upcast(PageTransitionEvent::new_uninitialized(GlobalRef::Window(&self.window)))),
+                Ok(Root::upcast(PageTransitionEvent::new_uninitialized(self.window.upcast()))),
             _ =>
                 Err(Error::NotSupported),
         }
@@ -2993,7 +2993,7 @@ impl DocumentProgressHandler {
     fn dispatch_load(&self) {
         let document = self.addr.root();
         let window = document.window();
-        let event = Event::new(GlobalRef::Window(window),
+        let event = Event::new(window.upcast(),
                                atom!("load"),
                                EventBubbles::DoesNotBubble,
                                EventCancelable::NotCancelable);
diff --git a/components/script/dom/domexception.rs b/components/script/dom/domexception.rs
index e32d5dc40ac..2a5946193b6 100644
--- a/components/script/dom/domexception.rs
+++ b/components/script/dom/domexception.rs
@@ -5,10 +5,10 @@
 use dom::bindings::codegen::Bindings::DOMExceptionBinding;
 use dom::bindings::codegen::Bindings::DOMExceptionBinding::DOMExceptionConstants;
 use dom::bindings::codegen::Bindings::DOMExceptionBinding::DOMExceptionMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
+use dom::globalscope::GlobalScope;
 
 #[repr(u16)]
 #[derive(JSTraceable, Copy, Clone, Debug, HeapSizeOf)]
@@ -52,7 +52,7 @@ impl DOMException {
         }
     }
 
-    pub fn new(global: GlobalRef, code: DOMErrorName) -> Root<DOMException> {
+    pub fn new(global: &GlobalScope, code: DOMErrorName) -> Root<DOMException> {
         reflect_dom_object(box DOMException::new_inherited(code),
                            global,
                            DOMExceptionBinding::Wrap)
diff --git a/components/script/dom/domimplementation.rs b/components/script/dom/domimplementation.rs
index dd55630204c..42d744bd6a5 100644
--- a/components/script/dom/domimplementation.rs
+++ b/components/script/dom/domimplementation.rs
@@ -8,7 +8,6 @@ use dom::bindings::codegen::Bindings::DOMImplementationBinding::DOMImplementatio
 use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
 use dom::bindings::error::Fallible;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
@@ -43,7 +42,7 @@ impl DOMImplementation {
     pub fn new(document: &Document) -> Root<DOMImplementation> {
         let window = document.window();
         reflect_dom_object(box DOMImplementation::new_inherited(document),
-                           GlobalRef::Window(window),
+                           window,
                            DOMImplementationBinding::Wrap)
     }
 }
diff --git a/components/script/dom/dommatrix.rs b/components/script/dom/dommatrix.rs
index c63290c9326..2ccf4b126fb 100644
--- a/components/script/dom/dommatrix.rs
+++ b/components/script/dom/dommatrix.rs
@@ -10,6 +10,7 @@ use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
 use dom::dommatrixreadonly::{dommatrixinit_to_matrix, DOMMatrixReadOnly, entries_to_matrix};
+use dom::globalscope::GlobalScope;
 use euclid::Matrix4D;
 
 
@@ -20,7 +21,7 @@ pub struct DOMMatrix {
 
 impl DOMMatrix {
     #[allow(unrooted_must_root)]
-    pub fn new(global: GlobalRef, is2D: bool, matrix: Matrix4D<f64>) -> Root<Self> {
+    pub fn new(global: &GlobalScope, is2D: bool, matrix: Matrix4D<f64>) -> Root<Self> {
         let dommatrix = Self::new_inherited(is2D, matrix);
         reflect_dom_object(box dommatrix, global, Wrap)
     }
@@ -40,7 +41,7 @@ impl DOMMatrix {
     pub fn Constructor_(global: GlobalRef, entries: Vec<f64>) -> Fallible<Root<Self>> {
         entries_to_matrix(&entries[..])
             .map(|(is2D, matrix)| {
-                Self::new(global, is2D, matrix)
+                Self::new(global.as_global_scope(), is2D, matrix)
             })
     }
 
@@ -48,11 +49,11 @@ impl DOMMatrix {
     pub fn FromMatrix(global: GlobalRef, other: &DOMMatrixInit) -> Fallible<Root<Self>> {
         dommatrixinit_to_matrix(&other)
             .map(|(is2D, matrix)| {
-                Self::new(global, is2D, matrix)
+                Self::new(global.as_global_scope(), is2D, matrix)
             })
     }
 
-    pub fn from_readonly(global: GlobalRef, ro: &DOMMatrixReadOnly) -> Root<Self> {
+    pub fn from_readonly(global: &GlobalScope, ro: &DOMMatrixReadOnly) -> Root<Self> {
         Self::new(global, ro.is_2d(), ro.matrix().clone())
     }
 }
diff --git a/components/script/dom/dommatrixreadonly.rs b/components/script/dom/dommatrixreadonly.rs
index 5c6d66c9a1a..b643ef3131a 100644
--- a/components/script/dom/dommatrixreadonly.rs
+++ b/components/script/dom/dommatrixreadonly.rs
@@ -13,6 +13,7 @@ use dom::bindings::js::Root;
 use dom::bindings::reflector::{reflect_dom_object, Reflectable, Reflector};
 use dom::dommatrix::DOMMatrix;
 use dom::dompoint::DOMPoint;
+use dom::globalscope::GlobalScope;
 use euclid::{Matrix4D, Point4D, Radians};
 use std::cell::{Cell, Ref};
 use std::f64;
@@ -26,7 +27,7 @@ pub struct DOMMatrixReadOnly {
 
 impl DOMMatrixReadOnly {
     #[allow(unrooted_must_root)]
-    pub fn new(global: GlobalRef, is2D: bool, matrix: Matrix4D<f64>) -> Root<Self> {
+    pub fn new(global: &GlobalScope, is2D: bool, matrix: Matrix4D<f64>) -> Root<Self> {
         let dommatrix = Self::new_inherited(is2D, matrix);
         reflect_dom_object(box dommatrix, global, Wrap)
     }
@@ -41,14 +42,14 @@ impl DOMMatrixReadOnly {
 
     // https://drafts.fxtf.org/geometry-1/#dom-dommatrixreadonly-dommatrixreadonly
     pub fn Constructor(global: GlobalRef) -> Fallible<Root<Self>> {
-        Ok(Self::new(global, true, Matrix4D::identity()))
+        Ok(Self::new(global.as_global_scope(), true, Matrix4D::identity()))
     }
 
     // https://drafts.fxtf.org/geometry-1/#dom-dommatrixreadonly-dommatrixreadonly-numbersequence
     pub fn Constructor_(global: GlobalRef, entries: Vec<f64>) -> Fallible<Root<Self>> {
         entries_to_matrix(&entries[..])
             .map(|(is2D, matrix)| {
-                Self::new(global, is2D, matrix)
+                Self::new(global.as_global_scope(), is2D, matrix)
             })
     }
 
@@ -56,7 +57,7 @@ impl DOMMatrixReadOnly {
     pub fn FromMatrix(global: GlobalRef, other: &DOMMatrixInit) -> Fallible<Root<Self>> {
         dommatrixinit_to_matrix(&other)
             .map(|(is2D, matrix)| {
-                Self::new(global, is2D, matrix)
+                Self::new(global.as_global_scope(), is2D, matrix)
             })
     }
 
@@ -463,48 +464,50 @@ impl DOMMatrixReadOnlyMethods for DOMMatrixReadOnly {
 
     // https://drafts.fxtf.org/geometry-1/#dom-dommatrixreadonly-translate
     fn Translate(&self, tx: f64, ty: f64, tz: f64) -> Root<DOMMatrix> {
-        DOMMatrix::from_readonly(self.global().r(), self).TranslateSelf(tx, ty, tz)
+        DOMMatrix::from_readonly(self.global().r().as_global_scope(), self).TranslateSelf(tx, ty, tz)
     }
 
     // https://drafts.fxtf.org/geometry-1/#dom-dommatrixreadonly-scale
     fn Scale(&self, scaleX: f64, scaleY: Option<f64>, scaleZ: f64,
                     originX: f64, originY: f64, originZ: f64) -> Root<DOMMatrix> {
-        DOMMatrix::from_readonly(self.global().r(), self).ScaleSelf(scaleX, scaleY, scaleZ, originX, originY, originZ)
+        DOMMatrix::from_readonly(self.global().r().as_global_scope(), self)
+            .ScaleSelf(scaleX, scaleY, scaleZ, originX, originY, originZ)
     }
 
     // https://drafts.fxtf.org/geometry-1/#dom-dommatrixreadonly-scale3d
     fn Scale3d(&self, scale: f64, originX: f64, originY: f64, originZ: f64) -> Root<DOMMatrix> {
-        DOMMatrix::from_readonly(self.global().r(), self).Scale3dSelf(scale, originX, originY, originZ)
+        DOMMatrix::from_readonly(self.global().r().as_global_scope(), self)
+            .Scale3dSelf(scale, originX, originY, originZ)
     }
 
     // https://drafts.fxtf.org/geometry-1/#dom-dommatrixreadonly-rotate
     fn Rotate(&self, rotX: f64, rotY: Option<f64>, rotZ: Option<f64>) -> Root<DOMMatrix> {
-        DOMMatrix::from_readonly(self.global().r(), self).RotateSelf(rotX, rotY, rotZ)
+        DOMMatrix::from_readonly(self.global().r().as_global_scope(), self).RotateSelf(rotX, rotY, rotZ)
     }
 
     // https://drafts.fxtf.org/geometry-1/#dom-dommatrixreadonly-rotatefromvector
     fn RotateFromVector(&self, x: f64, y: f64) -> Root<DOMMatrix> {
-        DOMMatrix::from_readonly(self.global().r(), self).RotateFromVectorSelf(x, y)
+        DOMMatrix::from_readonly(self.global().r().as_global_scope(), self).RotateFromVectorSelf(x, y)
     }
 
     // https://drafts.fxtf.org/geometry-1/#dom-dommatrixreadonly-rotateaxisangle
     fn RotateAxisAngle(&self, x: f64, y: f64, z: f64, angle: f64) -> Root<DOMMatrix> {
-        DOMMatrix::from_readonly(self.global().r(), self).RotateAxisAngleSelf(x, y, z, angle)
+        DOMMatrix::from_readonly(self.global().r().as_global_scope(), self).RotateAxisAngleSelf(x, y, z, angle)
     }
 
     // https://drafts.fxtf.org/geometry-1/#dom-dommatrixreadonly-skewx
     fn SkewX(&self, sx: f64) -> Root<DOMMatrix> {
-        DOMMatrix::from_readonly(self.global().r(), self).SkewXSelf(sx)
+        DOMMatrix::from_readonly(self.global().r().as_global_scope(), self).SkewXSelf(sx)
     }
 
     // https://drafts.fxtf.org/geometry-1/#dom-dommatrixreadonly-skewy
     fn SkewY(&self, sy: f64) -> Root<DOMMatrix> {
-        DOMMatrix::from_readonly(self.global().r(), self).SkewYSelf(sy)
+        DOMMatrix::from_readonly(self.global().r().as_global_scope(), self).SkewYSelf(sy)
     }
 
     // https://drafts.fxtf.org/geometry-1/#dom-dommatrixreadonly-multiply
     fn Multiply(&self, other: &DOMMatrixInit) -> Fallible<Root<DOMMatrix>> {
-        DOMMatrix::from_readonly(self.global().r(), self).MultiplySelf(&other)
+        DOMMatrix::from_readonly(self.global().r().as_global_scope(), self).MultiplySelf(&other)
     }
 
     // https://drafts.fxtf.org/geometry-1/#dom-dommatrixreadonly-flipx
@@ -515,7 +518,7 @@ impl DOMMatrixReadOnlyMethods for DOMMatrixReadOnly {
                                         0.0, 0.0, 1.0, 0.0,
                                         0.0, 0.0, 0.0, 1.0);
         let matrix = flip.post_mul(&self.matrix.borrow());
-        DOMMatrix::new(self.global().r(), is2D, matrix)
+        DOMMatrix::new(self.global().r().as_global_scope(), is2D, matrix)
     }
 
     // https://drafts.fxtf.org/geometry-1/#dom-dommatrixreadonly-flipy
@@ -526,19 +529,24 @@ impl DOMMatrixReadOnlyMethods for DOMMatrixReadOnly {
                                        0.0,  0.0, 1.0, 0.0,
                                        0.0,  0.0, 0.0, 1.0);
         let matrix = flip.post_mul(&self.matrix.borrow());
-        DOMMatrix::new(self.global().r(), is2D, matrix)
+        DOMMatrix::new(self.global().r().as_global_scope(), is2D, matrix)
     }
 
     // https://drafts.fxtf.org/geometry-1/#dom-dommatrixreadonly-inverse
     fn Inverse(&self) -> Root<DOMMatrix> {
-        DOMMatrix::from_readonly(self.global().r(), self).InvertSelf()
+        DOMMatrix::from_readonly(self.global().r().as_global_scope(), self).InvertSelf()
     }
 
     // https://drafts.fxtf.org/geometry-1/#dom-dommatrixreadonly-transformpoint
     fn TransformPoint(&self, point: &DOMPointInit) -> Root<DOMPoint> {
         let matrix = self.matrix.borrow();
         let result = matrix.transform_point4d(&Point4D::new(point.x, point.y, point.z, point.w));
-        DOMPoint::new(self.global().r(), result.x as f64, result.y as f64, result.z as f64, result.w as f64)
+        DOMPoint::new(
+            self.global().r().as_global_scope(),
+            result.x as f64,
+            result.y as f64,
+            result.z as f64,
+            result.w as f64)
     }
 }
 
diff --git a/components/script/dom/domparser.rs b/components/script/dom/domparser.rs
index a52f0b8b82f..cf82cad01ca 100644
--- a/components/script/dom/domparser.rs
+++ b/components/script/dom/domparser.rs
@@ -38,7 +38,7 @@ impl DOMParser {
 
     pub fn new(window: &Window) -> Root<DOMParser> {
         reflect_dom_object(box DOMParser::new_inherited(window),
-                           GlobalRef::Window(window),
+                           window,
                            DOMParserBinding::Wrap)
     }
 
diff --git a/components/script/dom/dompoint.rs b/components/script/dom/dompoint.rs
index 906a30ea617..49a873a25fc 100644
--- a/components/script/dom/dompoint.rs
+++ b/components/script/dom/dompoint.rs
@@ -9,6 +9,7 @@ use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
 use dom::dompointreadonly::{DOMPointReadOnly, DOMPointWriteMethods};
+use dom::globalscope::GlobalScope;
 
 // http://dev.w3.org/fxtf/geometry/Overview.html#dompoint
 #[dom_struct]
@@ -23,7 +24,7 @@ impl DOMPoint {
         }
     }
 
-    pub fn new(global: GlobalRef, x: f64, y: f64, z: f64, w: f64) -> Root<DOMPoint> {
+    pub fn new(global: &GlobalScope, x: f64, y: f64, z: f64, w: f64) -> Root<DOMPoint> {
         reflect_dom_object(box DOMPoint::new_inherited(x, y, z, w), global, Wrap)
     }
 
@@ -33,10 +34,10 @@ impl DOMPoint {
                        z: f64,
                        w: f64)
                        -> Fallible<Root<DOMPoint>> {
-        Ok(DOMPoint::new(global, x, y, z, w))
+        Ok(DOMPoint::new(global.as_global_scope(), x, y, z, w))
     }
 
-    pub fn new_from_init(global: GlobalRef, p: &DOMPointInit) -> Root<DOMPoint> {
+    pub fn new_from_init(global: &GlobalScope, p: &DOMPointInit) -> Root<DOMPoint> {
         DOMPoint::new(global, p.x, p.y, p.z, p.w)
     }
 }
diff --git a/components/script/dom/dompointreadonly.rs b/components/script/dom/dompointreadonly.rs
index aa7efa76267..f905db356ca 100644
--- a/components/script/dom/dompointreadonly.rs
+++ b/components/script/dom/dompointreadonly.rs
@@ -7,6 +7,7 @@ use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::globalscope::GlobalScope;
 use std::cell::Cell;
 
 // http://dev.w3.org/fxtf/geometry/Overview.html#dompointreadonly
@@ -30,7 +31,7 @@ impl DOMPointReadOnly {
         }
     }
 
-    pub fn new(global: GlobalRef, x: f64, y: f64, z: f64, w: f64) -> Root<DOMPointReadOnly> {
+    pub fn new(global: &GlobalScope, x: f64, y: f64, z: f64, w: f64) -> Root<DOMPointReadOnly> {
         reflect_dom_object(box DOMPointReadOnly::new_inherited(x, y, z, w),
                            global,
                            Wrap)
@@ -42,7 +43,7 @@ impl DOMPointReadOnly {
                        z: f64,
                        w: f64)
                        -> Fallible<Root<DOMPointReadOnly>> {
-        Ok(DOMPointReadOnly::new(global, x, y, z, w))
+        Ok(DOMPointReadOnly::new(global.as_global_scope(), x, y, z, w))
     }
 }
 
diff --git a/components/script/dom/domquad.rs b/components/script/dom/domquad.rs
index a9af14d3d69..238258889a8 100644
--- a/components/script/dom/domquad.rs
+++ b/components/script/dom/domquad.rs
@@ -11,6 +11,7 @@ use dom::bindings::js::{Root, JS};
 use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::dompoint::DOMPoint;
 use dom::domrect::DOMRect;
+use dom::globalscope::GlobalScope;
 
 // https://drafts.fxtf.org/geometry/#DOMQuad
 #[dom_struct]
@@ -37,7 +38,7 @@ impl DOMQuad {
         }
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                p1: &DOMPoint,
                p2: &DOMPoint,
                p3: &DOMPoint,
@@ -53,6 +54,7 @@ impl DOMQuad {
                        p3: &DOMPointInit,
                        p4: &DOMPointInit)
                        -> Fallible<Root<DOMQuad>> {
+        let global = global.as_global_scope();
         Ok(DOMQuad::new(global,
                         &*DOMPoint::new_from_init(global, p1),
                         &*DOMPoint::new_from_init(global, p2),
@@ -62,6 +64,7 @@ impl DOMQuad {
 
     // https://drafts.fxtf.org/geometry/#dom-domquad-fromrect
     pub fn FromRect(global: GlobalRef, other: &DOMRectInit) -> Root<DOMQuad> {
+        let global = global.as_global_scope();
         DOMQuad::new(global,
                      &*DOMPoint::new(global, other.x, other.y, 0f64, 1f64),
                      &*DOMPoint::new(global, other.x + other.width, other.y, 0f64, 1f64),
@@ -71,6 +74,7 @@ impl DOMQuad {
 
     // https://drafts.fxtf.org/geometry/#dom-domquad-fromquad
     pub fn FromQuad(global: GlobalRef, other: &DOMQuadInit) -> Root<DOMQuad> {
+        let global = global.as_global_scope();
         DOMQuad::new(global,
                      &DOMPoint::new_from_init(global, &other.p1),
                      &DOMPoint::new_from_init(global, &other.p2),
@@ -107,7 +111,7 @@ impl DOMQuadMethods for DOMQuad {
         let right = self.p1.X().max(self.p2.X()).max(self.p3.X()).max(self.p4.X());
         let bottom = self.p1.Y().max(self.p2.Y()).max(self.p3.Y()).max(self.p4.Y());
 
-        DOMRect::new(self.global().r(),
+        DOMRect::new(self.global().r().as_global_scope(),
                      left,
                      top,
                      right - left,
diff --git a/components/script/dom/domrect.rs b/components/script/dom/domrect.rs
index 086e21882c6..f70eda2ead1 100644
--- a/components/script/dom/domrect.rs
+++ b/components/script/dom/domrect.rs
@@ -10,6 +10,7 @@ use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
 use dom::domrectreadonly::DOMRectReadOnly;
+use dom::globalscope::GlobalScope;
 
 #[dom_struct]
 pub struct DOMRect {
@@ -23,7 +24,7 @@ impl DOMRect {
         }
     }
 
-    pub fn new(global: GlobalRef, x: f64, y: f64, width: f64, height: f64) -> Root<DOMRect> {
+    pub fn new(global: &GlobalScope, x: f64, y: f64, width: f64, height: f64) -> Root<DOMRect> {
         reflect_dom_object(box DOMRect::new_inherited(x, y, width, height),
                            global,
                            DOMRectBinding::Wrap)
@@ -35,7 +36,7 @@ impl DOMRect {
                        width: f64,
                        height: f64)
                        -> Fallible<Root<DOMRect>> {
-        Ok(DOMRect::new(global, x, y, width, height))
+        Ok(DOMRect::new(global.as_global_scope(), x, y, width, height))
     }
 }
 
diff --git a/components/script/dom/domrectlist.rs b/components/script/dom/domrectlist.rs
index 86774a49ff3..392aa18997e 100644
--- a/components/script/dom/domrectlist.rs
+++ b/components/script/dom/domrectlist.rs
@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::DOMRectListBinding;
 use dom::bindings::codegen::Bindings::DOMRectListBinding::DOMRectListMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::domrect::DOMRect;
@@ -30,7 +29,7 @@ impl DOMRectList {
         where T: Iterator<Item = Root<DOMRect>>
     {
         reflect_dom_object(box DOMRectList::new_inherited(rects),
-                           GlobalRef::Window(window),
+                           window,
                            DOMRectListBinding::Wrap)
     }
 }
diff --git a/components/script/dom/domrectreadonly.rs b/components/script/dom/domrectreadonly.rs
index 8e72dae6942..a9d87ec3947 100644
--- a/components/script/dom/domrectreadonly.rs
+++ b/components/script/dom/domrectreadonly.rs
@@ -7,6 +7,7 @@ use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::globalscope::GlobalScope;
 use std::cell::Cell;
 
 #[dom_struct]
@@ -29,7 +30,7 @@ impl DOMRectReadOnly {
         }
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                x: f64,
                y: f64,
                width: f64,
@@ -46,7 +47,7 @@ impl DOMRectReadOnly {
                        width: f64,
                        height: f64)
                        -> Fallible<Root<DOMRectReadOnly>> {
-        Ok(DOMRectReadOnly::new(global, x, y, width, height))
+        Ok(DOMRectReadOnly::new(global.as_global_scope(), x, y, width, height))
     }
 
     pub fn set_x(&self, value: f64) {
diff --git a/components/script/dom/domstringmap.rs b/components/script/dom/domstringmap.rs
index 11479d6b5df..687c10ec898 100644
--- a/components/script/dom/domstringmap.rs
+++ b/components/script/dom/domstringmap.rs
@@ -5,7 +5,6 @@
 use dom::bindings::codegen::Bindings::DOMStringMapBinding;
 use dom::bindings::codegen::Bindings::DOMStringMapBinding::DOMStringMapMethods;
 use dom::bindings::error::ErrorResult;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
@@ -29,7 +28,7 @@ impl DOMStringMap {
     pub fn new(element: &HTMLElement) -> Root<DOMStringMap> {
         let window = window_from_node(element);
         reflect_dom_object(box DOMStringMap::new_inherited(element),
-                           GlobalRef::Window(window.r()),
+                           window.r(),
                            DOMStringMapBinding::Wrap)
     }
 }
diff --git a/components/script/dom/domtokenlist.rs b/components/script/dom/domtokenlist.rs
index c1c09de94c2..00f6ba1abb1 100644
--- a/components/script/dom/domtokenlist.rs
+++ b/components/script/dom/domtokenlist.rs
@@ -6,7 +6,6 @@ use dom::attr::Attr;
 use dom::bindings::codegen::Bindings::DOMTokenListBinding;
 use dom::bindings::codegen::Bindings::DOMTokenListBinding::DOMTokenListMethods;
 use dom::bindings::error::{Error, ErrorResult, Fallible};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
@@ -34,7 +33,7 @@ impl DOMTokenList {
     pub fn new(element: &Element, local_name: &Atom) -> Root<DOMTokenList> {
         let window = window_from_node(element);
         reflect_dom_object(box DOMTokenList::new_inherited(element, local_name.clone()),
-                           GlobalRef::Window(window.r()),
+                           window.r(),
                            DOMTokenListBinding::Wrap)
     }
 
diff --git a/components/script/dom/element.rs b/components/script/dom/element.rs
index 5e00cb71c75..13937bf904c 100644
--- a/components/script/dom/element.rs
+++ b/components/script/dom/element.rs
@@ -21,7 +21,6 @@ use dom::bindings::codegen::Bindings::WindowBinding::{ScrollBehavior, ScrollToOp
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::codegen::UnionTypes::NodeOrString;
 use dom::bindings::error::{Error, ErrorResult, Fallible};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::{Castable, ElementTypeId, HTMLElementTypeId, NodeTypeId};
 use dom::bindings::js::{JS, LayoutJS, MutNullableHeap};
 use dom::bindings::js::{Root, RootedReference};
@@ -1589,7 +1588,7 @@ impl ElementMethods for Element {
         let win = window_from_node(self);
         let raw_rects = self.upcast::<Node>().content_boxes();
         let rects = raw_rects.iter().map(|rect| {
-            DOMRect::new(GlobalRef::Window(win.r()),
+            DOMRect::new(win.upcast(),
                          rect.origin.x.to_f64_px(),
                          rect.origin.y.to_f64_px(),
                          rect.size.width.to_f64_px(),
@@ -1602,7 +1601,7 @@ impl ElementMethods for Element {
     fn GetBoundingClientRect(&self) -> Root<DOMRect> {
         let win = window_from_node(self);
         let rect = self.upcast::<Node>().bounding_content_box();
-        DOMRect::new(GlobalRef::Window(win.r()),
+        DOMRect::new(win.upcast(),
                      rect.origin.x.to_f64_px(),
                      rect.origin.y.to_f64_px(),
                      rect.size.width.to_f64_px(),
diff --git a/components/script/dom/errorevent.rs b/components/script/dom/errorevent.rs
index 61db675f551..394ce749cdb 100644
--- a/components/script/dom/errorevent.rs
+++ b/components/script/dom/errorevent.rs
@@ -13,6 +13,7 @@ use dom::bindings::js::{MutHeapJSVal, Root};
 use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
 use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::globalscope::GlobalScope;
 use js::jsapi::{HandleValue, JSContext};
 use js::jsval::JSVal;
 use std::cell::Cell;
@@ -41,13 +42,13 @@ impl ErrorEvent {
         }
     }
 
-    pub fn new_uninitialized(global: GlobalRef) -> Root<ErrorEvent> {
+    pub fn new_uninitialized(global: &GlobalScope) -> Root<ErrorEvent> {
         reflect_dom_object(box ErrorEvent::new_inherited(),
                            global,
                            ErrorEventBinding::Wrap)
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                type_: Atom,
                bubbles: EventBubbles,
                cancelable: EventCancelable,
@@ -94,11 +95,16 @@ impl ErrorEvent {
         // Dictionaries need to be rooted
         // https://github.com/servo/servo/issues/6381
         rooted!(in(global.get_cx()) let error = init.error);
-        let event = ErrorEvent::new(global, Atom::from(type_),
-                                bubbles, cancelable,
-                                msg, file_name,
-                                line_num, col_num,
-                                error.handle());
+        let event = ErrorEvent::new(
+                global.as_global_scope(),
+                Atom::from(type_),
+                bubbles,
+                cancelable,
+                msg,
+                file_name,
+                line_num,
+                col_num,
+                error.handle());
         Ok(event)
     }
 
diff --git a/components/script/dom/event.rs b/components/script/dom/event.rs
index a6dfe7c9ac4..3f5a7c24c8a 100644
--- a/components/script/dom/event.rs
+++ b/components/script/dom/event.rs
@@ -13,6 +13,7 @@ use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
 use dom::eventdispatcher::EventStatus;
 use dom::eventtarget::EventTarget;
+use dom::globalscope::GlobalScope;
 use script_thread::Runnable;
 use std::cell::Cell;
 use std::default::Default;
@@ -115,13 +116,13 @@ impl Event {
         }
     }
 
-    pub fn new_uninitialized(global: GlobalRef) -> Root<Event> {
+    pub fn new_uninitialized(global: &GlobalScope) -> Root<Event> {
         reflect_dom_object(box Event::new_inherited(),
                            global,
                            EventBinding::Wrap)
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                type_: Atom,
                bubbles: EventBubbles,
                cancelable: EventCancelable) -> Root<Event> {
@@ -135,7 +136,7 @@ impl Event {
                        init: &EventBinding::EventInit) -> Fallible<Root<Event>> {
         let bubbles = EventBubbles::from(init.bubbles);
         let cancelable = EventCancelable::from(init.cancelable);
-        Ok(Event::new(global, Atom::from(type_), bubbles, cancelable))
+        Ok(Event::new(global.as_global_scope(), Atom::from(type_), bubbles, cancelable))
     }
 
     pub fn init_event(&self, type_: Atom, bubbles: bool, cancelable: bool) {
diff --git a/components/script/dom/eventsource.rs b/components/script/dom/eventsource.rs
index 4007e391852..667627e1e83 100644
--- a/components/script/dom/eventsource.rs
+++ b/components/script/dom/eventsource.rs
@@ -11,6 +11,7 @@ use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
 use dom::eventtarget::EventTarget;
+use dom::globalscope::GlobalScope;
 use std::cell::Cell;
 use url::Url;
 
@@ -42,8 +43,10 @@ impl EventSource {
         }
     }
 
-    fn new(global: GlobalRef, url: Url, with_credentials: bool) -> Root<EventSource> {
-        reflect_dom_object(box EventSource::new_inherited(url, with_credentials), global, Wrap)
+    fn new(global: &GlobalScope, url: Url, with_credentials: bool) -> Root<EventSource> {
+        reflect_dom_object(box EventSource::new_inherited(url, with_credentials),
+                           global,
+                           Wrap)
     }
 
     pub fn Constructor(global: GlobalRef,
@@ -56,7 +59,7 @@ impl EventSource {
             Err(_) => return Err(Error::Syntax)
         };
         // Step 3
-        let event_source = EventSource::new(global, url, event_source_init.withCredentials);
+        let event_source = EventSource::new(global.as_global_scope(), url, event_source_init.withCredentials);
         // Step 4
         // Step 5
         // Step 6
diff --git a/components/script/dom/eventtarget.rs b/components/script/dom/eventtarget.rs
index 9bdaac20288..fb647d3d590 100644
--- a/components/script/dom/eventtarget.rs
+++ b/components/script/dom/eventtarget.rs
@@ -500,8 +500,8 @@ impl EventTarget {
                       bubbles: EventBubbles,
                       cancelable: EventCancelable)
                       -> Root<Event> {
-        let global = self.global();
-        let event = Event::new(global.r(), Atom::from(name), bubbles, cancelable);
+        let event = Event::new(
+                self.global().r().as_global_scope(), Atom::from(name), bubbles, cancelable);
 
         event.fire(self);
 
diff --git a/components/script/dom/extendableevent.rs b/components/script/dom/extendableevent.rs
index ffb6c3baad2..1888888e841 100644
--- a/components/script/dom/extendableevent.rs
+++ b/components/script/dom/extendableevent.rs
@@ -11,6 +11,7 @@ use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
 use dom::event::Event;
+use dom::globalscope::GlobalScope;
 use js::jsapi::{HandleValue, JSContext};
 use string_cache::Atom;
 
@@ -28,7 +29,7 @@ impl ExtendableEvent {
             extensions_allowed: true
         }
     }
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                type_: Atom,
                bubbles: bool,
                cancelable: bool)
@@ -44,7 +45,7 @@ impl ExtendableEvent {
     pub fn Constructor(global: GlobalRef,
                        type_: DOMString,
                        init: &ExtendableEventBinding::ExtendableEventInit) -> Fallible<Root<ExtendableEvent>> {
-        Ok(ExtendableEvent::new(global,
+        Ok(ExtendableEvent::new(global.as_global_scope(),
                                 Atom::from(type_),
                                 init.parent.bubbles,
                                 init.parent.cancelable))
diff --git a/components/script/dom/extendablemessageevent.rs b/components/script/dom/extendablemessageevent.rs
index 202c81c0416..a0d8b3cf76b 100644
--- a/components/script/dom/extendablemessageevent.rs
+++ b/components/script/dom/extendablemessageevent.rs
@@ -13,6 +13,7 @@ use dom::bindings::str::DOMString;
 use dom::event::Event;
 use dom::eventtarget::EventTarget;
 use dom::extendableevent::ExtendableEvent;
+use dom::globalscope::GlobalScope;
 use js::jsapi::{HandleValue, Heap, JSContext};
 use js::jsval::JSVal;
 use std::default::Default;
@@ -27,7 +28,7 @@ pub struct ExtendableMessageEvent {
 }
 
 impl ExtendableMessageEvent {
-    pub fn new(global: GlobalRef, type_: Atom,
+    pub fn new(global: &GlobalScope, type_: Atom,
                bubbles: bool, cancelable: bool,
                data: HandleValue, origin: DOMString, lastEventId: DOMString)
                -> Root<ExtendableMessageEvent> {
@@ -51,7 +52,8 @@ impl ExtendableMessageEvent {
                        init: &ExtendableMessageEventBinding::ExtendableMessageEventInit)
                        -> Fallible<Root<ExtendableMessageEvent>> {
         rooted!(in(global.get_cx()) let data = init.data);
-        let ev = ExtendableMessageEvent::new(global, Atom::from(type_),
+        let ev = ExtendableMessageEvent::new(global.as_global_scope(),
+                                             Atom::from(type_),
                                              init.parent.parent.bubbles,
                                              init.parent.parent.cancelable,
                                              data.handle(),
@@ -66,7 +68,7 @@ impl ExtendableMessageEvent {
                           scope: GlobalRef,
                           message: HandleValue) {
         let Extendablemessageevent = ExtendableMessageEvent::new(
-            scope, atom!("message"), false, false, message,
+            scope.as_global_scope(), atom!("message"), false, false, message,
             DOMString::new(), DOMString::new());
         Extendablemessageevent.upcast::<Event>().fire(target);
     }
diff --git a/components/script/dom/file.rs b/components/script/dom/file.rs
index 8b4abaaed80..6ee2f0c3771 100644
--- a/components/script/dom/file.rs
+++ b/components/script/dom/file.rs
@@ -7,10 +7,12 @@ use dom::bindings::codegen::Bindings::FileBinding::FileMethods;
 use dom::bindings::codegen::UnionTypes::BlobOrString;
 use dom::bindings::error::{Error, Fallible};
 use dom::bindings::global::GlobalRef;
+use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
 use dom::blob::{Blob, BlobImpl, blob_parts_to_bytes};
+use dom::globalscope::GlobalScope;
 use dom::window::Window;
 use net_traits::filemanager_thread::SelectedFile;
 use time;
@@ -41,7 +43,7 @@ impl File {
     }
 
     #[allow(unrooted_must_root)]
-    pub fn new(global: GlobalRef, blob_impl: BlobImpl,
+    pub fn new(global: &GlobalScope, blob_impl: BlobImpl,
                name: DOMString, modified: Option<i64>, typeString: &str) -> Root<File> {
         reflect_dom_object(box File::new_inherited(blob_impl, name, modified, typeString),
                            global,
@@ -52,9 +54,7 @@ impl File {
     pub fn new_from_selected(window: &Window, selected: SelectedFile) -> Root<File> {
         let name = DOMString::from(selected.filename.to_str().expect("File name encoding error"));
 
-        let global = GlobalRef::Window(window);
-
-        File::new(global, BlobImpl::new_from_file(selected.id, selected.filename, selected.size),
+        File::new(window.upcast(), BlobImpl::new_from_file(selected.id, selected.filename, selected.size),
                   name, Some(selected.modified as i64), &selected.type_string)
     }
 
@@ -76,7 +76,11 @@ impl File {
         // NOTE: Following behaviour might be removed in future,
         // see https://github.com/w3c/FileAPI/issues/41
         let replaced_filename = DOMString::from_string(filename.replace("/", ":"));
-        Ok(File::new(global, BlobImpl::new_from_bytes(bytes), replaced_filename, modified, typeString))
+        Ok(File::new(global.as_global_scope(),
+                    BlobImpl::new_from_bytes(bytes),
+                    replaced_filename,
+                    modified,
+                    typeString))
     }
 
     pub fn name(&self) -> &DOMString {
diff --git a/components/script/dom/filelist.rs b/components/script/dom/filelist.rs
index 8adbe1ed467..e3654b752dc 100644
--- a/components/script/dom/filelist.rs
+++ b/components/script/dom/filelist.rs
@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::FileListBinding;
 use dom::bindings::codegen::Bindings::FileListBinding::FileListMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::file::File;
@@ -30,7 +29,7 @@ impl FileList {
     #[allow(unrooted_must_root)]
     pub fn new(window: &Window, files: Vec<Root<File>>) -> Root<FileList> {
         reflect_dom_object(box FileList::new_inherited(files.iter().map(|r| JS::from_ref(&**r)).collect()),
-                           GlobalRef::Window(window),
+                           window,
                            FileListBinding::Wrap)
     }
 
diff --git a/components/script/dom/filereader.rs b/components/script/dom/filereader.rs
index a82e4dc47bc..ac2aa37ee56 100644
--- a/components/script/dom/filereader.rs
+++ b/components/script/dom/filereader.rs
@@ -17,6 +17,7 @@ use dom::blob::Blob;
 use dom::domexception::{DOMErrorName, DOMException};
 use dom::event::{Event, EventBubbles, EventCancelable};
 use dom::eventtarget::EventTarget;
+use dom::globalscope::GlobalScope;
 use dom::progressevent::ProgressEvent;
 use encoding::all::UTF_8;
 use encoding::label::encoding_from_whatwg_label;
@@ -88,13 +89,13 @@ impl FileReader {
         }
     }
 
-    pub fn new(global: GlobalRef) -> Root<FileReader> {
+    pub fn new(global: &GlobalScope) -> Root<FileReader> {
         reflect_dom_object(box FileReader::new_inherited(),
                            global, FileReaderBinding::Wrap)
     }
 
     pub fn Constructor(global: GlobalRef) -> Fallible<Root<FileReader>> {
-        Ok(FileReader::new(global))
+        Ok(FileReader::new(global.as_global_scope()))
     }
 
     //https://w3c.github.io/FileAPI/#dfn-error-steps
@@ -115,7 +116,7 @@ impl FileReader {
         *fr.result.borrow_mut() = None;
 
         let global = fr.r().global();
-        let exception = DOMException::new(global.r(), error);
+        let exception = DOMException::new(global.r().as_global_scope(), error);
         fr.error.set(Some(&exception));
 
         fr.dispatch_progress_event(atom!("error"), 0, None);
@@ -290,7 +291,7 @@ impl FileReaderMethods for FileReader {
         *self.result.borrow_mut() = None;
 
         let global = self.global();
-        let exception = DOMException::new(global.r(), DOMErrorName::AbortError);
+        let exception = DOMException::new(global.r().as_global_scope(), DOMErrorName::AbortError);
         self.error.set(Some(&exception));
 
         self.terminate_ongoing_reading();
@@ -319,7 +320,7 @@ impl FileReaderMethods for FileReader {
 impl FileReader {
     fn dispatch_progress_event(&self, type_: Atom, loaded: u64, total: Option<u64>) {
         let global = self.global();
-        let progressevent = ProgressEvent::new(global.r(),
+        let progressevent = ProgressEvent::new(global.r().as_global_scope(),
             type_, EventBubbles::DoesNotBubble, EventCancelable::NotCancelable,
             total.is_some(), loaded, total.unwrap_or(0));
         progressevent.upcast::<Event>().fire(self.upcast());
@@ -338,7 +339,7 @@ impl FileReader {
         // Step 2
         if blob.IsClosed() {
             let global = self.global();
-            let exception = DOMException::new(global.r(), DOMErrorName::InvalidStateError);
+            let exception = DOMException::new(global.r().as_global_scope(), DOMErrorName::InvalidStateError);
             self.error.set(Some(&exception));
 
             self.dispatch_progress_event(atom!("error"), 0, None);
diff --git a/components/script/dom/filereadersync.rs b/components/script/dom/filereadersync.rs
index b248848edad..3e8800a65bf 100644
--- a/components/script/dom/filereadersync.rs
+++ b/components/script/dom/filereadersync.rs
@@ -8,8 +8,7 @@ use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
 use dom::eventtarget::EventTarget;
-
-
+use dom::globalscope::GlobalScope;
 
 #[dom_struct]
 pub struct FileReaderSync {
@@ -23,12 +22,12 @@ impl FileReaderSync {
         }
     }
 
-    pub fn new(global: GlobalRef) -> Root<FileReaderSync> {
+    pub fn new(global: &GlobalScope) -> Root<FileReaderSync> {
         reflect_dom_object(box FileReaderSync::new_inherited(),
                            global, FileReaderSyncBinding::Wrap)
     }
 
     pub fn Constructor(global: GlobalRef) -> Fallible<Root<FileReaderSync>> {
-        Ok(FileReaderSync::new(global))
+        Ok(FileReaderSync::new(global.as_global_scope()))
     }
 }
diff --git a/components/script/dom/focusevent.rs b/components/script/dom/focusevent.rs
index dd5e41e8426..cb65d40088f 100644
--- a/components/script/dom/focusevent.rs
+++ b/components/script/dom/focusevent.rs
@@ -13,6 +13,7 @@ use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
 use dom::event::{EventBubbles, EventCancelable};
 use dom::eventtarget::EventTarget;
+use dom::globalscope::GlobalScope;
 use dom::uievent::UIEvent;
 use dom::window::Window;
 use std::default::Default;
@@ -31,7 +32,7 @@ impl FocusEvent {
         }
     }
 
-    pub fn new_uninitialized(global: GlobalRef) -> Root<FocusEvent> {
+    pub fn new_uninitialized(global: &GlobalScope) -> Root<FocusEvent> {
         reflect_dom_object(box FocusEvent::new_inherited(),
                            global,
                            FocusEventBinding::Wrap)
@@ -44,8 +45,7 @@ impl FocusEvent {
                view: Option<&Window>,
                detail: i32,
                related_target: Option<&EventTarget>) -> Root<FocusEvent> {
-        let event = box FocusEvent::new_inherited();
-        let ev = reflect_dom_object(event, GlobalRef::Window(window), FocusEventBinding::Wrap);
+        let ev = FocusEvent::new_uninitialized(window.upcast());
         ev.upcast::<UIEvent>().InitUIEvent(type_,
                                            bool::from(can_bubble),
                                            bool::from(cancelable),
diff --git a/components/script/dom/forcetouchevent.rs b/components/script/dom/forcetouchevent.rs
index e982cfdf86e..9e1c5cfcd91 100644
--- a/components/script/dom/forcetouchevent.rs
+++ b/components/script/dom/forcetouchevent.rs
@@ -5,7 +5,6 @@
 use dom::bindings::codegen::Bindings::ForceTouchEventBinding;
 use dom::bindings::codegen::Bindings::ForceTouchEventBinding::ForceTouchEventMethods;
 use dom::bindings::codegen::Bindings::UIEventBinding::UIEventMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::num::Finite;
@@ -32,7 +31,7 @@ impl ForceTouchEvent {
                type_: DOMString,
                force: f32) -> Root<ForceTouchEvent> {
         let event = box ForceTouchEvent::new_inherited(force);
-        let ev = reflect_dom_object(event, GlobalRef::Window(window), ForceTouchEventBinding::Wrap);
+        let ev = reflect_dom_object(event, window, ForceTouchEventBinding::Wrap);
         ev.upcast::<UIEvent>().InitUIEvent(type_, true, true, Some(window), 0);
         ev
     }
diff --git a/components/script/dom/formdata.rs b/components/script/dom/formdata.rs
index 542b44e804e..e5bdc6ca1d5 100644
--- a/components/script/dom/formdata.rs
+++ b/components/script/dom/formdata.rs
@@ -14,6 +14,7 @@ use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::str::{DOMString, USVString};
 use dom::blob::{Blob, BlobImpl};
 use dom::file::File;
+use dom::globalscope::GlobalScope;
 use dom::htmlformelement::{HTMLFormElement, FormDatumValue, FormDatum};
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
@@ -45,14 +46,14 @@ impl FormData {
         }
     }
 
-    pub fn new(form: Option<&HTMLFormElement>, global: GlobalRef) -> Root<FormData> {
+    pub fn new(form: Option<&HTMLFormElement>, global: &GlobalScope) -> Root<FormData> {
         reflect_dom_object(box FormData::new_inherited(form),
                            global, FormDataWrap)
     }
 
     pub fn Constructor(global: GlobalRef, form: Option<&HTMLFormElement>) -> Fallible<Root<FormData>> {
         // TODO: Construct form data set for form if it is supplied
-        Ok(FormData::new(form, global))
+        Ok(FormData::new(form, global.as_global_scope()))
     }
 }
 
@@ -154,7 +155,7 @@ impl FormData {
 
         let bytes = blob.get_bytes().unwrap_or(vec![]);
 
-        File::new(global.r(), BlobImpl::new_from_bytes(bytes), name, None, "")
+        File::new(global.r().as_global_scope(), BlobImpl::new_from_bytes(bytes), name, None, "")
     }
 
     pub fn datums(&self) -> Vec<FormDatum> {
diff --git a/components/script/dom/globalscope.rs b/components/script/dom/globalscope.rs
index 7c284987958..de9ee3773d2 100644
--- a/components/script/dom/globalscope.rs
+++ b/components/script/dom/globalscope.rs
@@ -2,7 +2,9 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use dom::bindings::reflector::Reflectable;
 use dom::eventtarget::EventTarget;
+use js::jsapi::{JS_GetContext, JS_GetObjectRuntime, JSContext};
 
 #[dom_struct]
 pub struct GlobalScope {
@@ -15,4 +17,16 @@ impl GlobalScope {
             eventtarget: EventTarget::new_inherited(),
         }
     }
+
+    #[allow(unsafe_code)]
+    pub fn get_cx(&self) -> *mut JSContext {
+        unsafe {
+            let runtime = JS_GetObjectRuntime(
+                self.reflector().get_jsobject().get());
+            assert!(!runtime.is_null());
+            let context = JS_GetContext(runtime);
+            assert!(!context.is_null());
+            context
+        }
+    }
 }
diff --git a/components/script/dom/hashchangeevent.rs b/components/script/dom/hashchangeevent.rs
index 33562123ac6..c97599b25a3 100644
--- a/components/script/dom/hashchangeevent.rs
+++ b/components/script/dom/hashchangeevent.rs
@@ -12,6 +12,7 @@ use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::{DOMString, USVString};
 use dom::event::Event;
+use dom::globalscope::GlobalScope;
 use string_cache::Atom;
 
 // https://html.spec.whatwg.org/multipage/#hashchangeevent
@@ -31,14 +32,13 @@ impl HashChangeEvent {
         }
     }
 
-    pub fn new_uninitialized(global: GlobalRef)
-                             -> Root<HashChangeEvent> {
+    pub fn new_uninitialized(global: &GlobalScope) -> Root<HashChangeEvent> {
         reflect_dom_object(box HashChangeEvent::new_inherited(String::new(), String::new()),
                            global,
                            HashChangeEventBinding::Wrap)
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                type_: Atom,
                bubbles: bool,
                cancelable: bool,
@@ -59,7 +59,7 @@ impl HashChangeEvent {
                        type_: DOMString,
                        init: &HashChangeEventBinding::HashChangeEventInit)
                        -> Fallible<Root<HashChangeEvent>> {
-        Ok(HashChangeEvent::new(global,
+        Ok(HashChangeEvent::new(global.as_global_scope(),
                                 Atom::from(type_),
                                 init.parent.bubbles,
                                 init.parent.cancelable,
diff --git a/components/script/dom/headers.rs b/components/script/dom/headers.rs
index 7f43dd6b07a..68c3d92c0ad 100644
--- a/components/script/dom/headers.rs
+++ b/components/script/dom/headers.rs
@@ -10,6 +10,7 @@ use dom::bindings::iterable::Iterable;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::{ByteString, is_token};
+use dom::globalscope::GlobalScope;
 use hyper::header::Headers as HyperHeaders;
 use mime::{Mime, TopLevel, SubLevel};
 use std::cell::Cell;
@@ -43,14 +44,14 @@ impl Headers {
         }
     }
 
-    pub fn new(global: GlobalRef) -> Root<Headers> {
+    pub fn new(global: &GlobalScope) -> Root<Headers> {
         reflect_dom_object(box Headers::new_inherited(), global, HeadersWrap)
     }
 
     // https://fetch.spec.whatwg.org/#dom-headers
     pub fn Constructor(global: GlobalRef, init: Option<HeadersInit>)
                        -> Fallible<Root<Headers>> {
-        let dom_headers_new = Headers::new(global);
+        let dom_headers_new = Headers::new(global.as_global_scope());
         try!(dom_headers_new.fill(init));
         Ok(dom_headers_new)
     }
@@ -205,13 +206,13 @@ impl Headers {
         }
     }
 
-    pub fn for_request(global: GlobalRef) -> Root<Headers> {
+    pub fn for_request(global: &GlobalScope) -> Root<Headers> {
         let headers_for_request = Headers::new(global);
         headers_for_request.guard.set(Guard::Request);
         headers_for_request
     }
 
-    pub fn for_response(global: GlobalRef) -> Root<Headers> {
+    pub fn for_response(global: &GlobalScope) -> Root<Headers> {
         let headers_for_response = Headers::new(global);
         headers_for_response.guard.set(Guard::Response);
         headers_for_response
diff --git a/components/script/dom/history.rs b/components/script/dom/history.rs
index 5ced543d728..9fe5789524c 100644
--- a/components/script/dom/history.rs
+++ b/components/script/dom/history.rs
@@ -6,7 +6,6 @@ use dom::bindings::codegen::Bindings::HistoryBinding;
 use dom::bindings::codegen::Bindings::HistoryBinding::HistoryMethods;
 use dom::bindings::codegen::Bindings::LocationBinding::LocationMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::window::Window;
@@ -31,7 +30,7 @@ impl History {
 
     pub fn new(window: &Window) -> Root<History> {
         reflect_dom_object(box History::new_inherited(window),
-                           GlobalRef::Window(window),
+                           window,
                            HistoryBinding::Wrap)
     }
 }
diff --git a/components/script/dom/htmlcollection.rs b/components/script/dom/htmlcollection.rs
index 66a810eff9f..4274c04a21b 100644
--- a/components/script/dom/htmlcollection.rs
+++ b/components/script/dom/htmlcollection.rs
@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::HTMLCollectionBinding;
 use dom::bindings::codegen::Bindings::HTMLCollectionBinding::HTMLCollectionMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{JS, Root, MutNullableHeap};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
@@ -83,7 +82,7 @@ impl HTMLCollection {
     #[allow(unrooted_must_root)]
     pub fn new(window: &Window, root: &Node, filter: Box<CollectionFilter + 'static>) -> Root<HTMLCollection> {
         reflect_dom_object(box HTMLCollection::new_inherited(root, filter),
-                           GlobalRef::Window(window), HTMLCollectionBinding::Wrap)
+                           window, HTMLCollectionBinding::Wrap)
     }
 
     pub fn create(window: &Window, root: &Node,
diff --git a/components/script/dom/htmlformcontrolscollection.rs b/components/script/dom/htmlformcontrolscollection.rs
index e52a541225f..2450b26c179 100644
--- a/components/script/dom/htmlformcontrolscollection.rs
+++ b/components/script/dom/htmlformcontrolscollection.rs
@@ -6,7 +6,6 @@ use dom::bindings::codegen::Bindings::HTMLCollectionBinding::HTMLCollectionMetho
 use dom::bindings::codegen::Bindings::HTMLFormControlsCollectionBinding;
 use dom::bindings::codegen::Bindings::HTMLFormControlsCollectionBinding::HTMLFormControlsCollectionMethods;
 use dom::bindings::codegen::UnionTypes::RadioNodeListOrElement;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflectable, reflect_dom_object};
 use dom::bindings::str::DOMString;
@@ -33,7 +32,7 @@ impl HTMLFormControlsCollection {
         -> Root<HTMLFormControlsCollection>
     {
         reflect_dom_object(box HTMLFormControlsCollection::new_inherited(root, filter),
-                           GlobalRef::Window(window),
+                           window,
                            HTMLFormControlsCollectionBinding::Wrap)
     }
 
diff --git a/components/script/dom/htmliframeelement.rs b/components/script/dom/htmliframeelement.rs
index 1503ff28e06..2b7781dae1e 100644
--- a/components/script/dom/htmliframeelement.rs
+++ b/components/script/dom/htmliframeelement.rs
@@ -18,7 +18,6 @@ use dom::bindings::codegen::Bindings::HTMLIFrameElementBinding::HTMLIFrameElemen
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::conversions::ToJSValConvertible;
 use dom::bindings::error::{Error, ErrorResult, Fallible};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{JS, LayoutJS, MutNullableHeap, Root};
 use dom::bindings::reflector::Reflectable;
@@ -316,7 +315,7 @@ pub fn build_mozbrowser_custom_event(window: &Window, event: MozBrowserEvent) ->
     rooted!(in(cx) let mut detail = UndefinedValue());
     let event_name = Atom::from(event.name());
     unsafe { build_mozbrowser_event_detail(event, cx, detail.handle_mut()); }
-    CustomEvent::new(GlobalRef::Window(window),
+    CustomEvent::new(window.upcast(),
                      event_name,
                      true,
                      true,
diff --git a/components/script/dom/htmlmediaelement.rs b/components/script/dom/htmlmediaelement.rs
index 5bbdd738079..24ae7542880 100644
--- a/components/script/dom/htmlmediaelement.rs
+++ b/components/script/dom/htmlmediaelement.rs
@@ -311,7 +311,7 @@ impl HTMLMediaElement {
 
     fn fire_simple_event(&self, type_: &str) {
         let window = window_from_node(self);
-        let event = Event::new(GlobalRef::Window(&*window),
+        let event = Event::new(window.upcast(),
                                Atom::from(type_),
                                EventBubbles::DoesNotBubble,
                                EventCancelable::NotCancelable);
diff --git a/components/script/dom/htmloptionscollection.rs b/components/script/dom/htmloptionscollection.rs
index dd6d4531974..473d698d35b 100644
--- a/components/script/dom/htmloptionscollection.rs
+++ b/components/script/dom/htmloptionscollection.rs
@@ -9,7 +9,6 @@ use dom::bindings::codegen::Bindings::HTMLOptionsCollectionBinding::HTMLOptionsC
 use dom::bindings::codegen::Bindings::NodeBinding::NodeBinding::NodeMethods;
 use dom::bindings::codegen::UnionTypes::{HTMLOptionElementOrHTMLOptGroupElement, HTMLElementOrLong};
 use dom::bindings::error::{Error, ErrorResult};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{Root, RootedReference};
 use dom::bindings::reflector::reflect_dom_object;
@@ -36,7 +35,7 @@ impl HTMLOptionsCollection {
         -> Root<HTMLOptionsCollection>
     {
         reflect_dom_object(box HTMLOptionsCollection::new_inherited(root, filter),
-                           GlobalRef::Window(window),
+                           window,
                            HTMLOptionsCollectionBinding::Wrap)
     }
 
diff --git a/components/script/dom/htmlscriptelement.rs b/components/script/dom/htmlscriptelement.rs
index e96ceb6d834..7f5266b9e84 100644
--- a/components/script/dom/htmlscriptelement.rs
+++ b/components/script/dom/htmlscriptelement.rs
@@ -604,7 +604,7 @@ impl HTMLScriptElement {
                       cancelable: EventCancelable) -> EventStatus {
         let window = window_from_node(self);
         let window = window.r();
-        let event = Event::new(GlobalRef::Window(window), type_, bubbles, cancelable);
+        let event = Event::new(window.upcast(), type_, bubbles, cancelable);
         event.fire(self.upcast())
     }
 }
diff --git a/components/script/dom/imagedata.rs b/components/script/dom/imagedata.rs
index 0959a52eb32..5f99fb9db57 100644
--- a/components/script/dom/imagedata.rs
+++ b/components/script/dom/imagedata.rs
@@ -5,9 +5,9 @@
 use core::nonzero::NonZero;
 use dom::bindings::codegen::Bindings::ImageDataBinding;
 use dom::bindings::codegen::Bindings::ImageDataBinding::ImageDataMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::globalscope::GlobalScope;
 use euclid::size::Size2D;
 use js::jsapi::{Heap, JSContext, JSObject};
 use js::jsapi::{JS_GetUint8ClampedArrayData, JS_NewUint8ClampedArray};
@@ -27,7 +27,7 @@ pub struct ImageData {
 
 impl ImageData {
     #[allow(unsafe_code)]
-    pub fn new(global: GlobalRef, width: u32, height: u32, data: Option<Vec<u8>>) -> Root<ImageData> {
+    pub fn new(global: &GlobalScope, width: u32, height: u32, data: Option<Vec<u8>>) -> Root<ImageData> {
         let mut imagedata = box ImageData {
             reflector_: Reflector::new(),
             width: width,
diff --git a/components/script/dom/keyboardevent.rs b/components/script/dom/keyboardevent.rs
index d21f53eb609..06987f55b12 100644
--- a/components/script/dom/keyboardevent.rs
+++ b/components/script/dom/keyboardevent.rs
@@ -62,7 +62,7 @@ impl KeyboardEvent {
 
     pub fn new_uninitialized(window: &Window) -> Root<KeyboardEvent> {
         reflect_dom_object(box KeyboardEvent::new_inherited(),
-                           GlobalRef::Window(window),
+                           window,
                            KeyboardEventBinding::Wrap)
     }
 
diff --git a/components/script/dom/location.rs b/components/script/dom/location.rs
index ba835ada146..cf91c683f2f 100644
--- a/components/script/dom/location.rs
+++ b/components/script/dom/location.rs
@@ -5,7 +5,6 @@
 use dom::bindings::codegen::Bindings::LocationBinding;
 use dom::bindings::codegen::Bindings::LocationBinding::LocationMethods;
 use dom::bindings::error::{Error, ErrorResult};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::{DOMString, USVString};
@@ -29,7 +28,7 @@ impl Location {
 
     pub fn new(window: &Window) -> Root<Location> {
         reflect_dom_object(box Location::new_inherited(window),
-                           GlobalRef::Window(window),
+                           window,
                            LocationBinding::Wrap)
     }
 
diff --git a/components/script/dom/mediaerror.rs b/components/script/dom/mediaerror.rs
index 17d92947f72..b7b7a800989 100644
--- a/components/script/dom/mediaerror.rs
+++ b/components/script/dom/mediaerror.rs
@@ -3,7 +3,6 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::MediaErrorBinding::{self, MediaErrorMethods};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::window::Window;
@@ -24,7 +23,7 @@ impl MediaError {
 
     pub fn new(window: &Window, code: u16) -> Root<MediaError> {
         reflect_dom_object(box MediaError::new_inherited(code),
-                           GlobalRef::Window(window),
+                           window,
                            MediaErrorBinding::Wrap)
     }
 }
diff --git a/components/script/dom/messageevent.rs b/components/script/dom/messageevent.rs
index b5b46fba5d8..62c8c4c5ed4 100644
--- a/components/script/dom/messageevent.rs
+++ b/components/script/dom/messageevent.rs
@@ -13,6 +13,7 @@ use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
 use dom::event::Event;
 use dom::eventtarget::EventTarget;
+use dom::globalscope::GlobalScope;
 use js::jsapi::{HandleValue, Heap, JSContext};
 use js::jsval::JSVal;
 use std::default::Default;
@@ -27,14 +28,14 @@ pub struct MessageEvent {
 }
 
 impl MessageEvent {
-    pub fn new_uninitialized(global: GlobalRef) -> Root<MessageEvent> {
+    pub fn new_uninitialized(global: &GlobalScope) -> Root<MessageEvent> {
         MessageEvent::new_initialized(global,
                                       HandleValue::undefined(),
                                       DOMString::new(),
                                       DOMString::new())
     }
 
-    pub fn new_initialized(global: GlobalRef,
+    pub fn new_initialized(global: &GlobalScope,
                            data: HandleValue,
                            origin: DOMString,
                            lastEventId: DOMString) -> Root<MessageEvent> {
@@ -48,7 +49,7 @@ impl MessageEvent {
         reflect_dom_object(ev, global, MessageEventBinding::Wrap)
     }
 
-    pub fn new(global: GlobalRef, type_: Atom,
+    pub fn new(global: &GlobalScope, type_: Atom,
                bubbles: bool, cancelable: bool,
                data: HandleValue, origin: DOMString, lastEventId: DOMString)
                -> Root<MessageEvent> {
@@ -67,9 +68,13 @@ impl MessageEvent {
         // Dictionaries need to be rooted
         // https://github.com/servo/servo/issues/6381
         rooted!(in(global.get_cx()) let data = init.data);
-        let ev = MessageEvent::new(global, Atom::from(type_), init.parent.bubbles, init.parent.cancelable,
+        let ev = MessageEvent::new(global.as_global_scope(),
+                                   Atom::from(type_),
+                                   init.parent.bubbles,
+                                   init.parent.cancelable,
                                    data.handle(),
-                                   init.origin.clone(), init.lastEventId.clone());
+                                   init.origin.clone(),
+                                   init.lastEventId.clone());
         Ok(ev)
     }
 }
@@ -79,8 +84,13 @@ impl MessageEvent {
                           scope: GlobalRef,
                           message: HandleValue) {
         let messageevent = MessageEvent::new(
-            scope, atom!("message"), false, false, message,
-            DOMString::new(), DOMString::new());
+            scope.as_global_scope(),
+            atom!("message"),
+            false,
+            false,
+            message,
+            DOMString::new(),
+            DOMString::new());
         messageevent.upcast::<Event>().fire(target);
     }
 }
diff --git a/components/script/dom/mimetypearray.rs b/components/script/dom/mimetypearray.rs
index de820f6d06a..e0dd8090f8f 100644
--- a/components/script/dom/mimetypearray.rs
+++ b/components/script/dom/mimetypearray.rs
@@ -4,10 +4,10 @@
 
 use dom::bindings::codegen::Bindings::MimeTypeArrayBinding;
 use dom::bindings::codegen::Bindings::MimeTypeArrayBinding::MimeTypeArrayMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
+use dom::globalscope::GlobalScope;
 use dom::mimetype::MimeType;
 
 #[dom_struct]
@@ -22,7 +22,7 @@ impl MimeTypeArray {
         }
     }
 
-    pub fn new(global: GlobalRef) -> Root<MimeTypeArray> {
+    pub fn new(global: &GlobalScope) -> Root<MimeTypeArray> {
         reflect_dom_object(box MimeTypeArray::new_inherited(),
                            global,
                            MimeTypeArrayBinding::Wrap)
diff --git a/components/script/dom/mouseevent.rs b/components/script/dom/mouseevent.rs
index 659a28226b7..096b119641f 100644
--- a/components/script/dom/mouseevent.rs
+++ b/components/script/dom/mouseevent.rs
@@ -53,7 +53,7 @@ impl MouseEvent {
 
     pub fn new_uninitialized(window: &Window) -> Root<MouseEvent> {
         reflect_dom_object(box MouseEvent::new_inherited(),
-                           GlobalRef::Window(window),
+                           window,
                            MouseEventBinding::Wrap)
     }
 
diff --git a/components/script/dom/namednodemap.rs b/components/script/dom/namednodemap.rs
index 9edc1b1e93b..1145ff60562 100644
--- a/components/script/dom/namednodemap.rs
+++ b/components/script/dom/namednodemap.rs
@@ -7,7 +7,6 @@ use dom::bindings::codegen::Bindings::ElementBinding::ElementMethods;
 use dom::bindings::codegen::Bindings::NamedNodeMapBinding;
 use dom::bindings::codegen::Bindings::NamedNodeMapBinding::NamedNodeMapMethods;
 use dom::bindings::error::{Error, Fallible};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
@@ -33,7 +32,7 @@ impl NamedNodeMap {
 
     pub fn new(window: &Window, elem: &Element) -> Root<NamedNodeMap> {
         reflect_dom_object(box NamedNodeMap::new_inherited(elem),
-                           GlobalRef::Window(window), NamedNodeMapBinding::Wrap)
+                           window, NamedNodeMapBinding::Wrap)
     }
 }
 
diff --git a/components/script/dom/navigator.rs b/components/script/dom/navigator.rs
index ce97c30ae60..d4e4629e486 100644
--- a/components/script/dom/navigator.rs
+++ b/components/script/dom/navigator.rs
@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::NavigatorBinding;
 use dom::bindings::codegen::Bindings::NavigatorBinding::NavigatorMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::bindings::reflector::{Reflector, Reflectable, reflect_dom_object};
 use dom::bindings::str::DOMString;
@@ -37,7 +36,7 @@ impl Navigator {
 
     pub fn new(window: &Window) -> Root<Navigator> {
         reflect_dom_object(box Navigator::new_inherited(),
-                           GlobalRef::Window(window),
+                           window,
                            NavigatorBinding::Wrap)
     }
 }
@@ -80,7 +79,7 @@ impl NavigatorMethods for Navigator {
 
     // https://webbluetoothcg.github.io/web-bluetooth/#dom-navigator-bluetooth
     fn Bluetooth(&self) -> Root<Bluetooth> {
-        self.bluetooth.or_init(|| Bluetooth::new(self.global().r()))
+        self.bluetooth.or_init(|| Bluetooth::new(self.global().r().as_global_scope()))
     }
 
     // https://html.spec.whatwg.org/multipage/#navigatorlanguage
@@ -90,12 +89,12 @@ impl NavigatorMethods for Navigator {
 
     // https://html.spec.whatwg.org/multipage/#dom-navigator-plugins
     fn Plugins(&self) -> Root<PluginArray> {
-        self.plugins.or_init(|| PluginArray::new(self.global().r()))
+        self.plugins.or_init(|| PluginArray::new(self.global().r().as_global_scope()))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-navigator-mimetypes
     fn MimeTypes(&self) -> Root<MimeTypeArray> {
-        self.mime_types.or_init(|| MimeTypeArray::new(self.global().r()))
+        self.mime_types.or_init(|| MimeTypeArray::new(self.global().r().as_global_scope()))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-navigator-javaenabled
@@ -105,7 +104,9 @@ impl NavigatorMethods for Navigator {
 
     // https://w3c.github.io/ServiceWorker/#navigator-service-worker-attribute
     fn ServiceWorker(&self) -> Root<ServiceWorkerContainer> {
-        self.service_worker.or_init(|| ServiceWorkerContainer::new(self.global().r()))
+        self.service_worker.or_init(|| {
+            ServiceWorkerContainer::new(self.global().r().as_global_scope())
+        })
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-navigator-cookieenabled
diff --git a/components/script/dom/node.rs b/components/script/dom/node.rs
index 041d6407418..c18613ac6a2 100644
--- a/components/script/dom/node.rs
+++ b/components/script/dom/node.rs
@@ -20,7 +20,6 @@ use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::codegen::UnionTypes::NodeOrString;
 use dom::bindings::conversions::{self, DerivedFrom};
 use dom::bindings::error::{Error, ErrorResult, Fallible};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::{Castable, CharacterDataTypeId, ElementTypeId};
 use dom::bindings::inheritance::{EventTargetTypeId, HTMLElementTypeId, NodeTypeId};
 use dom::bindings::js::{JS, LayoutJS, MutNullableHeap};
@@ -35,6 +34,7 @@ use dom::documentfragment::DocumentFragment;
 use dom::documenttype::DocumentType;
 use dom::element::{Element, ElementCreator};
 use dom::eventtarget::EventTarget;
+use dom::globalscope::GlobalScope;
 use dom::htmlbodyelement::HTMLBodyElement;
 use dom::htmlcanvaselement::LayoutHTMLCanvasElementHelpers;
 use dom::htmlcollection::HTMLCollection;
@@ -1339,13 +1339,15 @@ pub enum CloneChildrenFlag {
 fn as_uintptr<T>(t: &T) -> uintptr_t { t as *const T as uintptr_t }
 
 impl Node {
-    pub fn reflect_node<N: DerivedFrom<Node> + Reflectable>
-            (node:      Box<N>,
-             document:  &Document,
-             wrap_fn:   extern "Rust" fn(*mut JSContext, GlobalRef, Box<N>) -> Root<N>)
-             -> Root<N> {
+    pub fn reflect_node<N>(
+            node: Box<N>,
+            document: &Document,
+            wrap_fn: extern "Rust" fn(*mut JSContext, &GlobalScope, Box<N>) -> Root<N>)
+            -> Root<N>
+        where N: DerivedFrom<Node> + Reflectable
+    {
         let window = document.window();
-        reflect_dom_object(node, GlobalRef::Window(window), wrap_fn)
+        reflect_dom_object(node, window, wrap_fn)
     }
 
     pub fn new_inherited(doc: &Document) -> Node {
diff --git a/components/script/dom/nodeiterator.rs b/components/script/dom/nodeiterator.rs
index 14b8f240fbb..4315dd28113 100644
--- a/components/script/dom/nodeiterator.rs
+++ b/components/script/dom/nodeiterator.rs
@@ -9,7 +9,6 @@ use dom::bindings::codegen::Bindings::NodeFilterBinding::NodeFilterConstants;
 use dom::bindings::codegen::Bindings::NodeIteratorBinding;
 use dom::bindings::codegen::Bindings::NodeIteratorBinding::NodeIteratorMethods;
 use dom::bindings::error::Fallible;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutHeap, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::document::Document;
@@ -48,7 +47,7 @@ impl NodeIterator {
                            what_to_show: u32,
                            filter: Filter) -> Root<NodeIterator> {
         reflect_dom_object(box NodeIterator::new_inherited(root_node, what_to_show, filter),
-                           GlobalRef::Window(document.window()),
+                           document.window(),
                            NodeIteratorBinding::Wrap)
     }
 
diff --git a/components/script/dom/nodelist.rs b/components/script/dom/nodelist.rs
index 8f8a5515592..ffd44d277a5 100644
--- a/components/script/dom/nodelist.rs
+++ b/components/script/dom/nodelist.rs
@@ -5,7 +5,6 @@
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
 use dom::bindings::codegen::Bindings::NodeListBinding;
 use dom::bindings::codegen::Bindings::NodeListBinding::NodeListMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutNullableHeap, Root, RootedReference};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::node::{ChildrenMutation, Node};
@@ -38,7 +37,8 @@ impl NodeList {
     #[allow(unrooted_must_root)]
     pub fn new(window: &Window, list_type: NodeListType) -> Root<NodeList> {
         reflect_dom_object(box NodeList::new_inherited(list_type),
-                           GlobalRef::Window(window), NodeListBinding::Wrap)
+                           window,
+                           NodeListBinding::Wrap)
     }
 
     pub fn new_simple_list<T>(window: &Window, iter: T) -> Root<NodeList>
diff --git a/components/script/dom/pagetransitionevent.rs b/components/script/dom/pagetransitionevent.rs
index 7c6b7b6f555..c25281dcc31 100644
--- a/components/script/dom/pagetransitionevent.rs
+++ b/components/script/dom/pagetransitionevent.rs
@@ -12,6 +12,7 @@ use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
 use dom::event::Event;
+use dom::globalscope::GlobalScope;
 use std::cell::Cell;
 use string_cache::Atom;
 
@@ -30,13 +31,13 @@ impl PageTransitionEvent {
         }
     }
 
-    pub fn new_uninitialized(global: GlobalRef) -> Root<PageTransitionEvent> {
+    pub fn new_uninitialized(global: &GlobalScope) -> Root<PageTransitionEvent> {
         reflect_dom_object(box PageTransitionEvent::new_inherited(),
                            global,
                            PageTransitionEventBinding::Wrap)
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                type_: Atom,
                bubbles: bool,
                cancelable: bool,
@@ -55,7 +56,7 @@ impl PageTransitionEvent {
                        type_: DOMString,
                        init: &PageTransitionEventBinding::PageTransitionEventInit)
                        -> Fallible<Root<PageTransitionEvent>> {
-        Ok(PageTransitionEvent::new(global,
+        Ok(PageTransitionEvent::new(global.as_global_scope(),
                               Atom::from(type_),
                               init.parent.bubbles,
                               init.parent.cancelable,
diff --git a/components/script/dom/performance.rs b/components/script/dom/performance.rs
index f6bc8d288f8..3852a49b28c 100644
--- a/components/script/dom/performance.rs
+++ b/components/script/dom/performance.rs
@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::PerformanceBinding;
 use dom::bindings::codegen::Bindings::PerformanceBinding::PerformanceMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::num::Finite;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
@@ -38,7 +37,7 @@ impl Performance {
         reflect_dom_object(box Performance::new_inherited(window,
                                                           navigation_start,
                                                           navigation_start_precise),
-                           GlobalRef::Window(window),
+                           window,
                            PerformanceBinding::Wrap)
     }
 }
diff --git a/components/script/dom/performancetiming.rs b/components/script/dom/performancetiming.rs
index 6faa8246242..16dc7650649 100644
--- a/components/script/dom/performancetiming.rs
+++ b/components/script/dom/performancetiming.rs
@@ -5,7 +5,6 @@
 use dom::bindings::codegen::Bindings::PerformanceTimingBinding;
 use dom::bindings::codegen::Bindings::PerformanceTimingBinding::PerformanceTimingMethods;
 use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::document::Document;
@@ -40,7 +39,8 @@ impl PerformanceTiming {
         let timing = PerformanceTiming::new_inherited(navigation_start,
                                                       navigation_start_precise,
                                                       window.Document().r());
-        reflect_dom_object(box timing, GlobalRef::Window(window),
+        reflect_dom_object(box timing,
+                           window,
                            PerformanceTimingBinding::Wrap)
     }
 }
diff --git a/components/script/dom/pluginarray.rs b/components/script/dom/pluginarray.rs
index aa6b779280d..fde760d793c 100644
--- a/components/script/dom/pluginarray.rs
+++ b/components/script/dom/pluginarray.rs
@@ -4,10 +4,10 @@
 
 use dom::bindings::codegen::Bindings::PluginArrayBinding;
 use dom::bindings::codegen::Bindings::PluginArrayBinding::PluginArrayMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
+use dom::globalscope::GlobalScope;
 use dom::plugin::Plugin;
 
 #[dom_struct]
@@ -22,7 +22,7 @@ impl PluginArray {
         }
     }
 
-    pub fn new(global: GlobalRef) -> Root<PluginArray> {
+    pub fn new(global: &GlobalScope) -> Root<PluginArray> {
         reflect_dom_object(box PluginArray::new_inherited(),
                            global,
                            PluginArrayBinding::Wrap)
diff --git a/components/script/dom/popstateevent.rs b/components/script/dom/popstateevent.rs
index a9487f48299..621c9d4199f 100644
--- a/components/script/dom/popstateevent.rs
+++ b/components/script/dom/popstateevent.rs
@@ -12,6 +12,7 @@ use dom::bindings::js::{MutHeapJSVal, Root};
 use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
 use dom::event::Event;
+use dom::globalscope::GlobalScope;
 use js::jsapi::{HandleValue, JSContext};
 use js::jsval::JSVal;
 use string_cache::Atom;
@@ -32,13 +33,13 @@ impl PopStateEvent {
         }
     }
 
-    pub fn new_uninitialized(global: GlobalRef) -> Root<PopStateEvent> {
+    pub fn new_uninitialized(global: &GlobalScope) -> Root<PopStateEvent> {
         reflect_dom_object(box PopStateEvent::new_inherited(),
                            global,
                            PopStateEventBinding::Wrap)
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                type_: Atom,
                bubbles: bool,
                cancelable: bool,
@@ -58,7 +59,7 @@ impl PopStateEvent {
                        type_: DOMString,
                        init: &PopStateEventBinding::PopStateEventInit)
                        -> Fallible<Root<PopStateEvent>> {
-        Ok(PopStateEvent::new(global,
+        Ok(PopStateEvent::new(global.as_global_scope(),
                               Atom::from(type_),
                               init.parent.bubbles,
                               init.parent.cancelable,
diff --git a/components/script/dom/progressevent.rs b/components/script/dom/progressevent.rs
index f0d2b5c400a..2f25df109fa 100644
--- a/components/script/dom/progressevent.rs
+++ b/components/script/dom/progressevent.rs
@@ -12,7 +12,7 @@ use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
 use dom::event::{Event, EventBubbles, EventCancelable};
-use dom::window::Window;
+use dom::globalscope::GlobalScope;
 use string_cache::Atom;
 
 #[dom_struct]
@@ -32,12 +32,12 @@ impl ProgressEvent {
             total: total
         }
     }
-    pub fn new_uninitialized(window: &Window) -> Root<ProgressEvent> {
+    pub fn new_uninitialized(global: &GlobalScope) -> Root<ProgressEvent> {
         reflect_dom_object(box ProgressEvent::new_inherited(false, 0, 0),
-                           GlobalRef::Window(window),
+                           global,
                            ProgressEventBinding::Wrap)
     }
-    pub fn new(global: GlobalRef, type_: Atom,
+    pub fn new(global: &GlobalScope, type_: Atom,
                can_bubble: EventBubbles, cancelable: EventCancelable,
                length_computable: bool, loaded: u64, total: u64) -> Root<ProgressEvent> {
         let ev = reflect_dom_object(box ProgressEvent::new_inherited(length_computable, loaded, total),
@@ -55,7 +55,7 @@ impl ProgressEvent {
                        -> Fallible<Root<ProgressEvent>> {
         let bubbles = EventBubbles::from(init.parent.bubbles);
         let cancelable = EventCancelable::from(init.parent.cancelable);
-        let ev = ProgressEvent::new(global, Atom::from(type_), bubbles, cancelable,
+        let ev = ProgressEvent::new(global.as_global_scope(), Atom::from(type_), bubbles, cancelable,
                                     init.lengthComputable, init.loaded, init.total);
         Ok(ev)
     }
diff --git a/components/script/dom/promisenativehandler.rs b/components/script/dom/promisenativehandler.rs
index 603122556ef..b1c0ff3504c 100644
--- a/components/script/dom/promisenativehandler.rs
+++ b/components/script/dom/promisenativehandler.rs
@@ -3,10 +3,10 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::PromiseNativeHandlerBinding;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::trace::JSTraceable;
+use dom::globalscope::GlobalScope;
 use heapsize::HeapSizeOf;
 use js::jsapi::{JSContext, HandleValue};
 
@@ -22,7 +22,7 @@ pub struct PromiseNativeHandler {
 }
 
 impl PromiseNativeHandler {
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                resolve: Option<Box<Callback>>,
                reject: Option<Box<Callback>>)
                -> Root<PromiseNativeHandler> {
diff --git a/components/script/dom/radionodelist.rs b/components/script/dom/radionodelist.rs
index 9bbdae00c85..5cf05cb872a 100644
--- a/components/script/dom/radionodelist.rs
+++ b/components/script/dom/radionodelist.rs
@@ -6,7 +6,6 @@ use dom::bindings::codegen::Bindings::HTMLInputElementBinding::HTMLInputElementM
 use dom::bindings::codegen::Bindings::NodeListBinding::NodeListMethods;
 use dom::bindings::codegen::Bindings::RadioNodeListBinding;
 use dom::bindings::codegen::Bindings::RadioNodeListBinding::RadioNodeListMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::reflect_dom_object;
@@ -32,7 +31,7 @@ impl RadioNodeList {
     #[allow(unrooted_must_root)]
     pub fn new(window: &Window, list_type: NodeListType) -> Root<RadioNodeList> {
         reflect_dom_object(box RadioNodeList::new_inherited(list_type),
-                           GlobalRef::Window(window),
+                           window,
                            RadioNodeListBinding::Wrap)
     }
 
diff --git a/components/script/dom/range.rs b/components/script/dom/range.rs
index bab6bdcc3a2..80018b661f3 100644
--- a/components/script/dom/range.rs
+++ b/components/script/dom/range.rs
@@ -60,7 +60,7 @@ impl Range {
                -> Root<Range> {
         let range = reflect_dom_object(box Range::new_inherited(start_container, start_offset,
                                                                 end_container, end_offset),
-                                       GlobalRef::Window(document.window()),
+                                       document.window(),
                                        RangeBinding::Wrap);
         start_container.ranges().push(WeakRef::new(&range));
         if start_container != end_container {
diff --git a/components/script/dom/request.rs b/components/script/dom/request.rs
index fa665679c0d..1496f16d353 100644
--- a/components/script/dom/request.rs
+++ b/components/script/dom/request.rs
@@ -73,7 +73,7 @@ impl Request {
         reflect_dom_object(box Request::new_inherited(global,
                                                       url,
                                                       is_service_worker_global_scope),
-                           global, RequestBinding::Wrap)
+                           global.as_global_scope(), RequestBinding::Wrap)
     }
 
     // https://fetch.spec.whatwg.org/#dom-request
@@ -305,7 +305,7 @@ impl Request {
         let r = Request::from_net_request(global,
                                           false,
                                           request);
-        r.headers.or_init(|| Headers::for_request(r.global().r()));
+        r.headers.or_init(|| Headers::for_request(r.global().r().as_global_scope()));
 
         // Step 27
         let mut headers_copy = r.Headers();
@@ -429,11 +429,7 @@ impl Request {
         let body_used = r.body_used.get();
         let mime_type = r.mime_type.borrow().clone();
         let headers_guard = r.Headers().get_guard();
-        let r_clone = reflect_dom_object(
-            box Request::new_inherited(r.global().r(),
-                                       url,
-                                       is_service_worker_global_scope),
-            r.global().r(), RequestBinding::Wrap);
+        let r_clone = Request::new(r.global().r(), url, is_service_worker_global_scope);
         r_clone.request.borrow_mut().pipeline_id.set(req.pipeline_id.get());
         {
             let mut borrowed_r_request = r_clone.request.borrow_mut();
@@ -553,7 +549,7 @@ impl RequestMethods for Request {
 
     // https://fetch.spec.whatwg.org/#dom-request-headers
     fn Headers(&self) -> Root<Headers> {
-        self.headers.or_init(|| Headers::new(self.global().r()))
+        self.headers.or_init(|| Headers::new(self.global().r().as_global_scope()))
     }
 
     // https://fetch.spec.whatwg.org/#dom-request-type
diff --git a/components/script/dom/response.rs b/components/script/dom/response.rs
index 2287bb181b4..a90a551b20a 100644
--- a/components/script/dom/response.rs
+++ b/components/script/dom/response.rs
@@ -14,6 +14,7 @@ use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::str::{ByteString, USVString};
+use dom::globalscope::GlobalScope;
 use dom::headers::{Headers, Guard};
 use dom::headers::{is_vchar, is_obs_text};
 use dom::promise::Promise;
@@ -66,7 +67,7 @@ impl Response {
     }
 
     // https://fetch.spec.whatwg.org/#dom-response
-    pub fn new(global: GlobalRef) -> Root<Response> {
+    pub fn new(global: &GlobalScope) -> Root<Response> {
         reflect_dom_object(box Response::new_inherited(), global, ResponseBinding::Wrap)
     }
 
@@ -86,7 +87,7 @@ impl Response {
         }
 
         // Step 3
-        let r = Response::new(global);
+        let r = Response::new(global.as_global_scope());
 
         // Step 4
         *r.status.borrow_mut() = Some(StatusCode::from_u16(init.status));
@@ -139,7 +140,7 @@ impl Response {
 
     // https://fetch.spec.whatwg.org/#dom-response-error
     pub fn Error(global: GlobalRef) -> Root<Response> {
-        let r = Response::new(global);
+        let r = Response::new(global.as_global_scope());
         *r.response_type.borrow_mut() = DOMResponseType::Error;
         r.Headers().set_guard(Guard::Immutable);
         *r.raw_status.borrow_mut() = Some((0, b"".to_vec()));
@@ -166,7 +167,7 @@ impl Response {
 
         // Step 4
         // see Step 4 continued
-        let r = Response::new(global);
+        let r = Response::new(global.as_global_scope());
 
         // Step 5
         *r.status.borrow_mut() = Some(StatusCode::from_u16(status));
@@ -292,7 +293,7 @@ impl ResponseMethods for Response {
 
     // https://fetch.spec.whatwg.org/#dom-response-headers
     fn Headers(&self) -> Root<Headers> {
-        self.headers_reflector.or_init(|| Headers::for_response(self.global().r()))
+        self.headers_reflector.or_init(|| Headers::for_response(self.global().r().as_global_scope()))
     }
 
     // https://fetch.spec.whatwg.org/#dom-response-clone
@@ -301,7 +302,7 @@ impl ResponseMethods for Response {
         // TODO: This step relies on body and stream, which are still unimplemented.
 
         // Step 2
-        let new_response = Response::new(self.global().r());
+        let new_response = Response::new(self.global().r().as_global_scope());
         new_response.Headers().set_guard(self.Headers().get_guard());
 
         // https://fetch.spec.whatwg.org/#concept-response-clone
diff --git a/components/script/dom/screen.rs b/components/script/dom/screen.rs
index 158615e84dc..2c9fe185de1 100644
--- a/components/script/dom/screen.rs
+++ b/components/script/dom/screen.rs
@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::ScreenBinding;
 use dom::bindings::codegen::Bindings::ScreenBinding::ScreenMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::window::Window;
@@ -23,7 +22,7 @@ impl Screen {
 
     pub fn new(window: &Window) -> Root<Screen> {
         reflect_dom_object(box Screen::new_inherited(),
-                           GlobalRef::Window(window),
+                           window,
                            ScreenBinding::Wrap)
     }
 }
diff --git a/components/script/dom/serviceworker.rs b/components/script/dom/serviceworker.rs
index 8abcec513ce..cce149b5368 100644
--- a/components/script/dom/serviceworker.rs
+++ b/components/script/dom/serviceworker.rs
@@ -7,7 +7,6 @@ use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::Bindings::ServiceWorkerBinding::{ServiceWorkerMethods, ServiceWorkerState, Wrap};
 use dom::bindings::error::{ErrorResult, Error};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::refcounted::Trusted;
@@ -15,6 +14,7 @@ use dom::bindings::reflector::{Reflectable, reflect_dom_object};
 use dom::bindings::str::USVString;
 use dom::bindings::structuredclone::StructuredCloneData;
 use dom::eventtarget::EventTarget;
+use dom::globalscope::GlobalScope;
 use js::jsapi::{HandleValue, JSContext};
 use script_thread::Runnable;
 use script_traits::{ScriptMsg, DOMMessage};
@@ -45,7 +45,7 @@ impl ServiceWorker {
         }
     }
 
-    pub fn install_serviceworker(global: GlobalRef,
+    pub fn install_serviceworker(global: &GlobalScope,
                 script_url: Url,
                 scope_url: Url,
                 skip_waiting: bool) -> Root<ServiceWorker> {
diff --git a/components/script/dom/serviceworkercontainer.rs b/components/script/dom/serviceworkercontainer.rs
index abeb69f2ea3..3d9202accf4 100644
--- a/components/script/dom/serviceworkercontainer.rs
+++ b/components/script/dom/serviceworkercontainer.rs
@@ -5,12 +5,12 @@
 use dom::bindings::codegen::Bindings::ServiceWorkerContainerBinding::{ServiceWorkerContainerMethods, Wrap};
 use dom::bindings::codegen::Bindings::ServiceWorkerContainerBinding::RegistrationOptions;
 use dom::bindings::error::{Error, Fallible};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::bindings::reflector::{Reflectable, reflect_dom_object};
 use dom::bindings::str::USVString;
 use dom::eventtarget::EventTarget;
+use dom::globalscope::GlobalScope;
 use dom::serviceworker::ServiceWorker;
 use dom::serviceworkerregistration::ServiceWorkerRegistration;
 use script_thread::ScriptThread;
@@ -31,7 +31,7 @@ impl ServiceWorkerContainer {
         }
     }
 
-    pub fn new(global: GlobalRef) -> Root<ServiceWorkerContainer> {
+    pub fn new(global: &GlobalScope) -> Root<ServiceWorkerContainer> {
         reflect_dom_object(box ServiceWorkerContainer::new_inherited(), global, Wrap)
     }
 }
@@ -95,7 +95,7 @@ impl ServiceWorkerContainerMethods for ServiceWorkerContainer {
             return Err(Error::Type("Scope URL contains forbidden characters".to_owned()));
         }
 
-        let worker_registration = ServiceWorkerRegistration::new(self.global().r(),
+        let worker_registration = ServiceWorkerRegistration::new(self.global().r().as_global_scope(),
                                                                  script_url,
                                                                  scope.clone(),
                                                                  self);
diff --git a/components/script/dom/serviceworkerglobalscope.rs b/components/script/dom/serviceworkerglobalscope.rs
index 6efd555c909..d635f1cd41f 100644
--- a/components/script/dom/serviceworkerglobalscope.rs
+++ b/components/script/dom/serviceworkerglobalscope.rs
@@ -302,8 +302,7 @@ impl ServiceWorkerGlobalScope {
     }
 
     fn dispatch_activate(&self) {
-        let global = GlobalRef::Worker(self.upcast::<WorkerGlobalScope>());
-        let event = ExtendableEvent::new(global, atom!("activate"), false, false);
+        let event = ExtendableEvent::new(self.upcast(), atom!("activate"), false, false);
         let event = (&*event).upcast::<Event>();
         self.upcast::<EventTarget>().dispatch_event(event);
     }
diff --git a/components/script/dom/serviceworkerregistration.rs b/components/script/dom/serviceworkerregistration.rs
index f7c47b8ecec..b0580457f1c 100644
--- a/components/script/dom/serviceworkerregistration.rs
+++ b/components/script/dom/serviceworkerregistration.rs
@@ -9,6 +9,7 @@ use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::USVString;
 use dom::eventtarget::EventTarget;
+use dom::globalscope::GlobalScope;
 use dom::serviceworker::ServiceWorker;
 use dom::serviceworkercontainer::Controllable;
 use dom::workerglobalscope::prepare_workerscope_init;
@@ -35,7 +36,7 @@ impl ServiceWorkerRegistration {
         }
     }
     #[allow(unrooted_must_root)]
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                script_url: Url,
                scope: Url,
                container: &Controllable) -> Root<ServiceWorkerRegistration> {
diff --git a/components/script/dom/servohtmlparser.rs b/components/script/dom/servohtmlparser.rs
index 24a22be75dd..0f0976d0f78 100644
--- a/components/script/dom/servohtmlparser.rs
+++ b/components/script/dom/servohtmlparser.rs
@@ -11,7 +11,6 @@ use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
 use dom::bindings::codegen::Bindings::HTMLImageElementBinding::HTMLImageElementMethods;
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
 use dom::bindings::codegen::Bindings::ServoHTMLParserBinding;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::refcounted::Trusted;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
@@ -277,8 +276,7 @@ impl ServoHTMLParser {
             pipeline: pipeline,
         };
 
-        reflect_dom_object(box parser, GlobalRef::Window(document.window()),
-                           ServoHTMLParserBinding::Wrap)
+        reflect_dom_object(box parser, document.window(), ServoHTMLParserBinding::Wrap)
     }
 
     #[allow(unrooted_must_root)]
@@ -314,8 +312,7 @@ impl ServoHTMLParser {
             pipeline: None,
         };
 
-        reflect_dom_object(box parser, GlobalRef::Window(document.window()),
-                           ServoHTMLParserBinding::Wrap)
+        reflect_dom_object(box parser, document.window(), ServoHTMLParserBinding::Wrap)
     }
 
     #[inline]
diff --git a/components/script/dom/servoxmlparser.rs b/components/script/dom/servoxmlparser.rs
index 892477ffd0f..2b79a5cf117 100644
--- a/components/script/dom/servoxmlparser.rs
+++ b/components/script/dom/servoxmlparser.rs
@@ -4,7 +4,6 @@
 
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::ServoXMLParserBinding;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::trace::JSTraceable;
@@ -95,8 +94,7 @@ impl ServoXMLParser {
             pipeline: pipeline,
         };
 
-        reflect_dom_object(box parser, GlobalRef::Window(document.window()),
-                           ServoXMLParserBinding::Wrap)
+        reflect_dom_object(box parser, document.window(), ServoXMLParserBinding::Wrap)
     }
 
     pub fn window(&self) -> &Window {
diff --git a/components/script/dom/storage.rs b/components/script/dom/storage.rs
index 411e304b2f5..986cd8edcbe 100644
--- a/components/script/dom/storage.rs
+++ b/components/script/dom/storage.rs
@@ -5,13 +5,13 @@
 use dom::bindings::codegen::Bindings::StorageBinding;
 use dom::bindings::codegen::Bindings::StorageBinding::StorageMethods;
 use dom::bindings::error::{Error, ErrorResult};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::refcounted::Trusted;
 use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
 use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::globalscope::GlobalScope;
 use dom::storageevent::StorageEvent;
 use dom::urlhelper::UrlHelper;
 use ipc_channel::ipc::{self, IpcSender};
@@ -35,8 +35,8 @@ impl Storage {
         }
     }
 
-    pub fn new(global: &GlobalRef, storage_type: StorageType) -> Root<Storage> {
-        reflect_dom_object(box Storage::new_inherited(storage_type), *global, StorageBinding::Wrap)
+    pub fn new(global: &GlobalScope, storage_type: StorageType) -> Root<Storage> {
+        reflect_dom_object(box Storage::new_inherited(storage_type), global, StorageBinding::Wrap)
     }
 
     fn get_url(&self) -> Url {
@@ -191,7 +191,7 @@ impl Runnable for StorageEventRunnable {
         let ev_url = storage.get_url();
 
         let storage_event = StorageEvent::new(
-            global_ref,
+            global_ref.as_global_scope(),
             atom!("storage"),
             EventBubbles::DoesNotBubble, EventCancelable::NotCancelable,
             this.key.map(DOMString::from), this.old_value.map(DOMString::from), this.new_value.map(DOMString::from),
diff --git a/components/script/dom/storageevent.rs b/components/script/dom/storageevent.rs
index 69fe7c257d5..0b4a484ebc0 100644
--- a/components/script/dom/storageevent.rs
+++ b/components/script/dom/storageevent.rs
@@ -12,6 +12,7 @@ use dom::bindings::js::{JS, MutNullableHeap, Root, RootedReference};
 use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
 use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::globalscope::GlobalScope;
 use dom::storage::Storage;
 use dom::window::Window;
 use string_cache::Atom;
@@ -46,11 +47,11 @@ impl StorageEvent {
     pub fn new_uninitialized(window: &Window,
                              url: DOMString) -> Root<StorageEvent> {
         reflect_dom_object(box StorageEvent::new_inherited(None, None, None, url, None),
-                           GlobalRef::Window(window),
+                           window,
                            StorageEventBinding::Wrap)
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                type_: Atom,
                bubbles: EventBubbles,
                cancelable: EventCancelable,
@@ -80,7 +81,7 @@ impl StorageEvent {
         let storageArea = init.storageArea.r();
         let bubbles = EventBubbles::from(init.parent.bubbles);
         let cancelable = EventCancelable::from(init.parent.cancelable);
-        let event = StorageEvent::new(global, Atom::from(type_),
+        let event = StorageEvent::new(global.as_global_scope(), Atom::from(type_),
                                       bubbles, cancelable,
                                       key, oldValue, newValue,
                                       url, storageArea);
diff --git a/components/script/dom/stylesheet.rs b/components/script/dom/stylesheet.rs
index 15b8693c537..02c96623800 100644
--- a/components/script/dom/stylesheet.rs
+++ b/components/script/dom/stylesheet.rs
@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::StyleSheetBinding;
 use dom::bindings::codegen::Bindings::StyleSheetBinding::StyleSheetMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
@@ -35,7 +34,7 @@ impl StyleSheet {
                href: Option<DOMString>,
                title: Option<DOMString>) -> Root<StyleSheet> {
         reflect_dom_object(box StyleSheet::new_inherited(type_, href, title),
-                           GlobalRef::Window(window),
+                           window,
                            StyleSheetBinding::Wrap)
     }
 }
diff --git a/components/script/dom/stylesheetlist.rs b/components/script/dom/stylesheetlist.rs
index 721ac06525c..a4541fc9bb4 100644
--- a/components/script/dom/stylesheetlist.rs
+++ b/components/script/dom/stylesheetlist.rs
@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::StyleSheetListBinding;
 use dom::bindings::codegen::Bindings::StyleSheetListBinding::StyleSheetListMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::document::Document;
@@ -29,7 +28,7 @@ impl StyleSheetList {
     #[allow(unrooted_must_root)]
     pub fn new(window: &Window, document: JS<Document>) -> Root<StyleSheetList> {
         reflect_dom_object(box StyleSheetList::new_inherited(document),
-                           GlobalRef::Window(window), StyleSheetListBinding::Wrap)
+                           window, StyleSheetListBinding::Wrap)
     }
 }
 
diff --git a/components/script/dom/testbinding.rs b/components/script/dom/testbinding.rs
index 6f7d7baf770..62714dfc220 100644
--- a/components/script/dom/testbinding.rs
+++ b/components/script/dom/testbinding.rs
@@ -30,6 +30,7 @@ use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::str::{ByteString, DOMString, USVString};
 use dom::bindings::weakref::MutableWeakRef;
 use dom::blob::{Blob, BlobImpl};
+use dom::globalscope::GlobalScope;
 use dom::promise::Promise;
 use dom::promisenativehandler::{PromiseNativeHandler, Callback};
 use dom::url::URL;
@@ -57,23 +58,23 @@ impl TestBinding {
         }
     }
 
-    pub fn new(global: GlobalRef) -> Root<TestBinding> {
+    pub fn new(global: &GlobalScope) -> Root<TestBinding> {
         reflect_dom_object(box TestBinding::new_inherited(),
                            global, TestBindingBinding::Wrap)
     }
 
     pub fn Constructor(global: GlobalRef) -> Fallible<Root<TestBinding>> {
-        Ok(TestBinding::new(global))
+        Ok(TestBinding::new(global.as_global_scope()))
     }
 
     #[allow(unused_variables)]
     pub fn Constructor_(global: GlobalRef, nums: Vec<f64>) -> Fallible<Root<TestBinding>> {
-        Ok(TestBinding::new(global))
+        Ok(TestBinding::new(global.as_global_scope()))
     }
 
     #[allow(unused_variables)]
     pub fn Constructor__(global: GlobalRef, num: f64) -> Fallible<Root<TestBinding>> {
-        Ok(TestBinding::new(global))
+        Ok(TestBinding::new(global.as_global_scope()))
     }
 }
 
@@ -113,7 +114,7 @@ impl TestBindingMethods for TestBinding {
     fn EnumAttribute(&self) -> TestEnum { TestEnum::_empty }
     fn SetEnumAttribute(&self, _: TestEnum) {}
     fn InterfaceAttribute(&self) -> Root<Blob> {
-        Blob::new(self.global().r(), BlobImpl::new_from_bytes(vec![]), "".to_owned())
+        Blob::new(self.global().r().as_global_scope(), BlobImpl::new_from_bytes(vec![]), "".to_owned())
     }
     fn SetInterfaceAttribute(&self, _: &Blob) {}
     fn UnionAttribute(&self) -> HTMLElementOrLong { HTMLElementOrLong::Long(0) }
@@ -209,7 +210,7 @@ impl TestBindingMethods for TestBinding {
     fn SetAttr_to_automatically_rename(&self, _: DOMString) {}
     fn GetEnumAttributeNullable(&self) -> Option<TestEnum> { Some(TestEnum::_empty) }
     fn GetInterfaceAttributeNullable(&self) -> Option<Root<Blob>> {
-        Some(Blob::new(self.global().r(), BlobImpl::new_from_bytes(vec![]), "".to_owned()))
+        Some(Blob::new(self.global().r().as_global_scope(), BlobImpl::new_from_bytes(vec![]), "".to_owned()))
     }
     fn SetInterfaceAttributeNullable(&self, _: Option<&Blob>) {}
     fn GetInterfaceAttributeWeak(&self) -> Option<Root<URL>> {
@@ -264,7 +265,7 @@ impl TestBindingMethods for TestBinding {
     fn ReceiveByteString(&self) -> ByteString { ByteString::new(vec!()) }
     fn ReceiveEnum(&self) -> TestEnum { TestEnum::_empty }
     fn ReceiveInterface(&self) -> Root<Blob> {
-        Blob::new(self.global().r(), BlobImpl::new_from_bytes(vec![]), "".to_owned())
+        Blob::new(self.global().r().as_global_scope(), BlobImpl::new_from_bytes(vec![]), "".to_owned())
     }
     fn ReceiveAny(&self, _: *mut JSContext) -> JSVal { NullValue() }
     fn ReceiveObject(&self, cx: *mut JSContext) -> NonZero<*mut JSObject> {
@@ -287,7 +288,7 @@ impl TestBindingMethods for TestBinding {
     }
     fn ReceiveSequence(&self) -> Vec<i32> { vec![1] }
     fn ReceiveInterfaceSequence(&self) -> Vec<Root<Blob>> {
-        vec![Blob::new(self.global().r(), BlobImpl::new_from_bytes(vec![]), "".to_owned())]
+        vec![Blob::new(self.global().r().as_global_scope(), BlobImpl::new_from_bytes(vec![]), "".to_owned())]
     }
 
     fn ReceiveNullableBoolean(&self) -> Option<bool> { Some(false) }
@@ -308,7 +309,7 @@ impl TestBindingMethods for TestBinding {
     fn ReceiveNullableByteString(&self) -> Option<ByteString> { Some(ByteString::new(vec!())) }
     fn ReceiveNullableEnum(&self) -> Option<TestEnum> { Some(TestEnum::_empty) }
     fn ReceiveNullableInterface(&self) -> Option<Root<Blob>> {
-        Some(Blob::new(self.global().r(), BlobImpl::new_from_bytes(vec![]), "".to_owned()))
+        Some(Blob::new(self.global().r().as_global_scope(), BlobImpl::new_from_bytes(vec![]), "".to_owned()))
     }
     fn ReceiveNullableObject(&self, cx: *mut JSContext) -> Option<NonZero<*mut JSObject>> {
         self.GetObjectAttributeNullable(cx)
@@ -691,7 +692,7 @@ impl TestBindingMethods for TestBinding {
                             resolve: Option<Rc<SimpleCallback>>,
                             reject: Option<Rc<SimpleCallback>>) -> Rc<Promise> {
         let global = self.global();
-        let handler = PromiseNativeHandler::new(global.r(),
+        let handler = PromiseNativeHandler::new(global.r().as_global_scope(),
                                                 resolve.map(SimpleHandler::new),
                                                 reject.map(SimpleHandler::new));
         let p = Promise::new(global.r());
diff --git a/components/script/dom/testbindingiterable.rs b/components/script/dom/testbindingiterable.rs
index 2ad0df6dbb6..6023051d8f6 100644
--- a/components/script/dom/testbindingiterable.rs
+++ b/components/script/dom/testbindingiterable.rs
@@ -11,6 +11,7 @@ use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
+use dom::globalscope::GlobalScope;
 
 #[dom_struct]
 pub struct TestBindingIterable {
@@ -19,7 +20,7 @@ pub struct TestBindingIterable {
 }
 
 impl TestBindingIterable {
-    fn new(global: GlobalRef) -> Root<TestBindingIterable> {
+    fn new(global: &GlobalScope) -> Root<TestBindingIterable> {
         reflect_dom_object(box TestBindingIterable {
             reflector: Reflector::new(),
             vals: DOMRefCell::new(vec![]),
@@ -27,7 +28,7 @@ impl TestBindingIterable {
     }
 
     pub fn Constructor(global: GlobalRef) -> Fallible<Root<TestBindingIterable>> {
-        Ok(TestBindingIterable::new(global))
+        Ok(TestBindingIterable::new(global.as_global_scope()))
     }
 }
 
diff --git a/components/script/dom/testbindingpairiterable.rs b/components/script/dom/testbindingpairiterable.rs
index 9bceedd4980..7e3ad537aa5 100644
--- a/components/script/dom/testbindingpairiterable.rs
+++ b/components/script/dom/testbindingpairiterable.rs
@@ -13,6 +13,7 @@ use dom::bindings::iterable::Iterable;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
+use dom::globalscope::GlobalScope;
 
 #[dom_struct]
 pub struct TestBindingPairIterable {
@@ -35,7 +36,7 @@ impl Iterable for TestBindingPairIterable {
 }
 
 impl TestBindingPairIterable {
-    fn new(global: GlobalRef) -> Root<TestBindingPairIterable> {
+    fn new(global: &GlobalScope) -> Root<TestBindingPairIterable> {
         reflect_dom_object(box TestBindingPairIterable {
             reflector: Reflector::new(),
             map: DOMRefCell::new(vec![]),
@@ -43,7 +44,7 @@ impl TestBindingPairIterable {
     }
 
     pub fn Constructor(global: GlobalRef) -> Fallible<Root<TestBindingPairIterable>> {
-        Ok(TestBindingPairIterable::new(global))
+        Ok(TestBindingPairIterable::new(global.as_global_scope()))
     }
 }
 
diff --git a/components/script/dom/textdecoder.rs b/components/script/dom/textdecoder.rs
index fae78342a73..4d0e18e87f6 100644
--- a/components/script/dom/textdecoder.rs
+++ b/components/script/dom/textdecoder.rs
@@ -10,6 +10,7 @@ use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::{DOMString, USVString};
+use dom::globalscope::GlobalScope;
 use encoding::label::encoding_from_whatwg_label;
 use encoding::types::{DecoderTrap, EncodingRef};
 use js::jsapi::{JSContext, JSObject};
@@ -36,7 +37,7 @@ impl TextDecoder {
         Err(Error::Range("The given encoding is not supported.".to_owned()))
     }
 
-    pub fn new(global: GlobalRef, encoding: EncodingRef, fatal: bool) -> Root<TextDecoder> {
+    pub fn new(global: &GlobalScope, encoding: EncodingRef, fatal: bool) -> Root<TextDecoder> {
         reflect_dom_object(box TextDecoder::new_inherited(encoding, fatal),
                            global,
                            TextDecoderBinding::Wrap)
@@ -60,7 +61,7 @@ impl TextDecoder {
             Some("replacement") => return TextDecoder::make_range_error(),
             _ => ()
         };
-        Ok(TextDecoder::new(global, encoding, options.fatal))
+        Ok(TextDecoder::new(global.as_global_scope(), encoding, options.fatal))
     }
 }
 
diff --git a/components/script/dom/textencoder.rs b/components/script/dom/textencoder.rs
index 996e5d28e98..5076c82190d 100644
--- a/components/script/dom/textencoder.rs
+++ b/components/script/dom/textencoder.rs
@@ -10,6 +10,7 @@ use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::{DOMString, USVString};
+use dom::globalscope::GlobalScope;
 use encoding::EncoderTrap;
 use encoding::Encoding;
 use encoding::all::UTF_8;
@@ -30,7 +31,7 @@ impl TextEncoder {
         }
     }
 
-    pub fn new(global: GlobalRef) -> Root<TextEncoder> {
+    pub fn new(global: &GlobalScope) -> Root<TextEncoder> {
         reflect_dom_object(box TextEncoder::new_inherited(),
                            global,
                            TextEncoderBinding::Wrap)
@@ -38,7 +39,7 @@ impl TextEncoder {
 
     // https://encoding.spec.whatwg.org/#dom-textencoder
     pub fn Constructor(global: GlobalRef) -> Fallible<Root<TextEncoder>> {
-        Ok(TextEncoder::new(global))
+        Ok(TextEncoder::new(global.as_global_scope()))
     }
 }
 
diff --git a/components/script/dom/touch.rs b/components/script/dom/touch.rs
index 29bfac34152..32eeb24b6e1 100644
--- a/components/script/dom/touch.rs
+++ b/components/script/dom/touch.rs
@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::TouchBinding;
 use dom::bindings::codegen::Bindings::TouchBinding::TouchMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutHeap, Root};
 use dom::bindings::num::Finite;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
@@ -50,7 +49,8 @@ impl Touch {
                                                     screen_x, screen_y,
                                                     client_x, client_y,
                                                     page_x, page_y),
-                           GlobalRef::Window(window), TouchBinding::Wrap)
+                           window,
+                           TouchBinding::Wrap)
     }
 }
 
diff --git a/components/script/dom/touchevent.rs b/components/script/dom/touchevent.rs
index 1a2f7334cdf..9b4b3a250d5 100644
--- a/components/script/dom/touchevent.rs
+++ b/components/script/dom/touchevent.rs
@@ -5,7 +5,6 @@
 use dom::bindings::codegen::Bindings::TouchEventBinding;
 use dom::bindings::codegen::Bindings::TouchEventBinding::TouchEventMethods;
 use dom::bindings::codegen::Bindings::UIEventBinding::UIEventMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{JS, MutHeap, Root};
 use dom::bindings::reflector::reflect_dom_object;
@@ -49,7 +48,7 @@ impl TouchEvent {
                      changed_touches: &TouchList,
                      target_touches: &TouchList) -> Root<TouchEvent> {
         reflect_dom_object(box TouchEvent::new_inherited(touches, changed_touches, target_touches),
-                           GlobalRef::Window(window),
+                           window,
                            TouchEventBinding::Wrap)
     }
 
diff --git a/components/script/dom/touchlist.rs b/components/script/dom/touchlist.rs
index 14bb8a68766..a4ff7f8443e 100644
--- a/components/script/dom/touchlist.rs
+++ b/components/script/dom/touchlist.rs
@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::TouchListBinding;
 use dom::bindings::codegen::Bindings::TouchListBinding::TouchListMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::touch::Touch;
@@ -26,7 +25,7 @@ impl TouchList {
 
     pub fn new(window: &Window, touches: &[&Touch]) -> Root<TouchList> {
         reflect_dom_object(box TouchList::new_inherited(touches),
-                           GlobalRef::Window(window), TouchListBinding::Wrap)
+                           window, TouchListBinding::Wrap)
     }
 }
 
diff --git a/components/script/dom/treewalker.rs b/components/script/dom/treewalker.rs
index c4097fc761a..7c749a5c502 100644
--- a/components/script/dom/treewalker.rs
+++ b/components/script/dom/treewalker.rs
@@ -9,7 +9,6 @@ use dom::bindings::codegen::Bindings::NodeFilterBinding::NodeFilterConstants;
 use dom::bindings::codegen::Bindings::TreeWalkerBinding;
 use dom::bindings::codegen::Bindings::TreeWalkerBinding::TreeWalkerMethods;
 use dom::bindings::error::Fallible;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutHeap};
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
@@ -46,7 +45,7 @@ impl TreeWalker {
                            what_to_show: u32,
                            filter: Filter) -> Root<TreeWalker> {
         reflect_dom_object(box TreeWalker::new_inherited(root_node, what_to_show, filter),
-                           GlobalRef::Window(document.window()),
+                           document.window(),
                            TreeWalkerBinding::Wrap)
     }
 
diff --git a/components/script/dom/uievent.rs b/components/script/dom/uievent.rs
index a0f35868662..0b64e36c62f 100644
--- a/components/script/dom/uievent.rs
+++ b/components/script/dom/uievent.rs
@@ -37,7 +37,7 @@ impl UIEvent {
 
     pub fn new_uninitialized(window: &Window) -> Root<UIEvent> {
         reflect_dom_object(box UIEvent::new_inherited(),
-                           GlobalRef::Window(window),
+                           window,
                            UIEventBinding::Wrap)
     }
 
diff --git a/components/script/dom/url.rs b/components/script/dom/url.rs
index bc686d23cc4..5fd4a9b005f 100644
--- a/components/script/dom/url.rs
+++ b/components/script/dom/url.rs
@@ -11,6 +11,7 @@ use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::str::{DOMString, USVString};
 use dom::blob::Blob;
+use dom::globalscope::GlobalScope;
 use dom::urlhelper::UrlHelper;
 use dom::urlsearchparams::URLSearchParams;
 use ipc_channel::ipc;
@@ -44,7 +45,7 @@ impl URL {
         }
     }
 
-    pub fn new(global: GlobalRef, url: Url) -> Root<URL> {
+    pub fn new(global: &GlobalScope, url: Url) -> Root<URL> {
         reflect_dom_object(box URL::new_inherited(url),
                            global, URLBinding::Wrap)
     }
@@ -89,7 +90,7 @@ impl URL {
         };
         // Step 5: Skip (see step 8 below).
         // Steps 6-7.
-        let result = URL::new(global, parsed_url);
+        let result = URL::new(global.as_global_scope(), parsed_url);
         // Step 8: Instead of construcing a new `URLSearchParams` object here, construct it
         //         on-demand inside `URL::SearchParams`.
         // Step 9.
@@ -283,7 +284,9 @@ impl URLMethods for URL {
 
     // https://url.spec.whatwg.org/#dom-url-searchparams
     fn SearchParams(&self) -> Root<URLSearchParams> {
-        self.search_params.or_init(|| URLSearchParams::new(self.global().r(), Some(self)))
+        self.search_params.or_init(|| {
+            URLSearchParams::new(self.global().r().as_global_scope(), Some(self))
+        })
     }
 
     // https://url.spec.whatwg.org/#dom-url-href
diff --git a/components/script/dom/urlsearchparams.rs b/components/script/dom/urlsearchparams.rs
index 44eadea0932..a7b1672852f 100644
--- a/components/script/dom/urlsearchparams.rs
+++ b/components/script/dom/urlsearchparams.rs
@@ -12,6 +12,7 @@ use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::{DOMString, USVString};
 use dom::bindings::weakref::MutableWeakRef;
+use dom::globalscope::GlobalScope;
 use dom::url::URL;
 use encoding::types::EncodingRef;
 use url::form_urlencoded;
@@ -35,7 +36,7 @@ impl URLSearchParams {
         }
     }
 
-    pub fn new(global: GlobalRef, url: Option<&URL>) -> Root<URLSearchParams> {
+    pub fn new(global: &GlobalScope, url: Option<&URL>) -> Root<URLSearchParams> {
         reflect_dom_object(box URLSearchParams::new_inherited(url), global,
                            URLSearchParamsBinding::Wrap)
     }
@@ -44,7 +45,7 @@ impl URLSearchParams {
     pub fn Constructor(global: GlobalRef, init: Option<USVStringOrURLSearchParams>) ->
                        Fallible<Root<URLSearchParams>> {
         // Step 1.
-        let query = URLSearchParams::new(global, None);
+        let query = URLSearchParams::new(global.as_global_scope(), None);
         match init {
             Some(USVStringOrURLSearchParams::USVString(init)) => {
                 // Step 2.
diff --git a/components/script/dom/validitystate.rs b/components/script/dom/validitystate.rs
index 7595566f275..938320b7254 100644
--- a/components/script/dom/validitystate.rs
+++ b/components/script/dom/validitystate.rs
@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::ValidityStateBinding;
 use dom::bindings::codegen::Bindings::ValidityStateBinding::ValidityStateMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::element::Element;
@@ -47,7 +46,7 @@ impl ValidityState {
 
     pub fn new(window: &Window, element: &Element) -> Root<ValidityState> {
         reflect_dom_object(box ValidityState::new_inherited(element),
-                           GlobalRef::Window(window),
+                           window,
                            ValidityStateBinding::Wrap)
     }
 }
diff --git a/components/script/dom/webglactiveinfo.rs b/components/script/dom/webglactiveinfo.rs
index 00f70b682b7..ff82ce3b05f 100644
--- a/components/script/dom/webglactiveinfo.rs
+++ b/components/script/dom/webglactiveinfo.rs
@@ -5,10 +5,10 @@
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
 use dom::bindings::codegen::Bindings::WebGLActiveInfoBinding;
 use dom::bindings::codegen::Bindings::WebGLActiveInfoBinding::WebGLActiveInfoMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
+use dom::globalscope::GlobalScope;
 
 #[dom_struct]
 pub struct WebGLActiveInfo {
@@ -29,7 +29,7 @@ impl WebGLActiveInfo {
         }
     }
 
-    pub fn new(global: GlobalRef, size: i32, ty: u32, name: DOMString) -> Root<WebGLActiveInfo> {
+    pub fn new(global: &GlobalScope, size: i32, ty: u32, name: DOMString) -> Root<WebGLActiveInfo> {
         reflect_dom_object(box WebGLActiveInfo::new_inherited(size, ty, name), global, WebGLActiveInfoBinding::Wrap)
     }
 }
diff --git a/components/script/dom/webglbuffer.rs b/components/script/dom/webglbuffer.rs
index 3899d417b38..af8f83d256d 100644
--- a/components/script/dom/webglbuffer.rs
+++ b/components/script/dom/webglbuffer.rs
@@ -5,9 +5,9 @@
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
 use canvas_traits::CanvasMsg;
 use dom::bindings::codegen::Bindings::WebGLBufferBinding;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
+use dom::globalscope::GlobalScope;
 use dom::webglobject::WebGLObject;
 use ipc_channel::ipc::{self, IpcSender};
 use std::cell::Cell;
@@ -39,7 +39,7 @@ impl WebGLBuffer {
         }
     }
 
-    pub fn maybe_new(global: GlobalRef, renderer: IpcSender<CanvasMsg>)
+    pub fn maybe_new(global: &GlobalScope, renderer: IpcSender<CanvasMsg>)
                      -> Option<Root<WebGLBuffer>> {
         let (sender, receiver) = ipc::channel().unwrap();
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateBuffer(sender))).unwrap();
@@ -48,7 +48,7 @@ impl WebGLBuffer {
         result.map(|buffer_id| WebGLBuffer::new(global, renderer, buffer_id))
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                renderer: IpcSender<CanvasMsg>,
                id: WebGLBufferId)
               -> Root<WebGLBuffer> {
diff --git a/components/script/dom/webglcontextevent.rs b/components/script/dom/webglcontextevent.rs
index 9c73a9f6b65..01ab7e0eec1 100644
--- a/components/script/dom/webglcontextevent.rs
+++ b/components/script/dom/webglcontextevent.rs
@@ -13,6 +13,7 @@ use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
 use dom::event::{Event, EventBubbles, EventCancelable};
+use dom::globalscope::GlobalScope;
 use string_cache::Atom;
 
 #[dom_struct]
@@ -41,7 +42,7 @@ impl WebGLContextEvent {
         }
     }
 
-    pub fn new_uninitialized(global_ref: GlobalRef) -> Root<WebGLContextEvent> {
+    pub fn new_uninitialized(global_ref: &GlobalScope) -> Root<WebGLContextEvent> {
         // according to https://www.khronos.org/registry/webgl/specs/1.0/#5.15 this is
         // additional information or the empty string if no additional information is
         // available.
@@ -52,7 +53,7 @@ impl WebGLContextEvent {
                         WebGLContextEventBinding::Wrap)
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                type_: Atom,
                bubbles: EventBubbles,
                cancelable: EventCancelable,
@@ -82,7 +83,8 @@ impl WebGLContextEvent {
 
         let cancelable = EventCancelable::from(init.parent.cancelable);
 
-        Ok(WebGLContextEvent::new(global, Atom::from(type_),
+        Ok(WebGLContextEvent::new(global.as_global_scope(),
+                                  Atom::from(type_),
                                   bubbles,
                                   cancelable,
                                   status_message))
diff --git a/components/script/dom/webglframebuffer.rs b/components/script/dom/webglframebuffer.rs
index cd212d644bf..22749832389 100644
--- a/components/script/dom/webglframebuffer.rs
+++ b/components/script/dom/webglframebuffer.rs
@@ -6,9 +6,9 @@
 use canvas_traits::CanvasMsg;
 use dom::bindings::codegen::Bindings::WebGLFramebufferBinding;
 use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
+use dom::globalscope::GlobalScope;
 use dom::webglobject::WebGLObject;
 use ipc_channel::ipc::{self, IpcSender};
 use std::cell::Cell;
@@ -38,7 +38,7 @@ impl WebGLFramebuffer {
         }
     }
 
-    pub fn maybe_new(global: GlobalRef, renderer: IpcSender<CanvasMsg>)
+    pub fn maybe_new(global: &GlobalScope, renderer: IpcSender<CanvasMsg>)
                      -> Option<Root<WebGLFramebuffer>> {
         let (sender, receiver) = ipc::channel().unwrap();
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateFramebuffer(sender))).unwrap();
@@ -47,7 +47,7 @@ impl WebGLFramebuffer {
         result.map(|fb_id| WebGLFramebuffer::new(global, renderer, fb_id))
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                renderer: IpcSender<CanvasMsg>,
                id: WebGLFramebufferId)
                -> Root<WebGLFramebuffer> {
diff --git a/components/script/dom/webglobject.rs b/components/script/dom/webglobject.rs
index c6bc733de62..0964fc5d0cf 100644
--- a/components/script/dom/webglobject.rs
+++ b/components/script/dom/webglobject.rs
@@ -4,9 +4,9 @@
 
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
 use dom::bindings::codegen::Bindings::WebGLObjectBinding;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::globalscope::GlobalScope;
 
 #[dom_struct]
 pub struct WebGLObject {
@@ -20,7 +20,7 @@ impl WebGLObject {
         }
     }
 
-    pub fn new(global: GlobalRef) -> Root<WebGLObject> {
+    pub fn new(global: &GlobalScope) -> Root<WebGLObject> {
         reflect_dom_object(box WebGLObject::new_inherited(), global, WebGLObjectBinding::Wrap)
     }
 }
diff --git a/components/script/dom/webglprogram.rs b/components/script/dom/webglprogram.rs
index 6382897efb3..4b3b39b05cc 100644
--- a/components/script/dom/webglprogram.rs
+++ b/components/script/dom/webglprogram.rs
@@ -6,10 +6,10 @@
 use canvas_traits::CanvasMsg;
 use dom::bindings::codegen::Bindings::WebGLProgramBinding;
 use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::bindings::reflector::{Reflectable, reflect_dom_object};
 use dom::bindings::str::DOMString;
+use dom::globalscope::GlobalScope;
 use dom::webglactiveinfo::WebGLActiveInfo;
 use dom::webglobject::WebGLObject;
 use dom::webglrenderingcontext::MAX_UNIFORM_AND_ATTRIBUTE_LEN;
@@ -48,7 +48,7 @@ impl WebGLProgram {
         }
     }
 
-    pub fn maybe_new(global: GlobalRef, renderer: IpcSender<CanvasMsg>)
+    pub fn maybe_new(global: &GlobalScope, renderer: IpcSender<CanvasMsg>)
                      -> Option<Root<WebGLProgram>> {
         let (sender, receiver) = ipc::channel().unwrap();
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateProgram(sender))).unwrap();
@@ -57,7 +57,7 @@ impl WebGLProgram {
         result.map(|program_id| WebGLProgram::new(global, renderer, program_id))
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                renderer: IpcSender<CanvasMsg>,
                id: WebGLProgramId)
                -> Root<WebGLProgram> {
@@ -230,7 +230,7 @@ impl WebGLProgram {
             .unwrap();
 
         receiver.recv().unwrap().map(|(size, ty, name)|
-            WebGLActiveInfo::new(self.global().r(), size, ty, DOMString::from(name)))
+            WebGLActiveInfo::new(self.global().r().as_global_scope(), size, ty, DOMString::from(name)))
     }
 
     /// glGetActiveAttrib
@@ -244,7 +244,7 @@ impl WebGLProgram {
             .unwrap();
 
         receiver.recv().unwrap().map(|(size, ty, name)|
-            WebGLActiveInfo::new(self.global().r(), size, ty, DOMString::from(name)))
+            WebGLActiveInfo::new(self.global().r().as_global_scope(), size, ty, DOMString::from(name)))
     }
 
     /// glGetAttribLocation
diff --git a/components/script/dom/webglrenderbuffer.rs b/components/script/dom/webglrenderbuffer.rs
index b7e89f2eb22..de4eaa2d2c8 100644
--- a/components/script/dom/webglrenderbuffer.rs
+++ b/components/script/dom/webglrenderbuffer.rs
@@ -5,9 +5,9 @@
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
 use canvas_traits::CanvasMsg;
 use dom::bindings::codegen::Bindings::WebGLRenderbufferBinding;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
+use dom::globalscope::GlobalScope;
 use dom::webglobject::WebGLObject;
 use ipc_channel::ipc::{self, IpcSender};
 use std::cell::Cell;
@@ -36,7 +36,7 @@ impl WebGLRenderbuffer {
         }
     }
 
-    pub fn maybe_new(global: GlobalRef, renderer: IpcSender<CanvasMsg>)
+    pub fn maybe_new(global: &GlobalScope, renderer: IpcSender<CanvasMsg>)
                      -> Option<Root<WebGLRenderbuffer>> {
         let (sender, receiver) = ipc::channel().unwrap();
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateRenderbuffer(sender))).unwrap();
@@ -45,7 +45,7 @@ impl WebGLRenderbuffer {
         result.map(|renderbuffer_id| WebGLRenderbuffer::new(global, renderer, renderbuffer_id))
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                renderer: IpcSender<CanvasMsg>,
                id: WebGLRenderbufferId)
                -> Root<WebGLRenderbuffer> {
diff --git a/components/script/dom/webglrenderingcontext.rs b/components/script/dom/webglrenderingcontext.rs
index b69f11146fd..4b6e8b2cefd 100644
--- a/components/script/dom/webglrenderingcontext.rs
+++ b/components/script/dom/webglrenderingcontext.rs
@@ -162,11 +162,11 @@ impl WebGLRenderingContext {
     pub fn new(global: GlobalRef, canvas: &HTMLCanvasElement, size: Size2D<i32>, attrs: GLContextAttributes)
                -> Option<Root<WebGLRenderingContext>> {
         match WebGLRenderingContext::new_inherited(global, canvas, size, attrs) {
-            Ok(ctx) => Some(reflect_dom_object(box ctx, global,
+            Ok(ctx) => Some(reflect_dom_object(box ctx, global.as_global_scope(),
                                                WebGLRenderingContextBinding::Wrap)),
             Err(msg) => {
                 error!("Couldn't create WebGLRenderingContext: {}", msg);
-                let event = WebGLContextEvent::new(global,
+                let event = WebGLContextEvent::new(global.as_global_scope(),
                                                    atom!("webglcontextcreationerror"),
                                                    EventBubbles::DoesNotBubble,
                                                    EventCancelable::Cancelable,
@@ -1154,27 +1154,27 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     // generated objects, either here or in the webgl thread
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5
     fn CreateBuffer(&self) -> Option<Root<WebGLBuffer>> {
-        WebGLBuffer::maybe_new(self.global().r(), self.ipc_renderer.clone())
+        WebGLBuffer::maybe_new(self.global().r().as_global_scope(), self.ipc_renderer.clone())
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
     fn CreateFramebuffer(&self) -> Option<Root<WebGLFramebuffer>> {
-        WebGLFramebuffer::maybe_new(self.global().r(), self.ipc_renderer.clone())
+        WebGLFramebuffer::maybe_new(self.global().r().as_global_scope(), self.ipc_renderer.clone())
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.7
     fn CreateRenderbuffer(&self) -> Option<Root<WebGLRenderbuffer>> {
-        WebGLRenderbuffer::maybe_new(self.global().r(), self.ipc_renderer.clone())
+        WebGLRenderbuffer::maybe_new(self.global().r().as_global_scope(), self.ipc_renderer.clone())
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8
     fn CreateTexture(&self) -> Option<Root<WebGLTexture>> {
-        WebGLTexture::maybe_new(self.global().r(), self.ipc_renderer.clone())
+        WebGLTexture::maybe_new(self.global().r().as_global_scope(), self.ipc_renderer.clone())
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn CreateProgram(&self) -> Option<Root<WebGLProgram>> {
-        WebGLProgram::maybe_new(self.global().r(), self.ipc_renderer.clone())
+        WebGLProgram::maybe_new(self.global().r().as_global_scope(), self.ipc_renderer.clone())
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
@@ -1186,7 +1186,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                 return None;
             }
         }
-        WebGLShader::maybe_new(self.global().r(), self.ipc_renderer.clone(), shader_type)
+        WebGLShader::maybe_new(self.global().r().as_global_scope(), self.ipc_renderer.clone(), shader_type)
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5
@@ -1480,7 +1480,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                           name: DOMString) -> Option<Root<WebGLUniformLocation>> {
         program.and_then(|p| {
             handle_potential_webgl_error!(self, p.get_uniform_location(name), None)
-                .map(|location| WebGLUniformLocation::new(self.global().r(), location, p.id()))
+                .map(|location| WebGLUniformLocation::new(self.global().r().as_global_scope(), location, p.id()))
         })
     }
 
diff --git a/components/script/dom/webglshader.rs b/components/script/dom/webglshader.rs
index ca2555faa8e..82d1b88a7da 100644
--- a/components/script/dom/webglshader.rs
+++ b/components/script/dom/webglshader.rs
@@ -7,10 +7,10 @@ use angle::hl::{BuiltInResources, Output, ShaderValidator};
 use canvas_traits::CanvasMsg;
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::WebGLShaderBinding;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
+use dom::globalscope::GlobalScope;
 use dom::webglobject::WebGLObject;
 use ipc_channel::ipc::{self, IpcSender};
 use std::cell::Cell;
@@ -65,7 +65,7 @@ impl WebGLShader {
         }
     }
 
-    pub fn maybe_new(global: GlobalRef,
+    pub fn maybe_new(global: &GlobalScope,
                      renderer: IpcSender<CanvasMsg>,
                      shader_type: u32) -> Option<Root<WebGLShader>> {
         let (sender, receiver) = ipc::channel().unwrap();
@@ -75,7 +75,7 @@ impl WebGLShader {
         result.map(|shader_id| WebGLShader::new(global, renderer, shader_id, shader_type))
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                renderer: IpcSender<CanvasMsg>,
                id: WebGLShaderId,
                shader_type: u32)
diff --git a/components/script/dom/webglshaderprecisionformat.rs b/components/script/dom/webglshaderprecisionformat.rs
index 6cd78b8d51a..18ba8c189a5 100644
--- a/components/script/dom/webglshaderprecisionformat.rs
+++ b/components/script/dom/webglshaderprecisionformat.rs
@@ -5,9 +5,9 @@
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
 use dom::bindings::codegen::Bindings::WebGLShaderPrecisionFormatBinding;
 use dom::bindings::codegen::Bindings::WebGLShaderPrecisionFormatBinding::WebGLShaderPrecisionFormatMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::globalscope::GlobalScope;
 
 #[dom_struct]
 pub struct WebGLShaderPrecisionFormat {
@@ -27,7 +27,7 @@ impl WebGLShaderPrecisionFormat {
         }
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                range_min: i32,
                range_max: i32,
                precision: i32) -> Root<WebGLShaderPrecisionFormat> {
diff --git a/components/script/dom/webgltexture.rs b/components/script/dom/webgltexture.rs
index e189835ee9d..31fdaafcffd 100644
--- a/components/script/dom/webgltexture.rs
+++ b/components/script/dom/webgltexture.rs
@@ -7,9 +7,9 @@ use canvas_traits::CanvasMsg;
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
 use dom::bindings::codegen::Bindings::WebGLTextureBinding;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
+use dom::globalscope::GlobalScope;
 use dom::webgl_validations::types::{TexImageTarget, TexFormat, TexDataType};
 use dom::webglobject::WebGLObject;
 use ipc_channel::ipc::{self, IpcSender};
@@ -60,7 +60,7 @@ impl WebGLTexture {
         }
     }
 
-    pub fn maybe_new(global: GlobalRef, renderer: IpcSender<CanvasMsg>)
+    pub fn maybe_new(global: &GlobalScope, renderer: IpcSender<CanvasMsg>)
                      -> Option<Root<WebGLTexture>> {
         let (sender, receiver) = ipc::channel().unwrap();
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateTexture(sender))).unwrap();
@@ -69,7 +69,7 @@ impl WebGLTexture {
         result.map(|texture_id| WebGLTexture::new(global, renderer, texture_id))
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                renderer: IpcSender<CanvasMsg>,
                id: WebGLTextureId)
                -> Root<WebGLTexture> {
diff --git a/components/script/dom/webgluniformlocation.rs b/components/script/dom/webgluniformlocation.rs
index f52cb899eb8..6e0683ec833 100644
--- a/components/script/dom/webgluniformlocation.rs
+++ b/components/script/dom/webgluniformlocation.rs
@@ -4,9 +4,9 @@
 
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
 use dom::bindings::codegen::Bindings::WebGLUniformLocationBinding;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::globalscope::GlobalScope;
 use webrender_traits::WebGLProgramId;
 
 #[dom_struct]
@@ -27,7 +27,7 @@ impl WebGLUniformLocation {
         }
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                id: i32,
                program_id: WebGLProgramId)
                -> Root<WebGLUniformLocation> {
diff --git a/components/script/dom/websocket.rs b/components/script/dom/websocket.rs
index df9c2e5ed34..4e86241f36a 100644
--- a/components/script/dom/websocket.rs
+++ b/components/script/dom/websocket.rs
@@ -20,6 +20,7 @@ use dom::blob::{Blob, BlobImpl};
 use dom::closeevent::CloseEvent;
 use dom::event::{Event, EventBubbles, EventCancelable};
 use dom::eventtarget::EventTarget;
+use dom::globalscope::GlobalScope;
 use dom::messageevent::MessageEvent;
 use dom::urlhelper::UrlHelper;
 use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
@@ -190,7 +191,7 @@ impl WebSocket {
         }
     }
 
-    fn new(global: GlobalRef, url: Url) -> Root<WebSocket> {
+    fn new(global: &GlobalScope, url: Url) -> Root<WebSocket> {
         reflect_dom_object(box WebSocket::new_inherited(url),
                            global, WebSocketBinding::Wrap)
     }
@@ -241,7 +242,7 @@ impl WebSocket {
         let origin = UrlHelper::Origin(&global.get_url()).0;
 
         // Step 7.
-        let ws = WebSocket::new(global, resource_url.clone());
+        let ws = WebSocket::new(global.as_global_scope(), resource_url.clone());
         let address = Trusted::new(ws.r());
 
         let connect_data = WebSocketConnectData {
@@ -557,7 +558,7 @@ impl Runnable for CloseTask {
         let clean_close = !self.failed;
         let code = self.code.unwrap_or(close_code::NO_STATUS);
         let reason = DOMString::from(self.reason.unwrap_or("".to_owned()));
-        let close_event = CloseEvent::new(global.r(),
+        let close_event = CloseEvent::new(global.r().as_global_scope(),
                                           atom!("close"),
                                           EventBubbles::DoesNotBubble,
                                           EventCancelable::NotCancelable,
@@ -599,7 +600,10 @@ impl Runnable for MessageReceivedTask {
                 MessageData::Binary(data) => {
                     match ws.binary_type.get() {
                         BinaryType::Blob => {
-                            let blob = Blob::new(global.r(), BlobImpl::new_from_bytes(data), "".to_owned());
+                            let blob = Blob::new(
+                                global.r().as_global_scope(),
+                                BlobImpl::new_from_bytes(data),
+                                "".to_owned());
                             blob.to_jsval(cx, message.handle_mut());
                         }
                         BinaryType::Arraybuffer => {
diff --git a/components/script/dom/window.rs b/components/script/dom/window.rs
index 85c8f46fc63..0b764f6fa05 100644
--- a/components/script/dom/window.rs
+++ b/components/script/dom/window.rs
@@ -495,17 +495,17 @@ impl WindowMethods for Window {
 
     // https://html.spec.whatwg.org/multipage/#dom-sessionstorage
     fn SessionStorage(&self) -> Root<Storage> {
-        self.session_storage.or_init(|| Storage::new(&GlobalRef::Window(self), StorageType::Session))
+        self.session_storage.or_init(|| Storage::new(self.upcast(), StorageType::Session))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-localstorage
     fn LocalStorage(&self) -> Root<Storage> {
-        self.local_storage.or_init(|| Storage::new(&GlobalRef::Window(self), StorageType::Local))
+        self.local_storage.or_init(|| Storage::new(self.upcast(), StorageType::Local))
     }
 
     // https://dvcs.w3.org/hg/webcrypto-api/raw-file/tip/spec/Overview.html#dfn-GlobalCrypto
     fn Crypto(&self) -> Root<Crypto> {
-        self.crypto.or_init(|| Crypto::new(GlobalRef::Window(self)))
+        self.crypto.or_init(|| Crypto::new(self.upcast()))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-frameelement
@@ -1708,7 +1708,7 @@ impl Window {
 
         // Steps 3-12.
         // FIXME(#13195): muted errors.
-        let event = ErrorEvent::new(GlobalRef::Window(self),
+        let event = ErrorEvent::new(self.upcast(),
                                     atom!("error"),
                                     EventBubbles::DoesNotBubble,
                                     EventCancelable::Cancelable,
diff --git a/components/script/dom/worker.rs b/components/script/dom/worker.rs
index fb6b170ab1d..9c43f1c148d 100644
--- a/components/script/dom/worker.rs
+++ b/components/script/dom/worker.rs
@@ -21,6 +21,7 @@ use dom::errorevent::ErrorEvent;
 use dom::event::{Event, EventBubbles, EventCancelable};
 use dom::eventdispatcher::EventStatus;
 use dom::eventtarget::EventTarget;
+use dom::globalscope::GlobalScope;
 use dom::messageevent::MessageEvent;
 use dom::workerglobalscope::prepare_workerscope_init;
 use ipc_channel::ipc;
@@ -61,7 +62,7 @@ impl Worker {
         }
     }
 
-    pub fn new(global: GlobalRef,
+    pub fn new(global: &GlobalScope,
                sender: Sender<(TrustedWorkerAddress, WorkerScriptMsg)>,
                closing: Arc<AtomicBool>) -> Root<Worker> {
         reflect_dom_object(box Worker::new_inherited(sender, closing),
@@ -80,7 +81,7 @@ impl Worker {
 
         let (sender, receiver) = channel();
         let closing = Arc::new(AtomicBool::new(false));
-        let worker = Worker::new(global, sender.clone(), closing.clone());
+        let worker = Worker::new(global.as_global_scope(), sender.clone(), closing.clone());
         let worker_ref = Trusted::new(worker.r());
 
         let worker_load_origin = WorkerScriptLoadOrigin {
@@ -144,7 +145,7 @@ impl Worker {
     #[allow(unsafe_code)]
     fn dispatch_error(&self, error_info: ErrorInfo) {
         let global = self.global();
-        let event = ErrorEvent::new(global.r(),
+        let event = ErrorEvent::new(global.r().as_global_scope(),
                                     atom!("error"),
                                     EventBubbles::DoesNotBubble,
                                     EventCancelable::Cancelable,
diff --git a/components/script/dom/workerglobalscope.rs b/components/script/dom/workerglobalscope.rs
index 95e8b425c25..83cef1d994f 100644
--- a/components/script/dom/workerglobalscope.rs
+++ b/components/script/dom/workerglobalscope.rs
@@ -343,7 +343,7 @@ impl WorkerGlobalScopeMethods for WorkerGlobalScope {
 
     // https://html.spec.whatwg.org/multipage/#dfn-Crypto
     fn Crypto(&self) -> Root<Crypto> {
-        self.crypto.or_init(|| Crypto::new(GlobalRef::Worker(self)))
+        self.crypto.or_init(|| Crypto::new(self.upcast()))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-windowbase64-btoa
@@ -505,7 +505,7 @@ impl WorkerGlobalScope {
 
         // Steps 3-12.
         // FIXME(#13195): muted errors.
-        let event = ErrorEvent::new(GlobalRef::Worker(self),
+        let event = ErrorEvent::new(self.upcast(),
                                     atom!("error"),
                                     EventBubbles::DoesNotBubble,
                                     EventCancelable::Cancelable,
diff --git a/components/script/dom/workerlocation.rs b/components/script/dom/workerlocation.rs
index a037f7737a8..287a803a612 100644
--- a/components/script/dom/workerlocation.rs
+++ b/components/script/dom/workerlocation.rs
@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::WorkerLocationBinding;
 use dom::bindings::codegen::Bindings::WorkerLocationBinding::WorkerLocationMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::{DOMString, USVString};
@@ -29,7 +28,7 @@ impl WorkerLocation {
 
     pub fn new(global: &WorkerGlobalScope, url: Url) -> Root<WorkerLocation> {
         reflect_dom_object(box WorkerLocation::new_inherited(url),
-                           GlobalRef::Worker(global),
+                           global,
                            WorkerLocationBinding::Wrap)
     }
 }
diff --git a/components/script/dom/workernavigator.rs b/components/script/dom/workernavigator.rs
index 1114a91a169..f6cd521634d 100644
--- a/components/script/dom/workernavigator.rs
+++ b/components/script/dom/workernavigator.rs
@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::WorkerNavigatorBinding;
 use dom::bindings::codegen::Bindings::WorkerNavigatorBinding::WorkerNavigatorMethods;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
@@ -26,7 +25,7 @@ impl WorkerNavigator {
 
     pub fn new(global: &WorkerGlobalScope) -> Root<WorkerNavigator> {
         reflect_dom_object(box WorkerNavigator::new_inherited(),
-                           GlobalRef::Worker(global),
+                           global,
                            WorkerNavigatorBinding::Wrap)
     }
 }
diff --git a/components/script/dom/xmldocument.rs b/components/script/dom/xmldocument.rs
index 1a00f67b80c..6fb57ea52fd 100644
--- a/components/script/dom/xmldocument.rs
+++ b/components/script/dom/xmldocument.rs
@@ -6,7 +6,6 @@ use core::nonzero::NonZero;
 use document_loader::DocumentLoader;
 use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
 use dom::bindings::codegen::Bindings::XMLDocumentBinding::{self, XMLDocumentMethods};
-use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
@@ -66,7 +65,7 @@ impl XMLDocument {
                                            last_modified,
                                            source,
                                            doc_loader),
-            GlobalRef::Window(window),
+            window,
             XMLDocumentBinding::Wrap);
         {
             let node = doc.upcast::<Node>();
diff --git a/components/script/dom/xmlhttprequest.rs b/components/script/dom/xmlhttprequest.rs
index caebbddd09e..4c9397db566 100644
--- a/components/script/dom/xmlhttprequest.rs
+++ b/components/script/dom/xmlhttprequest.rs
@@ -167,7 +167,7 @@ impl XMLHttpRequest {
             ready_state: Cell::new(XMLHttpRequestState::Unsent),
             timeout: Cell::new(0u32),
             with_credentials: Cell::new(false),
-            upload: JS::from_ref(&*XMLHttpRequestUpload::new(global)),
+            upload: JS::from_ref(&*XMLHttpRequestUpload::new(global.as_global_scope())),
             response_url: DOMRefCell::new(String::from("")),
             status: Cell::new(0),
             status_text: DOMRefCell::new(ByteString::new(vec!())),
@@ -198,7 +198,7 @@ impl XMLHttpRequest {
     }
     pub fn new(global: GlobalRef) -> Root<XMLHttpRequest> {
         reflect_dom_object(box XMLHttpRequest::new_inherited(global),
-                           global,
+                           global.as_global_scope(),
                            XMLHttpRequestBinding::Wrap)
     }
 
@@ -860,7 +860,7 @@ impl XMLHttpRequest {
         assert!(self.ready_state.get() != rs);
         self.ready_state.set(rs);
         let global = self.global();
-        let event = Event::new(global.r(),
+        let event = Event::new(global.r().as_global_scope(),
                                atom!("readystatechange"),
                                EventBubbles::DoesNotBubble,
                                EventCancelable::Cancelable);
@@ -977,7 +977,7 @@ impl XMLHttpRequest {
                     }
                     let global = self.global();
                     let event = Event::new(
-                        global.r(),
+                        global.r().as_global_scope(),
                         atom!("readystatechange"),
                         EventBubbles::DoesNotBubble,
                         EventCancelable::Cancelable);
@@ -1050,7 +1050,7 @@ impl XMLHttpRequest {
 
     fn dispatch_progress_event(&self, upload: bool, type_: Atom, loaded: u64, total: Option<u64>) {
         let global = self.global();
-        let progressevent = ProgressEvent::new(global.r(),
+        let progressevent = ProgressEvent::new(global.r().as_global_scope(),
                                                type_,
                                                EventBubbles::DoesNotBubble,
                                                EventCancelable::NotCancelable,
@@ -1118,7 +1118,7 @@ impl XMLHttpRequest {
 
         // Step 3, 4
         let bytes = self.response.borrow().to_vec();
-        let blob = Blob::new(self.global().r(), BlobImpl::new_from_bytes(bytes), mime);
+        let blob = Blob::new(self.global().r().as_global_scope(), BlobImpl::new_from_bytes(bytes), mime);
         self.response_blob.set(Some(blob.r()));
         blob
     }
diff --git a/components/script/dom/xmlhttprequestupload.rs b/components/script/dom/xmlhttprequestupload.rs
index 900548f2e05..6c53fe15eca 100644
--- a/components/script/dom/xmlhttprequestupload.rs
+++ b/components/script/dom/xmlhttprequestupload.rs
@@ -3,9 +3,9 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::Bindings::XMLHttpRequestUploadBinding;
-use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
+use dom::globalscope::GlobalScope;
 use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTarget;
 
 #[dom_struct]
@@ -19,7 +19,7 @@ impl XMLHttpRequestUpload {
             eventtarget: XMLHttpRequestEventTarget::new_inherited(),
         }
     }
-    pub fn new(global: GlobalRef) -> Root<XMLHttpRequestUpload> {
+    pub fn new(global: &GlobalScope) -> Root<XMLHttpRequestUpload> {
         reflect_dom_object(box XMLHttpRequestUpload::new_inherited(),
                            global,
                            XMLHttpRequestUploadBinding::Wrap)
diff --git a/components/script/fetch.rs b/components/script/fetch.rs
index 634439c7c7d..75d6e3b0848 100644
--- a/components/script/fetch.rs
+++ b/components/script/fetch.rs
@@ -71,7 +71,7 @@ pub fn Fetch(global: GlobalRef, input: RequestOrUSVString, init: &RequestInit) -
 
     // Step 1
     let promise = Promise::new(global);
-    let response = Response::new(global);
+    let response = Response::new(global.as_global_scope());
 
     // Step 2
     let request = match Request::Constructor(global, input, init) {