IDL compiler: [Constructor] w/o arguments

Source/bindings/templates/interface.cpp

 {% extends 'interface_base.cpp' %}
 
 
 {##############################################################################}
 {% macro attribute_configuration(attribute) %}
 {% set getter_callback =
        '%sV8Internal::%sAttributeGetterCallback' %
             (interface_name, attribute.name)
        if not attribute.constructor_type else
        '{0}V8Internal::{0}ConstructorGetter'.format(interface_name) %}
@@ skipping 111 matching lines @@
     TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMSetter");
     {{cpp_class}}V8Internal::{{cpp_class}}OriginSafeMethodSetter(name, jsValue, info);
     TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
 }
 
 {% endif %}
 {% endblock %}
 
 
 {##############################################################################}
+{% block constructor %}
+{% if has_constructor %}
+{# FIXME: support overloading #}
+static void constructor(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    {# FIXME: support arguments #}
+    RefPtr<{{cpp_class}}> impl = {{cpp_class}}::create();
+    v8::Handle<v8::Object> wrapper = info.Holder();
+
+    V8DOMWrapper::associateObjectWithWrapper<{{v8_class}}>(impl.release(), &{{v8_class}}::wrapperTypeInfo, wrapper, info.GetIsolate(), WrapperConfiguration::Dependent);
+    info.GetReturnValue().Set(wrapper);

[haraken, 2013/12/05 05:54:16]

Can you use v8SetReturnValue()?

[Nils Barth (inactive), 2013/12/05 06:09:20]

I'll try in a followup!

+}
+
+{% endif %}
+{% endblock %}
+
+
+{##############################################################################}
+{% block constructor_callback %}
+{% if has_constructor %}
+void {{v8_class}}::constructorCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "DOMConstructor");
+    if (!info.IsConstructCall()) {
+        throwTypeError(ExceptionMessages::failedToConstruct("{{interface_name}}", "Please use the 'new' operator, this DOM object constructor cannot be called as a function."), info.GetIsolate());
+        return;
+    }
+
+    if (ConstructorMode::current() == ConstructorMode::WrapExistingObject) {
+        info.GetReturnValue().Set(info.Holder());

[haraken, 2013/12/05 05:54:16]

Ditto.

+        return;
+    }
+
+    {{cpp_class}}V8Internal::constructor(info);
+}
+
+{% endif %}
+{% endblock %}
+
+{##############################################################################}
 {% block visit_dom_wrapper %}
 {% if generate_visit_dom_wrapper_function %}
 void {{v8_class}}::visitDOMWrapper(void* object, const v8::Persistent<v8::Object>& wrapper, v8::Isolate* isolate)
 {
     {{cpp_class}}* impl = fromInternalPointer(object);
     if (Node* owner = impl->{{generate_visit_dom_wrapper_function}}()) {
         setObjectGroup(V8GCController::opaqueRootForGC(owner, isolate), wrapper, isolate);
         return;
     }
     setObjectGroup(object, wrapper, isolate);
@@ skipping 83 matching lines @@
                ('%sMethods' % v8_class,
                 'WTF_ARRAY_LENGTH(%sMethods)' % v8_class)
            if has_method_configuration else (0, 0) %}
         {{attributes_name}}, {{attributes_length}},
         {{accessors_name}}, {{accessors_length}},
         {{methods_name}}, {{methods_length}},
         isolate, currentWorldType);
     {% endfilter %}
 
     UNUSED_PARAM(defaultSignature);
+    {% if has_constructor %}
+    functionTemplate->SetCallHandler({{v8_class}}::constructorCallback);
+    {# FIXME: compute length #}
+    functionTemplate->SetLength(0);
+    {% endif %}
     v8::Local<v8::ObjectTemplate> instanceTemplate = functionTemplate->InstanceTemplate();
     v8::Local<v8::ObjectTemplate> prototypeTemplate = functionTemplate->PrototypeTemplate();
     UNUSED_PARAM(instanceTemplate);
     UNUSED_PARAM(prototypeTemplate);
     {% if is_check_security and interface_name != 'Window' %}
     instanceTemplate->SetAccessCheckCallbacks({{cpp_class}}V8Internal::namedSecurityCheck, {{cpp_class}}V8Internal::indexedSecurityCheck, v8::External::New(isolate, const_cast<WrapperTypeInfo*>(&{{v8_class}}::wrapperTypeInfo)));
     {% endif %}
     {% for attribute in attributes if attribute.runtime_enabled_function %}
     {% filter conditional(attribute.conditional_string) %}
     if ({{attribute.runtime_enabled_function}}()) {
@@ skipping 275 matching lines @@
     fromInternalPointer(object)->deref();
 }
 
 template<>
 v8::Handle<v8::Value> toV8NoInline({{cpp_class}}* impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
 {
     return toV8(impl, creationContext, isolate);
 }
 
 {% endblock %}