Auto merge of #6110 - klusark:NamedConstructor, r=Ms2ger

Implement Named constructors and the Image constructor for HTMLImageElement

I'm not sure if I like how I mostly just duplicated the code in CodegenRust.py, so that might need to be refactored.

Instead of just calling it Image, we might want to call it ConstructorImage, to make it clear that it's a constructor. Anyone have an opinion on that?

There seems to be a bug in the HTMLImageElement getter/setter as the value is 0 regardless of what I do. This seems to be unrelated to my commits, so I'll investigate that separately.

<!-- Reviewable:start -->
[<img src="https://reviewable.io/review_button.png" height=40 alt="Review on Reviewable"/>](https://reviewable.io/reviews/servo/servo/6110)
<!-- Reviewable:end -->

4 files changed, 122 insertions, 26 deletions

diff --git a/components/script/dom/bindings/codegen/CodegenRust.py b/components/script/dom/bindings/codegen/CodegenRust.py
index 832dd564736..2847401e65c 100644
--- a/components/script/dom/bindings/codegen/CodegenRust.py
+++ b/components/script/dom/bindings/codegen/CodegenRust.py
@@ -2286,11 +2286,25 @@ class CGCreateInterfaceObjectsMethod(CGAbstractMethod):
         call = """\
 do_create_interface_objects(cx, receiver, parent_proto.handle(),
                             %s, %s,
+                            &named_constructors,
                             %s,
                             &sNativeProperties, rval);""" % (protoClass, constructor, domClass)
 
+        createArray = """\
+let named_constructors: [(NonNullJSNative, &'static str, u32); %d] = [
+""" % len(self.descriptor.interface.namedConstructors)
+        for ctor in self.descriptor.interface.namedConstructors:
+            constructHook = CONSTRUCT_HOOK_NAME + "_" + ctor.identifier.name;
+            constructArgs = methodLength(ctor)
+            constructor = '(%s as NonNullJSNative, "%s", %d)' % (
+                constructHook, ctor.identifier.name, constructArgs)
+            createArray += constructor
+            createArray += ","
+        createArray += "];"
+
         return CGList([
             CGGeneric(getParentProto),
+            CGGeneric(createArray),
             CGGeneric(call % self.properties.variableNames())
         ], "\n")
 
@@ -4422,6 +4436,30 @@ let args = CallArgs::from_vp(vp, argc);
                                      self.descriptor, self._ctor)
         return CGList([preamble, callGenerator])
 
+class CGClassNameConstructHook(CGAbstractExternMethod):
+    """
+    JS-visible named constructor for our objects
+    """
+    def __init__(self, descriptor, ctor):
+        args = [Argument('*mut JSContext', 'cx'), Argument('u32', 'argc'), Argument('*mut JSVal', 'vp')]
+        self._ctor = ctor
+        CGAbstractExternMethod.__init__(self, descriptor,
+                                        CONSTRUCT_HOOK_NAME + "_" +
+                                            self._ctor.identifier.name,
+                                        'u8', args)
+
+    def definition_body(self):
+        preamble = CGGeneric("""\
+let global = global_object_for_js_object(JS_CALLEE(cx, vp).to_object());
+let args = CallArgs::from_vp(vp, argc);
+""")
+        name = self._ctor.identifier.name
+        nativeName = MakeNativeName(self.descriptor.binaryNameFor(name))
+        callGenerator = CGMethodCall(["global.r()"], nativeName, True,
+                                     self.descriptor, self._ctor)
+        return CGList([preamble, callGenerator])
+
+
 class CGClassFinalizeHook(CGAbstractClassHook):
     """
     A hook for finalize, used to release our native object.
@@ -4568,6 +4606,8 @@ class CGDescriptor(CGThing):
 
         if descriptor.interface.hasInterfaceObject():
             cgThings.append(CGClassConstructHook(descriptor))
+            for ctor in descriptor.interface.namedConstructors:
+                cgThings.append(CGClassNameConstructHook(descriptor, ctor))
             cgThings.append(CGInterfaceObjectJSClass(descriptor))
 
         if not descriptor.interface.isCallback():
diff --git a/components/script/dom/bindings/utils.rs b/components/script/dom/bindings/utils.rs
index f8df9805ebd..5a2eb51f2ce 100644
--- a/components/script/dom/bindings/utils.rs
+++ b/components/script/dom/bindings/utils.rs
@@ -205,6 +205,7 @@ pub fn do_create_interface_objects(cx: *mut JSContext,
                                    proto_proto: HandleObject,
                                    proto_class: Option<&'static JSClass>,
                                    constructor: Option<(NonNullJSNative, &'static str, u32)>,
+                                   named_constructors: &[(NonNullJSNative, &'static str, u32)],
                                    dom_class: *const DOMClass,
                                    members: &'static NativeProperties,
                                    rval: MutableHandleObject) {
@@ -226,6 +227,55 @@ pub fn do_create_interface_objects(cx: *mut JSContext,
                                 native, nargs, rval.handle(),
                                 members, s.as_ptr())
     }
+
+    for ctor in named_constructors.iter() {
+        let (cnative, cname, cnargs) = *ctor;
+
+        let cs = CString::new(cname).unwrap();
+        let constructor = RootedObject::new(cx, create_constructor(cx, cnative, cnargs, cs.as_ptr()));
+        assert!(!constructor.ptr.is_null());
+        unsafe {
+            assert!(JS_DefineProperty1(cx, constructor.handle(), "prototype".as_ptr() as *const i8,
+                                       rval.handle(),
+                                       JSPROP_PERMANENT | JSPROP_READONLY,
+                                       None, None) != 0);
+        }
+        define_constructor(cx, receiver, cs.as_ptr(), constructor.handle());
+    }
+
+}
+
+fn create_constructor(cx: *mut JSContext,
+                      constructor_native: NonNullJSNative,
+                      ctor_nargs: u32,
+                      name: *const libc::c_char) -> *mut JSObject {
+    unsafe {
+        let fun = JS_NewFunction(cx, Some(constructor_native), ctor_nargs,
+                                 JSFUN_CONSTRUCTOR, name);
+        assert!(!fun.is_null());
+
+        let constructor = JS_GetFunctionObject(fun);
+        assert!(!constructor.is_null());
+
+        constructor
+    }
+}
+
+fn define_constructor(cx: *mut JSContext,
+                      receiver: HandleObject,
+                      name: *const libc::c_char,
+                      constructor: HandleObject) {
+    unsafe {
+        let mut already_defined = 0;
+        assert!(JS_AlreadyHasOwnProperty(cx, receiver, name, &mut already_defined) != 0);
+
+        if already_defined == 0 {
+            assert!(JS_DefineProperty1(cx, receiver, name,
+                                      constructor,
+                                      0, None, None) != 0);
+        }
+
+    }
 }
 
 /// Creates the *interface object*.
@@ -236,39 +286,28 @@ fn create_interface_object(cx: *mut JSContext,
                            ctor_nargs: u32, proto: HandleObject,
                            members: &'static NativeProperties,
                            name: *const libc::c_char) {
-    unsafe {
-        let fun = JS_NewFunction(cx, Some(constructor_native), ctor_nargs,
-                                 JSFUN_CONSTRUCTOR, name);
-        assert!(!fun.is_null());
+    let constructor = RootedObject::new(cx, create_constructor(cx, constructor_native, ctor_nargs, name));
+    assert!(!constructor.ptr.is_null());
 
-        let constructor = RootedObject::new(cx, JS_GetFunctionObject(fun));
-        assert!(!constructor.ptr.is_null());
-
-        if let Some(static_methods) = members.static_methods {
-            define_methods(cx, constructor.handle(), static_methods);
-        }
+    if let Some(static_methods) = members.static_methods {
+        define_methods(cx, constructor.handle(), static_methods);
+    }
 
-        if let Some(static_properties) = members.static_attrs {
-            define_properties(cx, constructor.handle(), static_properties);
-        }
+    if let Some(static_properties) = members.static_attrs {
+        define_properties(cx, constructor.handle(), static_properties);
+    }
 
-        if let Some(constants) = members.consts {
-            define_constants(cx, constructor.handle(), constants);
-        }
+    if let Some(constants) = members.consts {
+        define_constants(cx, constructor.handle(), constants);
+    }
 
+    unsafe {
         if !proto.get().is_null() {
             assert!(JS_LinkConstructorAndPrototype(cx, constructor.handle(), proto) != 0);
         }
-
-        let mut already_defined = 0;
-        assert!(JS_AlreadyHasOwnProperty(cx, receiver, name, &mut already_defined) != 0);
-
-        if already_defined == 0 {
-            assert!(JS_DefineProperty1(cx, receiver, name,
-                                       constructor.handle(),
-                                       0, None, None) != 0);
-        }
     }
+
+    define_constructor(cx, receiver, name, constructor.handle());
 }
 
 /// Defines constants on `obj`.
diff --git a/components/script/dom/htmlimageelement.rs b/components/script/dom/htmlimageelement.rs
index 2ea5442bff6..6580e4f42a5 100644
--- a/components/script/dom/htmlimageelement.rs
+++ b/components/script/dom/htmlimageelement.rs
@@ -7,8 +7,10 @@ use dom::attr::{AttrHelpers, AttrValue};
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::HTMLImageElementBinding;
 use dom::bindings::codegen::Bindings::HTMLImageElementBinding::HTMLImageElementMethods;
+use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::codegen::InheritTypes::{NodeCast, ElementCast, EventTargetCast, HTMLElementCast,
                                            HTMLImageElementDerived};
+use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{LayoutJS, Root};
 use dom::bindings::refcounted::Trusted;
@@ -151,6 +153,21 @@ impl HTMLImageElement {
         let element = HTMLImageElement::new_inherited(localName, prefix, document);
         Node::reflect_node(box element, document, HTMLImageElementBinding::Wrap)
     }
+
+    pub fn Image(global: GlobalRef,
+                 width: Option<u32>,
+                 height: Option<u32>) -> Fallible<Root<HTMLImageElement>> {
+        let document = global.as_window().Document();
+        let image = HTMLImageElement::new("img".to_owned(), None, document.r());
+        if let Some(w) = width {
+            image.SetWidth(w);
+        }
+        if let Some(h) = height {
+            image.SetHeight(h);
+        }
+
+        Ok(image)
+    }
 }
 
 pub trait LayoutHTMLImageElementHelpers {
diff --git a/components/script/dom/webidls/HTMLImageElement.webidl b/components/script/dom/webidls/HTMLImageElement.webidl
index 71b49229393..defbfb68257 100644
--- a/components/script/dom/webidls/HTMLImageElement.webidl
+++ b/components/script/dom/webidls/HTMLImageElement.webidl
@@ -4,7 +4,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 // https://www.whatwg.org/html/#htmlimageelement
-//[NamedConstructor=Image(optional unsigned long width, optional unsigned long height)]
+[NamedConstructor=Image(optional unsigned long width, optional unsigned long height)]
 interface HTMLImageElement : HTMLElement {
            attribute DOMString alt;
            attribute DOMString src;