WIP IDL compiler rewrite

Source/bindings/templates/interface_wip.cpp

+/*
+    This file is part of the Blink open source project.
+    This file has been auto-generated by CodeGeneratorV8.pm. DO NOT MODIFY!
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+*/
+
+{% from 'attributes_wip.cpp' import attribute_getter, attribute_getter_callback, attribute_setter, attribute_setter_callback, batched_attribute, enabled_at_runtime_batched_attribute with context %}
+{% from 'constants.cpp' import class_consts, const_data, batch_configure_constants with context %}
+{% from 'constructors.cpp' import constructor_callback, make_constructors, more_constructor_stuff with context %}
+{% from 'macros.cpp' import method, method_callback, parameters_check, function_call, feature_observation, deprecation_notification, custom_element_invocation, if_else_statement with context %}
+#include "config.h"
+{% if conditional_string %}
+#if {{conditional_string}}
+{% endif %}
+#include "{{v8_class_name}}.h"
+
+{% for filename in cpp_includes %}
+#include "{{filename}}"
+{% endfor %}
+
+namespace WebCore {
+
+static void initializeScriptWrappableForInterface({{cpp_class_name}}* object)
+{
+    if (ScriptWrappable::wrapperCanBeStoredInObject(object))
+        ScriptWrappable::setTypeInfoInObject(object, &{{v8_class_name}}::info);
+    else
+        ASSERT_NOT_REACHED();
+}
+
+} // namespace WebCore
+
+// In ScriptWrappable::init, the use of a local function declaration has an issue on Windows:
+// the local declaration does not pick up the surrounding namespace. Therefore, we provide this function
+// in the global namespace.
+// (More info on the MSVC bug here: http://connect.microsoft.com/VisualStudio/feedback/details/664619/the-namespace-of-local-function-declarations-in-c)
+void webCoreInitializeScriptWrappableForInterface({{namespace_for_interface=='WebCore' and 'WebCore::' or ''}}{{cpp_class_name}}* object)
+{
+    WebCore::initializeScriptWrappableForInterface(object);
+}
+
+namespace WebCore {
+WrapperTypeInfo {{v8_class_name}}::info = { {{v8_class_name}}::GetTemplate, {{v8_class_name}}::derefObject, {{to_active_dom_object}}, {{to_event_target}}, {{root_for_gc}}, {{v8_class_name}}::installPerContextPrototypeProperties, {{parent_class_info}}, {{wrapper_type_prototype}} };
+
+namespace {{cpp_class_name}}V8Internal {
+
+template <typename T> void V8_USE(T) { }
+
+{# ############################################## Attributes #}
+{% for attribute in attributes %}
+{% for for_main_world_suffix in attribute.for_main_world_suffixes %}
+{{attribute_getter(attribute, for_main_world_suffix) -}}
+{{attribute_getter_callback(attribute, for_main_world_suffix)}}{% endfor %}
+{% for for_main_world_suffix in attribute.for_main_world_suffixes %}
+{% if attribute.has_normal_setter and not attribute.has_custom_setter %}
+{{attribute_setter(attribute, for_main_world_suffix)}}{% endif %}
+{% if attribute.has_normal_setter %}
+{{attribute_setter_callback(attribute, for_main_world_suffix)}}{% endif %}
+{% endfor %}
+{% endfor %}
+{# ############################################## Functions #}
+{% for function in functions %}
+{% if function.name and not function.is_custom %}
+{% for for_main_world_suffix in function.for_main_world_suffixes %}
+{{method(function, for_main_world_suffix)}}{% endfor %}
+{% endif %}
+{# ###### Function callback #}
+{% for for_main_world_suffix in function.for_main_world_suffixes %}
+{{method_callback(function, for_main_world_suffix)}}{% endfor %}
+{% endfor %}
+{# for functions #}
+{##############################################################################}
+{# Constructors #}
+{##############################################################################}
+{% if not has_custom_constructor %}
+{{make_constructors()}}{% endif %}
+{##############################################################################}
+{# GenerateImplementationIndexedPropertyAccessors #}
+{# GenerateImplementationIndexedPropertyGetter #}
+{% if special_accessors.indexed.getter.enabled and not special_accessors.indexed.getter.is_custom %}
+static void indexedPropertyGetter(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info)
+{
+    ASSERT(V8DOMWrapper::maybeDOMWrapper(info.Holder()));
+    {{cpp_class_name}}* collection = {{v8_class_name}}::toNative(info.Holder());
+{% if special_accessors.indexed.getter.raises_exceptions %}
+    ExceptionState es(info.GetIsolate());
+{% endif %}
+{# TODO use function_call {{function_call(indexed_getter.function_call_parameter)}}#}
+{{special_accessors.indexed.getter.function_call}}
+{% if special_accessors.indexed.getter.raises_exceptions %}
+    if (es.throwIfNeeded())
+        return;
+{% endif %}
+{% if special_accessors.indexed.getter.return_type_is_union %}
+{#TODO#}
+    {{special_accessors.indexed.getter.return_js_value_statement | indent}}
+    return;
+{% else %}
+    if ({{special_accessors.indexed.getter.is_null_expression}})
+        return;
+    {{special_accessors.indexed.getter.return_js_value_statement | indent}}
+{% endif %}
+}
+
+{% endif %}
+{# GenerateImplementationIndexedPropertyGetterCallback #}
+{% if special_accessors.indexed.getter.enabled %}
+static void indexedPropertyGetterCallback(uint32_t index, const v8::PropertyCallbackInfo<v8::Value>& info)
+{
+    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMIndexedProperty");
+{% if special_accessors.indexed.getter.is_custom %}
+    {{v8_class_name}}::indexedPropertyGetterCustom(index, info);
+{% else %}
+    {{cpp_class_name}}V8Internal::indexedPropertyGetter(index, info);
+{% endif %}
+    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
+}
+
+{% endif %}
+{# GenerateImplementationIndexedPropertySetter #}
+{% if special_accessors.indexed.setter.enabled and not special_accessors.indexed.setter.is_custom %}
+static void indexedPropertySetter(uint32_t index, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info)
+{
+    {{cpp_class_name}}* collection = {{v8_class_name}}::toNative(info.Holder());
+    {{special_accessors.indexed.setter.js_to_native_statement}}
+{% if special_accessors.indexed.setter.raises_exceptions %}
+    ExceptionState es(info.GetIsolate());
+{% endif %}
+{{if_else_statement('bool', 'result', special_accessors.indexed.setter.condition_and_statements)}}
+    if (!result)
+        return;
+{% if special_accessors.indexed.setter.raises_exceptions %}
+    if (es.throwIfNeeded())
+        return;
+{% endif %}
+    v8SetReturnValue(info, value);
+}
+
+{% endif %}
+{# GenerateImplementationIndexedPropertySetterCallback #}
+{% if special_accessors.indexed.setter.enabled %}
+static void indexedPropertySetterCallback(uint32_t index, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info)
+{
+    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMIndexedProperty");
+{% if special_accessors.indexed.getter.is_custom %}
+    {{v8_class_name}}::indexedPropertySetterCustom(index, value, info);
+{% else %}
+    {{cpp_class_name}}V8Internal::indexedPropertySetter(index, value, info);
+{% endif %}
+    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
+}
+
+{% endif %}
+{# GenerateImplementationIndexedPropertyDeleter #}
+{# GenerateImplementationIndexedPropertyDeleterCallback #}
+{##############################################################################}
+{##############################################################################}
+{# GenerateImplementationNamedPropertyAccessors #}
+{# GenerateImplementationNamedPropertyGetter #}
+{% if special_accessors.named.getter.enabled and not special_accessors.named.getter.is_custom %}
+static void namedPropertyGetter(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
+{
+{% if not special_accessors.named.getter.override_builtins %}
+    if (!info.Holder()->GetRealNamedPropertyInPrototypeChain(name).IsEmpty())
+        return;
+    if (info.Holder()->HasRealNamedCallbackProperty(name))
+        return;
+    if (info.Holder()->HasRealNamedProperty(name))
+        return;
+
+{% endif %}
+    ASSERT(V8DOMWrapper::maybeDOMWrapper(info.Holder()));
+    {{cpp_class_name}}* collection = {{v8_class_name}}::toNative(info.Holder());
+    AtomicString propertyName = toWebCoreAtomicString(name);
+{% if special_accessors.named.getter.raises_exceptions %}
+    ExceptionState es(info.GetIsolate());
+{% endif %}
+{{special_accessors.named.getter.function_call}}
+{% if special_accessors.named.getter.raises_exceptions %}
+    if (es.throwIfNeeded())
+        return;
+{% endif %}
+{% if special_accessors.named.getter.is_return_type_union %}
+{{special_accessors.named.getter.return_js_value_code}}
+    return;
+{% else %}
+    if ({{special_accessors.named.getter.is_null_expression}})
+        return;
+    {{special_accessors.named.getter.return_js_value_code}}
+{% endif %}
+}
+
+{% endif %}
+{# GenerateImplementationNamedPropertyGetterCallback #}
+{% if special_accessors.named.getter.enabled %}
+static void namedPropertyGetterCallback(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value>& info)
+{
+    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMNamedProperty");
+{% if special_accessors.named.getter.is_custom %}
+    {{v8_class_name}}::namedPropertyGetterCustom(name, info);
+{% else %}
+    {{cpp_class_name}}V8Internal::namedPropertyGetter(name, info);
+{% endif %}
+    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
+}
+
+{% endif %}
+{# GenerateImplementationNamedPropertySetter #}
+{# GenerateImplementationNamedPropertySetterCallback #}
+{% if special_accessors.named.setter.enabled %}
+static void namedPropertySetterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info)
+{
+    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMNamedProperty");
+{% if special_accessors.named.setter.is_custom %}
+    {{v8_class_name}}::namedPropertySetterCustom(name, value, info);
+{% else %}
+    {{cpp_class_name}}V8Internal::namedPropertySetter(name, value, info);
+{% endif %}
+    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
+}
+
+{% endif %}
+{# GenerateImplementationNamedPropertyDeleter #}
+{# GenerateImplementationNamedPropertyDeleterCallback #}
+{% if special_accessors.named.deleter.enabled %}
+static void namedPropertyDeleterCallback(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value>& info)
+{
+    TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMNamedProperty");
+{% if special_accessors.named.deleter.is_custom %}
+    {{v8_class_name}}::namedPropertyDeleterCustom(name, info);
+{% else %}
+    {{cpp_class_name}}V8Internal::namedPropertyDeleter(name, info);
+{% endif %}
+    TRACE_EVENT_SET_SAMPLING_STATE("V8", "Execution");
+}
+{% endif %}
+{# GenerateImplementationNamedPropertyEnumerator #}
+{# GenerateImplementationNamedPropertyQuery #}
+{# GenerateImplementationNamedPropertyEnumeratorCallback #}
+{# GenerateImplementationNamedPropertyQueryCallback #}
+{##############################################################################}
+{##############################################################################}
+{# GenerateImplementationNamedPropertyAccessors #}
+{# GenerateImplementationMasqueradesAsUndefined #}
+{##############################################################################}
+} // namespace {{cpp_class_name}}V8Internal
+
+{% if needs_opaque_root_for_gc %}
+void* {{v8_class_name}}::opaqueRootForGC(void* object, v8::Isolate* isolate)
+{
+    {{cpp_class_name}}* impl = fromInternalPointer(object);
+{% if is_reachable_method %}
+    if (Node* owner = impl->{{is_reachable_method}}())
+        return V8GCController::opaqueRootForGC(owner, isolate);
+{% endif %}
+    return object;
+}
+
+{% endif %}
+{% if not has_custom_constructor %}
+{{more_constructor_stuff()}}{% endif %}
+{# FIXME: pass a list of normal_attributes, instead of length and is_normal #}
+{% if number_of_normal_attributes %}
+{{batched_attribute()}}
+{% endif %}
+{# ### BatchedFunction #}
+{% if function_callbacks %}
+static const V8DOMConfiguration::BatchedMethod {{v8_class_name}}Methods[] = {
+{% for function in functions %}
+{% if function.create_callback %}
+{% if function.conditional_string %}
+#if {{function.conditional_string}}
+{% endif %}
+    {"{{function.name}}", {{cpp_class_name}}V8Internal::{{function.name}}MethodCallback, {{function.method_for_main_world}}, {{function.length}}},
+{% if function.conditional_string %}
+#endif // {{function.conditional_string}}
+{% endif %}
+{% endif %}
+{% endfor %}
+};
+
+{% endif %}
+{% if constants %}
+{{class_consts()}}
+{% endif %}
+{% if not has_custom_constructor %}
+{% if is_constructor_template_of_event %}
+bool fill{{cpp_class_name}}Init({{cpp_class_name}}Init& eventInit, const Dictionary& options)
+{
+{% if parent %}
+    if (!fill{{parent}}Init(eventInit, options))
+        return false;
+
+{% endif %}
+{% for attribute in attributes %}
+{% if attribute.type != 'any' and attribute.initialized_by_event_constructor %}
+    options.get("{{attribute.name}}", eventInit.{{attribute.name}});
+{% endif %}
+{% endfor %}
+    return true;
+}
+
+{% endif %}
+{% endif %}
+{% if is_constructable %}
+{{constructor_callback()}}
+{% endif %}
+static v8::Handle<v8::FunctionTemplate> Configure{{v8_class_name}}Template(v8::Handle<v8::FunctionTemplate> desc, v8::Isolate* isolate, WrapperWorldType currentWorldType)
+{
+    desc->ReadOnlyPrototype();
+
+    v8::Local<v8::Signature> defaultSignature;
+{% if enabled_at_runtime %}
+    if (!{{enable_function}}())
+        defaultSignature = V8DOMConfiguration::configureTemplate(desc, "", {{parent_class_template}}, {{v8_class_name}}::internalFieldCount, 0, 0, 0, 0, isolate, currentWorldType);
+    else
+{% endif %}
+    defaultSignature = V8DOMConfiguration::configureTemplate(desc, "{{interface_name}}", {{parent_class_template}}, {{v8_class_name}}::internalFieldCount,
+        {{configure_template_batched_attribute}}, {{configure_template_attribute_count}},
+        {{configure_template_batched_method}}, {{configure_template_method_count}}, isolate, currentWorldType);
+    UNUSED_PARAM(defaultSignature); // In some cases, it will not be used.
+{% if is_constructable %}
+    desc->SetCallHandler({{v8_class_name}}::constructorCallback);
+    desc->SetLength({{interface_length}});
+{% endif %}
+{% if access_check or number_of_enabled_at_runtime_attributes or number_of_normal_functions or constants %}
+    v8::Local<v8::ObjectTemplate> instance = desc->InstanceTemplate();
+    v8::Local<v8::ObjectTemplate> proto = desc->PrototypeTemplate();
+    UNUSED_PARAM(instance); // In some cases, it will not be used.
+    UNUSED_PARAM(proto); // In some cases, it will not be used.
+{% endif %}
+{% if access_check %}
+    instance->SetAccessCheckCallbacks({{cpp_class_name}}V8Internal::namedSecurityCheck, {{cpp_class_name}}V8Internal::indexedSecurityCheck, v8::External::New(&{{v8_class_name}}::info));
+{% endif %}
+{# FIXME: instead pass a list of enabled_at_runtime_attributes #}
+{% if number_of_enabled_at_runtime_attributes %}
+{{enabled_at_runtime_batched_attribute()}}{% endif %}
+{% for constant in constants %}{{const_data(constant)}}{% endfor %}
+{# TODO GenerateImplementationIndexedPropertyAccessors #}
+{% if special_accessors.indexed.getter.enabled %}
+    desc->{{special_accessors.set_on}}Template()->SetIndexedPropertyHandler({{special_accessors.indexed.getter.callback_name}}, {{special_accessors.indexed.setter.callback_name}}, {{special_accessors.indexed.query.callback_name}}, {{special_accessors.indexed.deleter.callback_name}}, {{special_accessors.indexed.enumerator.callback_name}});
+{% endif %}
+{# TODO GenerateImplementationNamedPropertyAccessors #}
+{% if special_accessors.named.getter.enabled %}
+    desc->{{special_accessors.set_on}}Template()->SetNamedPropertyHandler({{special_accessors.named.getter.callback_name}}, {{special_accessors.named.setter.callback_name}}, {{special_accessors.named.query.callback_name}}, {{special_accessors.named.deleter.callback_name}}, {{special_accessors.named.enumerator.callback_name}});
+{% endif %}
+{# TODO GenerateImplementationLegacyCall #}
+{% if custom_legacy_call %}
+    desc->InstanceTemplate()->SetCallAsFunctionHandler({{v8_class_name}}::legacyCallCustom);
+{% endif %}
+{# TODO GenerateImplementationMasqueradesAsUndefined #}
+{% for function in functions %}
+{% if function.is_representative and function.is_normal_function and not function.is_standard_function %}
+{% if check_security and function.do_not_check_security %}
+
+    // {{function.comment_info}}
+    {{function.conditional_runtime}}{{function.template}}->SetAccessor(v8::String::NewSymbol("{{function.name}}"), {{cpp_class_name}}V8Internal::{{function.name}}AttrGetterCallback, {{function.setter}}, v8Undefined(), v8::ALL_CAN_READ, static_cast<v8::PropertyAttribute>({{function.property_attributes}}));
+
+{% else %}
+{% if function.conditional_string %}
+#if {{function.conditional_string}}
+{%- endif %}
+{% if function.requires_custom_signature %}
+
+    // Custom Signature '{{function.name}}'
+    const int {{function.name}}Argc = {{function.parameters | length}};
+    v8::Handle<v8::FunctionTemplate> {{function.name}}Argv[{{function.name}}Argc] = { {{function.custom_signature}} };
+    v8::Handle<v8::Signature> {{function.name}}Signature = v8::Signature::New(desc, {{function.name}}Argc, {{function.name}}Argv);
+{% endif %}
+{# see end of GenerateNonStandardFunction in perl #}
+{% if function.per_world_bindings %}
+    if (currentWorldType == MainWorld) {
+        {{function.conditional_runtime}}{{function.template}}->Set(v8::String::NewSymbol("{{function.name}}"), v8::FunctionTemplate::New({{cpp_class_name}}V8Internal::{{function.name}}MethodCallbackForMainWorld, v8Undefined(), {{function.signature}}, {{function.mandatory_parameters}}){{function.property_attributes}});
+    } else {
+        {{function.conditional_runtime}}{{function.template}}->Set(v8::String::NewSymbol("{{function.name}}"), v8::FunctionTemplate::New({{cpp_class_name}}V8Internal::{{function.name}}MethodCallback, v8Undefined(), {{function.signature}}, {{function.mandatory_parameters}}){{function.property_attributes}});
+    }
+{% else %}
+    {{function.conditional_runtime}}{{function.template}}->Set(v8::String::NewSymbol("{{function.name}}"), v8::FunctionTemplate::New({{cpp_class_name}}V8Internal::{{function.name}}MethodCallback, v8Undefined(), {{function.signature}}, {{function.mandatory_parameters}}){{function.property_attributes}});
+{% endif %}
+{% if function.conditional_string %}
+#endif // {{function.conditional_string}}{% endif %}
+{% endif %}
+{% endif %}
+{% endfor %}
+{% if constants %}
+    {{batch_configure_constants()}}
+{% endif %}
+
+    // Custom toString template
+    desc->Set(v8::String::NewSymbol("toString"), V8PerIsolateData::current()->toStringTemplate());
+    return desc;
+}
+
+v8::Handle<v8::FunctionTemplate> {{v8_class_name}}::GetTemplate(v8::Isolate* isolate, WrapperWorldType currentWorldType)
+{
+    V8PerIsolateData* data = V8PerIsolateData::from(isolate);
+    V8PerIsolateData::TemplateMap::iterator result = data->templateMap(currentWorldType).find(&info);
+    if (result != data->templateMap(currentWorldType).end())
+        return result->value.newLocal(isolate);
+
+    TRACE_EVENT_SCOPED_SAMPLING_STATE("Blink", "BuildDOMTemplate");
+    v8::HandleScope handleScope(isolate);
+    v8::Handle<v8::FunctionTemplate> templ =
+        Configure{{v8_class_name}}Template(data->rawTemplate(&info, currentWorldType), isolate, currentWorldType);
+    data->templateMap(currentWorldType).add(&info, UnsafePersistent<v8::FunctionTemplate>(isolate, templ));
+    return handleScope.Close(templ);
+}
+
+bool {{v8_class_name}}::HasInstance(v8::Handle<v8::Value> value, v8::Isolate* isolate, WrapperWorldType currentWorldType)
+{
+    return V8PerIsolateData::from(isolate)->hasInstance(&info, value, currentWorldType);
+}
+
+bool {{v8_class_name}}::HasInstanceInAnyWorld(v8::Handle<v8::Value> value, v8::Isolate* isolate)
+{
+    return V8PerIsolateData::from(isolate)->hasInstance(&info, value, MainWorld)
+        || V8PerIsolateData::from(isolate)->hasInstance(&info, value, IsolatedWorld)
+        || V8PerIsolateData::from(isolate)->hasInstance(&info, value, WorkerWorld);
+}
+
+{% if number_of_enabled_per_context_functions %}
+void {{v8_class_name}}::installPerContextPrototypeProperties(v8::Handle<v8::Object> proto, v8::Isolate* isolate)
+{
+    UNUSED_PARAM(proto);
+{# Setup the enable-by-settings functions if we have them #}
+    v8::Local<v8::Signature> defaultSignature = v8::Signature::New(GetTemplate(isolate, worldType(isolate)));
+    UNUSED_PARAM(defaultSignature); // In some cases, it will not be used.
+
+    ScriptExecutionContext* context = toScriptExecutionContext(proto->CreationContext());
+{% for function in functions %}
+{% if function.is_enabled_per_context_function %}
+{% if function.conditional_string %}
+#if {{function.conditional_string}}
+{% endif %}
+    if (context && context->isDocument() && {{function.enable_function}}(toDocument(context)))
+        proto->Set(v8::String::NewSymbol("{{function.name}}"), v8::FunctionTemplate::New({{cpp_class_name}}V8Internal::{{function.name}}MethodCallback, v8Undefined(), defaultSignature, {{function.mandatory_parameters}})->GetFunction());
+{% if function.conditional_string %}
+#endif // {{function.conditional_string}}
+{% endif %}
+
+{% endif %}
+{% endfor %}
+}
+{% endif %}
+{% if inherits_extended_attribute_active_dom_object %}
+ActiveDOMObject* {{v8_class_name}}::toActiveDOMObject(v8::Handle<v8::Object> object)
+{
+    return {{active_dom_object_return_value}};
+}
+
+{% endif %}
+{% if inherits_event_target %}
+EventTarget* {{v8_class_name}}::toEventTarget(v8::Handle<v8::Object> object)
+{
+    return toNative(object);
+}
+
+{% endif %}
+{% if create_wrapper %}
+
+v8::Handle<v8::Object> {{v8_class_name}}::createWrapper(PassRefPtr<{{create_wrapper_argument_type}}> impl, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
+{
+    ASSERT(impl.get());
+    ASSERT(DOMDataStore::getWrapper<{{v8_class_name}}>(impl.get(), isolate).IsEmpty());
+    if (ScriptWrappable::wrapperCanBeStoredInObject(impl.get())) {
+        const WrapperTypeInfo* actualInfo = ScriptWrappable::getTypeInfoFromObject(impl.get());
+        // Might be a XXXConstructor::info instead of an XXX::info. These will both have
+        // the same object de-ref functions, though, so use that as the basis of the check.
+        RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(actualInfo->derefObjectFunction == info.derefObjectFunction);
+    }
+
+{% if inherit_document %}
+    if (Frame* frame = impl->frame()) {
+        if (frame->script()->initializeMainWorld()) {
+            // initializeMainWorld may have created a wrapper for the object, retry from the start.
+            v8::Handle<v8::Object> wrapper = DOMDataStore::getWrapper<{{v8_class_name}}>(impl.get(), isolate);
+            if (!wrapper.IsEmpty())
+                return wrapper;
+        }
+    }
+{% endif %}
+
+    v8::Handle<v8::Object> wrapper = V8DOMWrapper::createWrapper(creationContext, &info, toInternalPointer(impl.get()), isolate);
+    if (UNLIKELY(wrapper.IsEmpty()))
+        return wrapper;
+{% if interface_name == 'ArrayBuffer' %}
+    if (!impl->hasDeallocationObserver()) {
+        v8::V8::AdjustAmountOfExternalAllocatedMemory(impl->byteLength());
+        impl->setDeallocationObserver(V8ArrayBufferDeallocationObserver::instance());
+    }
+{% elif is_typed_array_type %}
+    if (!impl->buffer()->hasDeallocationObserver()) {
+        v8::V8::AdjustAmountOfExternalAllocatedMemory(impl->buffer()->byteLength());
+        impl->buffer()->setDeallocationObserver(V8ArrayBufferDeallocationObserver::instance());
+    }
+{% endif %}
+    installPerContextProperties(wrapper, impl.get(), isolate);
+    V8DOMWrapper::associateObjectWithWrapper<{{v8_class_name}}>(impl, &info, wrapper, isolate, {{wrapper_configuration}});
+    return wrapper;
+}
+{% endif %}
+void {{v8_class_name}}::derefObject(void* object)
+{
+    fromInternalPointer(object)->deref();
+}
+
+} // namespace WebCore
+{% if conditional_string %}
+
+#endif // {{conditional_string}}
+{% endif %}
+