Add global default method for Reflectable trait

components/script/dom/bindings/reflector.rs

@@ -4,7 +4,7 @@
 
 //! The `Reflector` struct.
 
-use dom::bindings::global::GlobalRef;
+use dom::bindings::global::{GlobalRef, GlobalRoot, global_root_from_reflector};
 use dom::bindings::js::Root;
 use js::jsapi::{HandleObject, JSContext, JSObject};
 use std::cell::UnsafeCell;
@@ -75,4 +75,9 @@ pub trait Reflectable {
     fn reflector(&self) -> &Reflector;
     /// Initializes the Reflector
     fn init_reflector(&mut self, obj: *mut JSObject);
+
+    /// Returns the global object of the realm that the Reflectable was created in.
+    fn global(&self) -> GlobalRoot where Self: Sized {
+        global_root_from_reflector(self)
+    }
 }

components/script/dom/blob.rs

@@ -5,9 +5,9 @@
 use dom::bindings::codegen::Bindings::BlobBinding;
 use dom::bindings::codegen::Bindings::BlobBinding::BlobMethods;
 use dom::bindings::error::Fallible;
-use dom::bindings::global::{GlobalRef, global_root_from_reflector};
+use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
-use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::trace::JSTraceable;
 use num::ToPrimitive;
 use std::ascii::AsciiExt;
@@ -168,7 +168,7 @@ impl BlobMethods for Blob {
                 }
             }
         };
-        let global = global_root_from_reflector(self);
+        let global = self.global();
         let bytes = self.data.bytes.clone();
         Blob::new_sliced(global.r(), bytes, start, end, &relativeContentType)
     }

components/script/dom/canvasrenderingcontext2d.rs

@@ -18,11 +18,11 @@ use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::codegen::UnionTypes::HTMLImageElementOrHTMLCanvasElementOrCanvasRenderingContext2D;
 use dom::bindings::codegen::UnionTypes::StringOrCanvasGradientOrCanvasPattern;
 use dom::bindings::error::{Error, Fallible};
-use dom::bindings::global::{GlobalRef, global_root_from_reflector};
+use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{JS, LayoutJS, Root};
 use dom::bindings::num::Finite;
-use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::canvasgradient::{CanvasGradient, CanvasGradientStyle, ToFillOrStrokeStyle};
 use dom::canvaspattern::CanvasPattern;
 use dom::htmlcanvaselement::HTMLCanvasElement;
@@ -1014,12 +1014,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(global_root_from_reflector(self).r(), sw, sh, None))
+        Ok(ImageData::new(self.global().r(), sw, sh, None))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-createimagedata
     fn CreateImageData_(&self, imagedata: &ImageData) -> Fallible<Root<ImageData>> {
-        Ok(ImageData::new(global_root_from_reflector(self).r(),
+        Ok(ImageData::new(self.global().r(),
                           imagedata.Width(),
                           imagedata.Height(),
                           None))
@@ -1076,7 +1076,7 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
             chunk[2] = UNPREMULTIPLY_TABLE[256 * alpha + chunk[2] as usize];
         }
 
-        Ok(ImageData::new(global_root_from_reflector(self).r(), sw, sh, Some(data)))
+        Ok(ImageData::new(self.global().r(), sw, sh, Some(data)))
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-putimagedata
@@ -1099,7 +1099,7 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
                      dirtyY: Finite<f64>,
                      dirtyWidth: Finite<f64>,
                      dirtyHeight: Finite<f64>) {
-        let data = imagedata.get_data_array(&global_root_from_reflector(self).r());
+        let data = imagedata.get_data_array(&self.global().r());
         let offset = Point2D::new(*dx, *dy);
         let image_data_size = Size2D::new(imagedata.Width() as f64, imagedata.Height() as f64);
 
@@ -1120,7 +1120,7 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
                             x1: Finite<f64>,
                             y1: Finite<f64>)
                             -> Root<CanvasGradient> {
-        CanvasGradient::new(global_root_from_reflector(self).r(),
+        CanvasGradient::new(self.global().r(),
                             CanvasGradientStyle::Linear(LinearGradientStyle::new(*x0,
                                                                                  *y0,
                                                                                  *x1,
@@ -1141,7 +1141,7 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
             return Err(Error::IndexSize);
         }
 
-        Ok(CanvasGradient::new(global_root_from_reflector(self).r(),
+        Ok(CanvasGradient::new(self.global().r(),
                                CanvasGradientStyle::Radial(RadialGradientStyle::new(*x0,
                                                                                     *y0,
                                                                                     *r0,
@@ -1181,7 +1181,7 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
         }
 
         if let Ok(rep) = RepetitionStyle::from_str(&repetition) {
-            Ok(CanvasPattern::new(global_root_from_reflector(self).r(),
+            Ok(CanvasPattern::new(self.global().r(),
                                   image_data,
                                   image_size,
                                   rep,

components/script/dom/console.rs

@@ -5,9 +5,9 @@
 use devtools_traits::{ConsoleMessage, LogLevel, ScriptToDevtoolsControlMsg};
 use dom::bindings::codegen::Bindings::ConsoleBinding;
 use dom::bindings::codegen::Bindings::ConsoleBinding::ConsoleMethods;
-use dom::bindings::global::{GlobalRef, global_root_from_reflector};
+use dom::bindings::global::GlobalRef;
 use dom::bindings::js::Root;
-use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use util::str::DOMString;
 
 // https://developer.mozilla.org/en-US/docs/Web/API/Console
@@ -30,7 +30,7 @@ impl Console {
     }
 
     fn send_to_devtools(&self, level: LogLevel, message: DOMString) {
-        let global = global_root_from_reflector(self);
+        let global = self.global();
         let global = global.r();
         if let Some(chan) = global.devtools_chan() {
             let console_message = prepare_message(level, message);

components/script/dom/domquad.rs

@@ -8,9 +8,9 @@ use dom::bindings::codegen::Bindings::DOMQuadBinding::{DOMQuadInit, DOMQuadMetho
 use dom::bindings::codegen::Bindings::DOMRectBinding::DOMRectMethods;
 use dom::bindings::codegen::Bindings::DOMRectReadOnlyBinding::{DOMRectInit, DOMRectReadOnlyMethods};
 use dom::bindings::error::Fallible;
-use dom::bindings::global::{GlobalRef, global_root_from_reflector};
+use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{Root, JS};
-use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::dompoint::DOMPoint;
 use dom::domrect::DOMRect;
 
@@ -110,7 +110,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(global_root_from_reflector(self).r(),
+        DOMRect::new(self.global().r(),
                      left,
                      top,
                      right - left,

components/script/dom/eventdispatcher.rs

@@ -5,9 +5,10 @@
 use devtools_traits::{StartedTimelineMarker, TimelineMarker, TimelineMarkerType};
 use dom::bindings::callback::ExceptionHandling::Report;
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
-use dom::bindings::global::{GlobalRoot, global_root_from_reflector};
+use dom::bindings::global::GlobalRoot;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{JS, Root, RootedReference};
+use dom::bindings::reflector::Reflectable;
 use dom::bindings::trace::RootedVec;
 use dom::event::{Event, EventPhase};
 use dom::eventtarget::{EventListenerType, EventTarget, ListenerPhase};
@@ -49,7 +50,7 @@ fn dispatch_to_listeners(event: &Event, target: &EventTarget, chain: &[&EventTar
     assert!(!event.stop_propagation());
     assert!(!event.stop_immediate());
 
-    let window = match global_root_from_reflector(target) {
+    let window = match target.global() {
         GlobalRoot::Window(window) => {
             if window.need_emit_timeline_marker(TimelineMarkerType::DOMEvent) {
                 Some(window)

components/script/dom/eventtarget.rs

@@ -11,7 +11,7 @@ use dom::bindings::codegen::Bindings::EventListenerBinding::EventListener;
 use dom::bindings::codegen::Bindings::EventTargetBinding::EventTargetMethods;
 use dom::bindings::codegen::UnionTypes::EventOrString;
 use dom::bindings::error::{Error, Fallible, report_pending_exception};
-use dom::bindings::global::{GlobalRef, global_root_from_reflector};
+use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::{Castable, EventTargetTypeId};
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflectable, Reflector};
@@ -123,7 +123,7 @@ impl EventListenerType {
                 match *handler {
                     CommonEventHandler::ErrorEventHandler(ref handler) => {
                         if let Some(event) = event.downcast::<ErrorEvent>() {
-                            let global = global_root_from_reflector(object);
+                            let global = object.global();
                             let cx = global.r().get_cx();
                             let error = RootedValue::new(cx, event.Error(cx));
                             let _ = handler.Call_(object,

components/script/dom/filereader.rs

@@ -7,7 +7,7 @@ use dom::bindings::codegen::Bindings::BlobBinding::BlobMethods;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::Bindings::FileReaderBinding::{self, FileReaderConstants, FileReaderMethods};
 use dom::bindings::error::{Error, ErrorResult, Fallible};
-use dom::bindings::global::{GlobalRef, global_root_from_reflector};
+use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::bindings::refcounted::Trusted;
@@ -112,7 +112,7 @@ impl FileReader {
         fr.change_ready_state(FileReaderReadyState::Done);
         *fr.result.borrow_mut() = None;
 
-        let global = global_root_from_reflector(fr.r());
+        let global = fr.r().global();
         let exception = DOMException::new(global.r(), error);
         fr.error.set(Some(&exception));
 
@@ -289,7 +289,7 @@ impl FileReaderMethods for FileReader {
         // Steps 1 & 3
         *self.result.borrow_mut() = None;
 
-        let global = global_root_from_reflector(self);
+        let global = self.global();
         let exception = DOMException::new(global.r(), DOMErrorName::AbortError);
         self.error.set(Some(&exception));
 
@@ -319,7 +319,7 @@ impl FileReaderMethods for FileReader {
 impl FileReader {
     fn dispatch_progress_event(&self, type_: Atom, loaded: u64, total: Option<u64>) {
 
-        let global = global_root_from_reflector(self);
+        let global = self.global();
         let progressevent = ProgressEvent::new(global.r(),
             type_, EventBubbles::DoesNotBubble, EventCancelable::NotCancelable,
             total.is_some(), loaded, total.unwrap_or(0));
@@ -332,7 +332,7 @@ impl FileReader {
     }
 
     fn read(&self, function: FileReaderFunction, blob: &Blob, label: Option<DOMString>) -> ErrorResult {
-        let root = global_root_from_reflector(self);
+        let root = self.global();
         let global = root.r();
         // Step 1
         if self.ready_state.get() == FileReaderReadyState::Loading {
@@ -340,7 +340,7 @@ impl FileReader {
         }
         // Step 2
         if blob.IsClosed() {
-            let global = global_root_from_reflector(self);
+            let global = self.global();
             let exception = DOMException::new(global.r(), DOMErrorName::InvalidStateError);
             self.error.set(Some(&exception));
 

components/script/dom/formdata.rs

@@ -7,10 +7,10 @@ use dom::bindings::codegen::Bindings::FormDataBinding;
 use dom::bindings::codegen::Bindings::FormDataBinding::FormDataMethods;
 use dom::bindings::codegen::UnionTypes::BlobOrUSVString::{self, eBlob, eUSVString};
 use dom::bindings::error::{Fallible};
-use dom::bindings::global::{GlobalRef, global_root_from_reflector};
+use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{JS, Root};
-use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::str::USVString;
 use dom::blob::Blob;
 use dom::file::File;
@@ -126,7 +126,7 @@ impl FormData {
     fn get_file_or_blob(&self, value: &Blob, filename: Option<USVString>) -> Root<Blob> {
         match filename {
             Some(fname) => {
-                let global = global_root_from_reflector(self);
+                let global = self.global();
                 let name = DOMString::from(fname.0);
                 Root::upcast(File::new(global.r(), value, name))
             }

components/script/dom/storage.rs

@@ -5,11 +5,11 @@
 use dom::bindings::codegen::Bindings::StorageBinding;
 use dom::bindings::codegen::Bindings::StorageBinding::StorageMethods;
 use dom::bindings::error::{Error, ErrorResult};
-use dom::bindings::global::{GlobalRef, global_root_from_reflector};
+use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{Root, RootedReference};
 use dom::bindings::refcounted::Trusted;
-use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::event::{Event, EventBubbles, EventCancelable};
 use dom::storageevent::StorageEvent;
 use dom::urlhelper::UrlHelper;
@@ -40,13 +40,13 @@ impl Storage {
     }
 
     fn get_url(&self) -> Url {
-        let global_root = global_root_from_reflector(self);
+        let global_root = self.global();
         let global_ref = global_root.r();
         global_ref.get_url()
     }
 
     fn get_storage_thread(&self) -> StorageThread {
-        let global_root = global_root_from_reflector(self);
+        let global_root = self.global();
         let global_ref = global_root.r();
         global_ref.as_window().storage_thread()
     }
@@ -152,7 +152,7 @@ impl Storage {
     /// https://html.spec.whatwg.org/multipage/#send-a-storage-notification
     fn broadcast_change_notification(&self, key: Option<String>, old_value: Option<String>,
                                      new_value: Option<String>) {
-        let global_root = global_root_from_reflector(self);
+        let global_root = self.global();
         let global_ref = global_root.r();
         let main_script_chan = global_ref.as_window().main_thread_script_chan();
         let script_chan = global_ref.dom_manipulation_thread_source();
@@ -181,7 +181,7 @@ impl MainThreadRunnable for StorageEventRunnable {
         let this = *self;
         let storage_root = this.element.root();
         let storage = storage_root.r();
-        let global_root = global_root_from_reflector(storage);
+        let global_root = storage.global();
         let global_ref = global_root.r();
         let ev_window = global_ref.as_window();
         let ev_url = storage.get_url();

components/script/dom/testbinding.rs

@@ -10,10 +10,10 @@ use dom::bindings::codegen::Bindings::TestBindingBinding::{self, TestBindingMeth
 use dom::bindings::codegen::UnionTypes::{BlobOrString, EventOrString};
 use dom::bindings::codegen::UnionTypes::{EventOrUSVString, HTMLElementOrLong};
 use dom::bindings::error::Fallible;
-use dom::bindings::global::{GlobalRef, global_root_from_reflector};
+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::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::str::{ByteString, USVString};
 use dom::bindings::weakref::MutableWeakRef;
 use dom::blob::Blob;
@@ -85,7 +85,7 @@ impl TestBindingMethods for TestBinding {
     fn EnumAttribute(&self) -> TestEnum { TestEnum::_empty }
     fn SetEnumAttribute(&self, _: TestEnum) {}
     fn InterfaceAttribute(&self) -> Root<Blob> {
-        Blob::new(global_root_from_reflector(self).r(), Vec::new(), "")
+        Blob::new(self.global().r(), Vec::new(), "")
     }
     fn SetInterfaceAttribute(&self, _: &Blob) {}
     fn UnionAttribute(&self) -> HTMLElementOrLong { HTMLElementOrLong::eLong(0) }
@@ -143,7 +143,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(global_root_from_reflector(self).r(), Vec::new(), ""))
+        Some(Blob::new(self.global().r(), Vec::new(), ""))
     }
     fn SetInterfaceAttributeNullable(&self, _: Option<&Blob>) {}
     fn GetInterfaceAttributeWeak(&self) -> Option<Root<URL>> {
@@ -182,7 +182,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(global_root_from_reflector(self).r(), Vec::new(), "")
+        Blob::new(self.global().r(), Vec::new(), "")
     }
     fn ReceiveAny(&self, _: *mut JSContext) -> JSVal { NullValue() }
     fn ReceiveObject(&self, _: *mut JSContext) -> *mut JSObject { panic!() }
@@ -207,7 +207,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(global_root_from_reflector(self).r(), Vec::new(), ""))
+        Some(Blob::new(self.global().r(), Vec::new(), ""))
     }
     fn ReceiveNullableObject(&self, _: *mut JSContext) -> *mut JSObject { ptr::null_mut() }
     fn ReceiveNullableUnion(&self) -> Option<HTMLElementOrLong> {

components/script/dom/webglrenderingcontext.rs

@@ -10,10 +10,10 @@ use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::{WebGLRender
 use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::{self, WebGLContextAttributes};
 use dom::bindings::codegen::UnionTypes::ImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement;
 use dom::bindings::conversions::{ToJSValConvertible, array_buffer_view_to_vec_checked, array_buffer_view_to_vec};
-use dom::bindings::global::{GlobalRef, global_root_from_reflector};
+use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{JS, LayoutJS, MutNullableHeap, Root};
-use dom::bindings::reflector::{Reflector, reflect_dom_object};
+use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::event::{Event, EventBubbles, EventCancelable};
 use dom::htmlcanvaselement::HTMLCanvasElement;
 use dom::htmlcanvaselement::utils as canvas_utils;
@@ -615,34 +615,34 @@ 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(global_root_from_reflector(self).r(), self.ipc_renderer.clone())
+        WebGLBuffer::maybe_new(self.global().r(), 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(global_root_from_reflector(self).r(), self.ipc_renderer.clone())
+        WebGLFramebuffer::maybe_new(self.global().r(), 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(global_root_from_reflector(self).r(), self.ipc_renderer.clone())
+        WebGLRenderbuffer::maybe_new(self.global().r(), 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(global_root_from_reflector(self).r(), self.ipc_renderer.clone())
+        WebGLTexture::maybe_new(self.global().r(), 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(global_root_from_reflector(self).r(), self.ipc_renderer.clone())
+        WebGLProgram::maybe_new(self.global().r(), self.ipc_renderer.clone())
     }
 
     // TODO(ecoal95): Check if constants are cross-platform or if we must make a translation
     // between WebGL constants and native ones.
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn CreateShader(&self, shader_type: u32) -> Option<Root<WebGLShader>> {
-        WebGLShader::maybe_new(global_root_from_reflector(self).r(), self.ipc_renderer.clone(), shader_type)
+        WebGLShader::maybe_new(self.global().r(), self.ipc_renderer.clone(), shader_type)
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5
@@ -804,7 +804,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                           name: DOMString) -> Option<Root<WebGLUniformLocation>> {
         if let Some(program) = program {
             handle_potential_webgl_error!(self, program.get_uniform_location(name), None)
-                .map(|location| WebGLUniformLocation::new(global_root_from_reflector(self).r(), location))
+                .map(|location| WebGLUniformLocation::new(self.global().r(), location))
         } else {
             None
         }
@@ -1081,7 +1081,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
 
         let (pixels, size) = match source {
             ImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::eImageData(image_data) => {
-                let global = global_root_from_reflector(self);
+                let global = self.global();
                 (image_data.get_data_array(&global.r()), image_data.get_size())
             },
             ImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement::eHTMLImageElement(image) => {

components/script/dom/websocket.rs

@@ -9,7 +9,7 @@ use dom::bindings::codegen::Bindings::WebSocketBinding;
 use dom::bindings::codegen::Bindings::WebSocketBinding::{BinaryType, WebSocketMethods};
 use dom::bindings::conversions::{ToJSValConvertible};
 use dom::bindings::error::{Error, Fallible};
-use dom::bindings::global::{GlobalRef, global_root_from_reflector};
+use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::refcounted::Trusted;
@@ -292,7 +292,7 @@ impl WebSocket {
             WebSocketRequestState::Closing | WebSocketRequestState::Closed => true,
         };
 
-        let global = global_root_from_reflector(self);
+        let global = self.global();
         let chan = global.r().networking_thread_source();
         let address = Trusted::new(self, chan.clone());
 
@@ -460,7 +460,7 @@ struct ConnectionEstablishedTask {
 impl Runnable for ConnectionEstablishedTask {
     fn handler(self: Box<Self>) {
         let ws = self.addr.root();
-        let global = global_root_from_reflector(ws.r());
+        let global = ws.r().global();
 
         // Step 1: Protocols.
         if !self.protocols.is_empty() && self.headers.get::<WebSocketProtocol>().is_none() {
@@ -519,7 +519,7 @@ impl Runnable for CloseTask {
     fn handler(self: Box<Self>) {
         let ws = self.addr.root();
         let ws = ws.r();
-        let global = global_root_from_reflector(ws);
+        let global = ws.global();
         ws.ready_state.set(WebSocketRequestState::Closed);
         //If failed or full, fire error event
         if ws.failed.get() || ws.full.get() {
@@ -565,7 +565,7 @@ impl Runnable for MessageReceivedTask {
         }
 
         // Step 2-5.
-        let global = global_root_from_reflector(ws.r());
+        let global = ws.r().global();
         // global.get_cx() returns a valid `JSContext` pointer, so this is safe.
         unsafe {
             let cx = global.r().get_cx();

components/script/dom/window.rs

@@ -12,7 +12,7 @@ use dom::bindings::codegen::Bindings::FunctionBinding::Function;
 use dom::bindings::codegen::Bindings::WindowBinding::{ScrollBehavior, ScrollToOptions};
 use dom::bindings::codegen::Bindings::WindowBinding::{self, FrameRequestCallback, WindowMethods};
 use dom::bindings::error::{Error, Fallible, report_pending_exception};
-use dom::bindings::global::{GlobalRef, global_root_from_reflector};
+use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::RootedReference;
 use dom::bindings::js::{JS, MutNullableHeap, Root};
@@ -803,7 +803,7 @@ impl<'a, T: Reflectable> ScriptHelpers for &'a T {
     #[allow(unsafe_code)]
     fn evaluate_script_on_global_with_result(self, code: &str, filename: &str,
                                              rval: MutableHandleValue) {
-        let global = global_root_from_reflector(self);
+        let global = self.global();
         let cx = global.r().get_cx();
         let _ar = JSAutoRequest::new(cx);
         let globalhandle = global.r().reflector().get_jsobject();

components/script/dom/worker.rs

@@ -7,7 +7,7 @@ use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::Bindings::WorkerBinding;
 use dom::bindings::codegen::Bindings::WorkerBinding::WorkerMethods;
 use dom::bindings::error::{Error, ErrorResult, Fallible};
-use dom::bindings::global::{GlobalRef, global_root_from_reflector};
+use dom::bindings::global::GlobalRef;
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::refcounted::Trusted;
@@ -111,7 +111,7 @@ impl Worker {
                           data: StructuredCloneData) {
         let worker = address.root();
 
-        let global = global_root_from_reflector(worker.r());
+        let global = worker.r().global();
         let target = worker.upcast();
         let _ar = JSAutoRequest::new(global.r().get_cx());
         let _ac = JSAutoCompartment::new(global.r().get_cx(), target.reflector().get_jsobject().get());
@@ -122,14 +122,14 @@ impl Worker {
 
     pub fn dispatch_simple_error(address: TrustedWorkerAddress) {
         let worker = address.root();
-        let global = global_root_from_reflector(worker.r());
+        let global = worker.r().global();
         worker.upcast().fire_simple_event("error", global.r());
     }
 
     pub fn handle_error_message(address: TrustedWorkerAddress, message: DOMString,
                                 filename: DOMString, lineno: u32, colno: u32) {
         let worker = address.root();
-        let global = global_root_from_reflector(worker.r());
+        let global = worker.r().global();
         let error = RootedValue::new(global.r().get_cx(), UndefinedValue());
         let errorevent = ErrorEvent::new(global.r(), atom!("error"),
                                          EventBubbles::Bubbles, EventCancelable::Cancelable,
@@ -142,7 +142,7 @@ impl WorkerMethods for Worker {
     // https://html.spec.whatwg.org/multipage/#dom-dedicatedworkerglobalscope-postmessage
     fn PostMessage(&self, cx: *mut JSContext, message: HandleValue) -> ErrorResult {
         let data = try!(StructuredCloneData::write(cx, message));
-        let address = Trusted::new(self, global_root_from_reflector(self).r().dom_manipulation_thread_source());
+        let address = Trusted::new(self, self.global().r().dom_manipulation_thread_source());
         self.sender.send((address, WorkerScriptMsg::DOMMessage(data))).unwrap();
         Ok(())
     }

components/script/dom/xmlhttprequest.rs

@@ -16,7 +16,7 @@ use dom::bindings::codegen::UnionTypes::StringOrURLSearchParams;
 use dom::bindings::codegen::UnionTypes::StringOrURLSearchParams::{eString, eURLSearchParams};
 use dom::bindings::conversions::{ToJSValConvertible};
 use dom::bindings::error::{Error, ErrorResult, Fallible};
-use dom::bindings::global::{GlobalRef, GlobalRoot, global_root_from_reflector};
+use dom::bindings::global::{GlobalRef, GlobalRoot};
 use dom::bindings::inheritance::Castable;
 use dom::bindings::js::{JS, MutNullableHeap};
 use dom::bindings::js::{Root, RootedReference};
@@ -323,7 +323,7 @@ impl XMLHttpRequestMethods for XMLHttpRequest {
                 *self.request_method.borrow_mut() = parsed_method;
 
                 // Step 6
-                let base = global_root_from_reflector(self).r().get_url();
+                let base = self.global().r().get_url();
                 let parsed_url = match base.join(&url) {
                     Ok(parsed) => parsed,
                     Err(_) => return Err(Error::Syntax) // Step 7
@@ -455,7 +455,7 @@ impl XMLHttpRequestMethods for XMLHttpRequest {
             XMLHttpRequestState::Loading |
             XMLHttpRequestState::Done => Err(Error::InvalidState),
             _ if self.send_flag.get() => Err(Error::InvalidState),
-            _ => match global_root_from_reflector(self) {
+            _ => match self.global() {
                 GlobalRoot::Window(_) if self.sync.get() => Err(Error::InvalidAccess),
                 _ => {
                     self.with_credentials.set(with_credentials);
@@ -517,7 +517,7 @@ impl XMLHttpRequestMethods for XMLHttpRequest {
 
         }
 
-        let global = global_root_from_reflector(self);
+        let global = self.global();
         let pipeline_id = global.r().pipeline();
         let mut load_data =
             LoadData::new(LoadContext::Browsing,
@@ -560,8 +560,8 @@ impl XMLHttpRequestMethods for XMLHttpRequest {
         load_data.method = (*self.request_method.borrow()).clone();
 
         // CORS stuff
-        let global = global_root_from_reflector(self);
+        let global = self.global();
-        let referer_url = global_root_from_reflector(self).r().get_url();
+        let referer_url = self.global().r().get_url();
         let mode = if self.upload_events.get() {
             RequestMode::ForcedPreflight
         } else {
@@ -684,7 +684,7 @@ impl XMLHttpRequestMethods for XMLHttpRequest {
 
     // https://xhr.spec.whatwg.org/#the-responsetype-attribute
     fn SetResponseType(&self, response_type: XMLHttpRequestResponseType) -> ErrorResult {
-        match global_root_from_reflector(self) {
+        match self.global() {
             GlobalRoot::Worker(_) if response_type == XMLHttpRequestResponseType::Document
             => return Ok(()),
             _ => {}
@@ -787,7 +787,7 @@ impl XMLHttpRequest {
     fn change_ready_state(&self, rs: XMLHttpRequestState) {
         assert!(self.ready_state.get() != rs);
         self.ready_state.set(rs);
-        let global = global_root_from_reflector(self);
+        let global = self.global();
         let event = Event::new(global.r(),
                                atom!("readystatechange"),
                                EventBubbles::DoesNotBubble,
@@ -968,7 +968,7 @@ impl XMLHttpRequest {
     }
 
     fn dispatch_progress_event(&self, upload: bool, type_: Atom, loaded: u64, total: Option<u64>) {
-        let global = global_root_from_reflector(self);
+        let global = self.global();
         let progressevent = ProgressEvent::new(global.r(),
                                                type_,
                                                EventBubbles::DoesNotBubble,
@@ -1022,7 +1022,7 @@ impl XMLHttpRequest {
 
         // Sets up the object to timeout in a given number of milliseconds
         // This will cancel all previous timeouts
-        let global = global_root_from_reflector(self);
+        let global = self.global();
         let callback = ScheduledXHRTimeout {
             xhr: Trusted::new(self, global.r().networking_thread_source()),
             generation_id: self.generation_id.get(),
@@ -1033,7 +1033,7 @@ impl XMLHttpRequest {
 
     fn cancel_timeout(&self) {
         if let Some(handle) = self.timeout_cancel.borrow_mut().take() {
-            let global = global_root_from_reflector(self);
+            let global = self.global();
             global.r().unschedule_callback(handle);
         }
     }
@@ -1082,7 +1082,7 @@ impl XMLHttpRequest {
 
     fn document_text_html(&self) -> Root<Document>{
         let charset = self.final_charset().unwrap_or(UTF_8);
-        let wr = global_root_from_reflector(self);
+        let wr = self.global();
         let wr = wr.r();
         let decoded = charset.decode(&self.response.borrow(), DecoderTrap::Replace).unwrap().to_owned();
         let document = self.new_doc(IsHTMLDocument::HTMLDocument);
@@ -1093,7 +1093,7 @@ impl XMLHttpRequest {
 
     fn handle_xml(&self) -> Root<Document> {
         let charset = self.final_charset().unwrap_or(UTF_8);
-        let wr = global_root_from_reflector(self);
+        let wr = self.global();
         let wr = wr.r();
         let decoded = charset.decode(&self.response.borrow(), DecoderTrap::Replace).unwrap().to_owned();
         let document = self.new_doc(IsHTMLDocument::NonHTMLDocument);
@@ -1103,13 +1103,13 @@ impl XMLHttpRequest {
     }
 
     fn new_doc(&self, is_html_document: IsHTMLDocument) -> Root<Document> {
-        let wr = global_root_from_reflector(self);
+        let wr = self.global();
         let wr = wr.r();
         let win = wr.as_window();
         let doc = win.Document();
         let doc = doc.r();
         let docloader = DocumentLoader::new(&*doc.loader());
-        let base = global_root_from_reflector(self).r().get_url();
+        let base = self.global().r().get_url();
         let parsed_url = match base.join(&self.ResponseURL()) {
             Ok(parsed) => Some(parsed),
             Err(_) => None // Step 7

components/script/timers.rs

@@ -5,7 +5,6 @@
 use dom::bindings::callback::ExceptionHandling::Report;
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::FunctionBinding::Function;
-use dom::bindings::global::global_root_from_reflector;
 use dom::bindings::reflector::Reflectable;
 use dom::bindings::trace::JSTraceable;
 use dom::window::ScriptHelpers;
@@ -289,7 +288,7 @@ impl ActiveTimers {
             // step 14
             match callback {
                 InternalTimerCallback::StringTimerCallback(code_str) => {
-                    let cx = global_root_from_reflector(this).r().get_cx();
+                    let cx = this.global().r().get_cx();
                     let mut rval = RootedValue::new(cx, UndefinedValue());
 
                     this.evaluate_js_on_global_with_result(&code_str, rval.handle_mut());