Merge pull request #2839 from Ms2ger/globals

Introduce abstractions for global scopes; r=Manishearth,larsberg

5 files changed, 105 insertions, 20 deletions

diff --git a/src/components/script/dom/bindings/callback.rs b/src/components/script/dom/bindings/callback.rs
index 8b0c1879dd3..865bd9d3ef7 100644
--- a/src/components/script/dom/bindings/callback.rs
+++ b/src/components/script/dom/bindings/callback.rs
@@ -114,8 +114,8 @@ pub struct CallSetup {
 
 impl CallSetup {
     pub fn new<T: CallbackContainer>(callback: &T, handling: ExceptionHandling) -> CallSetup {
-        let win = global_object_for_js_object(callback.callback()).root();
-        let cx = win.deref().get_cx();
+        let global = global_object_for_js_object(callback.callback()).root();
+        let cx = global.root_ref().get_cx();
         CallSetup {
             cx: cx,
             _handling: handling
diff --git a/src/components/script/dom/bindings/codegen/CodegenRust.py b/src/components/script/dom/bindings/codegen/CodegenRust.py
index 43c5ac3f169..525c77b6419 100644
--- a/src/components/script/dom/bindings/codegen/CodegenRust.py
+++ b/src/components/script/dom/bindings/codegen/CodegenRust.py
@@ -1792,7 +1792,7 @@ class CGWrapMethod(CGAbstractMethod):
     def __init__(self, descriptor):
         assert descriptor.interface.hasInterfacePrototypeObject()
         if not descriptor.createGlobal:
-            args = [Argument('*mut JSContext', 'aCx'), Argument('&JSRef<Window>', 'aScope'),
+            args = [Argument('*mut JSContext', 'aCx'), Argument('&GlobalRef', 'aScope'),
                     Argument("Box<%s>" % descriptor.concreteType, 'aObject', mutable=True)]
         else:
             args = [Argument('*mut JSContext', 'aCx'),
@@ -2185,7 +2185,7 @@ class CGCallGenerator(CGThing):
                 "    Ok(result) => result,\n"
                 "    Err(e) => {\n"
                 "%s"
-                "        throw_dom_exception(cx, &*global, e);\n"
+                "        throw_dom_exception(cx, &global.root_ref(), e);\n"
                 "        return%s;\n"
                 "    },\n"
                 "};\n" % (glob, errorResult)))
@@ -4405,6 +4405,7 @@ class CGBindingRoot(CGThing):
             'js::rust::with_compartment',
             'dom::types::*',
             'dom::bindings',
+            'dom::bindings::global::GlobalRef',
             'dom::bindings::js::{JS, JSRef, Root, RootedReference, Temporary}',
             'dom::bindings::js::{OptionalRootable, OptionalRootedRootable, ResultRootable}',
             'dom::bindings::js::{OptionalRootedReference, OptionalOptionalRootedRootable}',
diff --git a/src/components/script/dom/bindings/error.rs b/src/components/script/dom/bindings/error.rs
index 7b021bbae2d..f204dc5859a 100644
--- a/src/components/script/dom/bindings/error.rs
+++ b/src/components/script/dom/bindings/error.rs
@@ -3,9 +3,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::conversions::ToJSValConvertible;
-use dom::bindings::js::JSRef;
+use dom::bindings::global::GlobalRef;
 use dom::domexception::DOMException;
-use dom::window::Window;
 
 use js::jsapi::{JSContext, JSBool};
 use js::jsapi::{JS_IsExceptionPending, JS_SetPendingException};
@@ -37,7 +36,7 @@ pub type Fallible<T> = Result<T, Error>;
 
 pub type ErrorResult = Fallible<()>;
 
-pub fn throw_dom_exception(cx: *mut JSContext, global: &JSRef<Window>,
+pub fn throw_dom_exception(cx: *mut JSContext, global: &GlobalRef,
                            result: Error) {
     assert!(unsafe { JS_IsExceptionPending(cx) } == 0);
     let exception = DOMException::new_from_error(global, result).root();
diff --git a/src/components/script/dom/bindings/global.rs b/src/components/script/dom/bindings/global.rs
new file mode 100644
index 00000000000..2e34e78e7c3
--- /dev/null
+++ b/src/components/script/dom/bindings/global.rs
@@ -0,0 +1,84 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+//! Abstractions for global scopes.
+
+use dom::bindings::js::{JS, JSRef, Root};
+use dom::bindings::utils::{Reflectable, Reflector};
+use dom::window::Window;
+use page::Page;
+use script_task::ScriptChan;
+
+use js::jsapi::JSContext;
+
+use url::Url;
+
+pub enum GlobalRef<'a> {
+    Window(JSRef<'a, Window>),
+}
+
+pub enum GlobalRoot<'a, 'b> {
+    WindowRoot(Root<'a, 'b, Window>),
+}
+
+#[deriving(Encodable)]
+pub enum GlobalField {
+    WindowField(JS<Window>),
+}
+
+impl<'a> GlobalRef<'a> {
+    pub fn get_cx(&self) -> *mut JSContext {
+        match *self {
+            Window(ref window) => window.get_cx(),
+        }
+    }
+
+    pub fn as_window<'b>(&'b self) -> &'b JSRef<'b, Window> {
+        match *self {
+            Window(ref window) => window,
+        }
+    }
+
+    pub fn page<'b>(&'b self) -> &'b Page {
+        self.as_window().page()
+    }
+
+    pub fn get_url(&self) -> Url {
+        self.as_window().get_url()
+    }
+
+    pub fn script_chan<'b>(&'b self) -> &'b ScriptChan {
+        &self.as_window().script_chan
+    }
+}
+
+impl<'a> Reflectable for GlobalRef<'a> {
+    fn reflector<'b>(&'b self) -> &'b Reflector {
+        match *self {
+            Window(ref window) => window.reflector(),
+        }
+    }
+}
+
+impl<'a, 'b> GlobalRoot<'a, 'b> {
+    pub fn root_ref<'c>(&'c self) -> GlobalRef<'c> {
+        match *self {
+            WindowRoot(ref window) => Window(window.root_ref()),
+        }
+    }
+}
+
+impl GlobalField {
+    pub fn from_rooted(global: &GlobalRef) -> GlobalField {
+        match *global {
+            Window(ref window) => WindowField(JS::from_rooted(window)),
+        }
+    }
+
+    pub fn root(&self) -> GlobalRoot {
+        match *self {
+            WindowField(ref window) => WindowRoot(window.root()),
+        }
+    }
+}
diff --git a/src/components/script/dom/bindings/utils.rs b/src/components/script/dom/bindings/utils.rs
index 0c3375111ef..628debb24ea 100644
--- a/src/components/script/dom/bindings/utils.rs
+++ b/src/components/script/dom/bindings/utils.rs
@@ -5,7 +5,8 @@
 use dom::bindings::codegen::PrototypeList;
 use dom::bindings::codegen::PrototypeList::MAX_PROTO_CHAIN_LENGTH;
 use dom::bindings::conversions::{FromJSValConvertible, IDLInterface};
-use dom::bindings::js::{JS, JSRef, Temporary, Root};
+use dom::bindings::global::{GlobalRef, GlobalField, WindowField};
+use dom::bindings::js::{JS, Temporary, Root};
 use dom::bindings::trace::Untraceable;
 use dom::browsercontext;
 use dom::window;
@@ -373,10 +374,10 @@ pub trait Reflectable {
 
 pub fn reflect_dom_object<T: Reflectable>
         (obj:     Box<T>,
-         window:  &JSRef<window::Window>,
-         wrap_fn: extern "Rust" fn(*mut JSContext, &JSRef<window::Window>, Box<T>) -> Temporary<T>)
+         global:  &GlobalRef,
+         wrap_fn: extern "Rust" fn(*mut JSContext, &GlobalRef, Box<T>) -> Temporary<T>)
          -> Temporary<T> {
-    wrap_fn(window.get_cx(), window, obj)
+    wrap_fn(global.get_cx(), global, obj)
 }
 
 #[allow(raw_pointer_deriving)]
@@ -580,23 +581,23 @@ pub extern fn outerize_global(_cx: *mut JSContext, obj: JSHandleObject) -> *mut
 }
 
 /// Returns the global object of the realm that the given JS object was created in.
-pub fn global_object_for_js_object(obj: *mut JSObject) -> JS<window::Window> {
+pub fn global_object_for_js_object(obj: *mut JSObject) -> GlobalField {
     unsafe {
         let global = GetGlobalForObjectCrossCompartment(obj);
         let clasp = JS_GetClass(global);
         assert!(((*clasp).flags & (JSCLASS_IS_DOMJSCLASS | JSCLASS_IS_GLOBAL)) != 0);
-        FromJSValConvertible::from_jsval(ptr::mut_null(), ObjectOrNullValue(global), ())
-            .ok().expect("found DOM global that doesn't unwrap to Window")
+        match FromJSValConvertible::from_jsval(ptr::mut_null(), ObjectOrNullValue(global), ()) {
+            Ok(window) => return WindowField(window),
+            Err(_) => (),
+        }
+
+        fail!("found DOM global that doesn't unwrap to Window")
     }
 }
 
 fn cx_for_dom_reflector(obj: *mut JSObject) -> *mut JSContext {
-    let win = global_object_for_js_object(obj).root();
-    let js_info = win.deref().page().js_info();
-    match *js_info {
-        Some(ref info) => info.js_context.deref().deref().ptr,
-        None => fail!("no JS context for DOM global")
-    }
+    let global = global_object_for_js_object(obj).root();
+    global.root_ref().get_cx()
 }
 
 pub fn cx_for_dom_object<T: Reflectable>(obj: &T) -> *mut JSContext {