Make reflect_dom_object take a &GlobalScope

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 {

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)
     }
 

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> {

components/script/dom/bindings/codegen/CodegenRust.py

@@ -1927,8 +1927,10 @@ def removeWrapperAndNullableTypes(types):
             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',

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());

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 {

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.

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.

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

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))

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>)

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,

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)
+        })
     }
 }