Replace GetReflector by an implementation of ToJSValConvertible.

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

@@ -1301,21 +1301,6 @@ def getWrapTemplateForType(type, descriptorProvider, result, successCode,
         return ("${jsvalRef} = %s;\n" +
                 tail) % (value)
 
-    def wrapAndSetPtr(wrapCall, failureCode=None):
-        """
-        Returns the code to set the jsval by calling "wrapCall". "failureCode"
-        is the code to run if calling "wrapCall" fails 
-        """
-        if failureCode is None:
-            if not haveSuccessCode:
-                return wrapCall + ";\n" + "return if (*vp).v != 0 { 1 } else { 0 };"
-            failureCode = "return 0;"
-        str = ("if !(%s != 0) {\n" +
-               CGIndenter(CGGeneric(failureCode)).define() + "\n" +
-               "}\n" +
-               successCode) % (wrapCall)
-        return str
-    
     if type is None or type.isVoid():
         return (setValue("UndefinedValue()"), True)
 
@@ -1326,26 +1311,7 @@ def getWrapTemplateForType(type, descriptorProvider, result, successCode,
         raise TypeError("Can't handle sequence return values yet")
 
     if type.isGeckoInterface():
-        descriptor = descriptorProvider.getDescriptor(type.unroll().inner.identifier.name)
-        if type.nullable():
-            wrappingCode = ("if %s.is_none() {\n" % (result) +
-                            CGIndenter(CGGeneric(setValue("NullValue()"))).define() + "\n" +
-                            "}\n" +
-                            "let mut %s = %s.unwrap();\n" % (result, result))
-        else:
-            wrappingCode = ""
-        if not descriptor.interface.isCallback():
-            wrap = "GetReflector(cx, (%s).reflector(), ${jsvalPtr} as *mut JSVal)" % result
-            # Non-prefable bindings can only fail to wrap as a new-binding object
-            # if they already threw an exception.  Same thing for
-            # non-prefable bindings.
-            failed = ("assert!(unsafe { JS_IsExceptionPending(cx) != 0 });\n" +
-                      "%s" % exceptionCode)
-            wrappingCode += wrapAndSetPtr(wrap, failed)
-        else:
-            wrap = "GetReflector(cx, (%s).reflector(), ${jsvalPtr} as *mut JSVal)" % result
-            wrappingCode += wrapAndSetPtr(wrap)
-        return (wrappingCode, False)
+        return (setValue("(%s).to_jsval(cx)" % result), True)
 
     if type.isString():
         return (setValue("(%s).to_jsval(cx)" % result), True)
@@ -5045,7 +5011,7 @@ class CGBindingRoot(CGThing):
             'dom::bindings::utils::{DOMJSClass}',
             'dom::bindings::utils::{FindEnumStringIndex, GetArrayIndexFromId}',
             'dom::bindings::utils::{GetPropertyOnPrototype, GetProtoOrIfaceArray}',
-            'dom::bindings::utils::{GetReflector, HasPropertyOnPrototype, IntVal}',
+            'dom::bindings::utils::{HasPropertyOnPrototype, IntVal}',
             'dom::bindings::utils::{jsid_to_str}',
             'dom::bindings::utils::{NativePropertyHooks}',
             'dom::bindings::utils::global_object_for_js_object',
@@ -5730,7 +5696,7 @@ class CallbackMember(CGNativeMember):
             {
                 'result' : result,
                 'successCode' : "continue;" if arg.variadic else "break;",
-                'jsvalRef' : "argv.handleAt(%s)" % jsvalIndex,
+                'jsvalRef' : "argv[%s]" % jsvalIndex,
                 'jsvalHandle' : "argv.handleAt(%s)" % jsvalIndex,
                 'jsvalPtr': "&mut argv[%s]" % jsvalIndex,
                 # XXXbz we don't have anything better to use for 'obj',

src/components/script/dom/bindings/conversions.rs

@@ -2,6 +2,8 @@
  * 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::js::JS;
+use dom::bindings::utils::Reflectable;
 use dom::bindings::utils::jsstring_to_str;
 use servo_util::str::DOMString;
 
@@ -10,8 +12,10 @@ use js::jsapi::{JS_ValueToUint64, JS_ValueToInt64};
 use js::jsapi::{JS_ValueToECMAUint32, JS_ValueToECMAInt32};
 use js::jsapi::{JS_ValueToUint16, JS_ValueToNumber, JS_ValueToBoolean};
 use js::jsapi::{JS_NewUCStringCopyN, JS_ValueToString};
+use js::jsapi::{JS_WrapValue};
 use js::jsval::JSVal;
 use js::jsval::{NullValue, BooleanValue, Int32Value, UInt32Value, StringValue};
+use js::jsval::ObjectValue;
 use js::glue::RUST_JS_NumberValue;
 use std::libc;
 
@@ -222,6 +226,18 @@ impl FromJSValConvertible<StringificationBehavior> for DOMString {
     }
 }
 
+impl<T: Reflectable> ToJSValConvertible for JS<T> {
+    fn to_jsval(&self, cx: *JSContext) -> JSVal {
+        let obj = self.reflector().get_jsobject();
+        assert!(obj.is_not_null());
+        let mut value = ObjectValue(unsafe { &*obj });
+        if unsafe { JS_WrapValue(cx, &mut value as *mut JSVal as *JSVal) } == 0 {
+            fail!("JS_WrapValue failed.");
+        }
+        value
+    }
+}
+
 impl<T: ToJSValConvertible> ToJSValConvertible for Option<T> {
     fn to_jsval(&self, cx: *JSContext) -> JSVal {
         match self {

src/components/script/dom/bindings/utils.rs

@@ -21,7 +21,7 @@ use std::unstable::raw::Box;
 use js::glue::*;
 use js::glue::{js_IsObjectProxyClass, js_IsFunctionProxyClass, IsProxyHandlerFamily};
 use js::jsapi::{JS_AlreadyHasOwnProperty, JS_NewFunction};
-use js::jsapi::{JS_DefineProperties, JS_WrapValue, JS_ForwardGetPropertyTo};
+use js::jsapi::{JS_DefineProperties, JS_ForwardGetPropertyTo};
 use js::jsapi::{JS_GetClass, JS_LinkConstructorAndPrototype, JS_GetStringCharsAndLength};
 use js::jsapi::{JS_ObjectIsRegExp, JS_ObjectIsDate};
 use js::jsapi::{JS_InternString, JS_GetFunctionObject};
@@ -460,16 +460,6 @@ impl Reflector {
     }
 }
 
-pub fn GetReflector(cx: *JSContext, reflector: &Reflector,
-                    vp: *mut JSVal) -> JSBool {
-    let obj = reflector.get_jsobject();
-    assert!(obj.is_not_null());
-    unsafe {
-        *vp = ObjectValue(&*obj);
-        return JS_WrapValue(cx, cast::transmute(vp));
-    }
-}
-
 pub fn GetPropertyOnPrototype(cx: *JSContext, proxy: *JSObject, id: jsid, found: *mut bool,
                               vp: *JSVal) -> bool {
     unsafe {