Generate HTMLElementFactory with Python

Source/build/scripts/templates/ElementFactory.cpp.tmpl

+{% from "macros.tmpl" import license -%}
+{{ license() }}
+
+#include "config.h"
+#include "{{namespace}}ElementFactory.h"
+
+#include "RuntimeEnabledFeatures.h"
+#include "{{namespace}}Names.h"
+{%- for tag in tags|sort %}
+#include "core/{{namespace|lower}}/{{tag|interface}}.h"
+{%- endfor %}
+{%- if fallback_interface %}
+#include "core/{{namespace|lower}}/{{fallback_interface}}.h"
+{%- endif %}
+#include "core/dom/ContextFeatures.h"
+#include "core/dom/custom/CustomElement.h"
+#include "core/dom/custom/CustomElementRegistrationContext.h"
+#include "core/dom/Document.h"
+#include "core/page/Settings.h"
+#include "wtf/HashMap.h"
+
+namespace WebCore {
+
+using namespace {{namespace}}Names;
+
+typedef PassRefPtr<{{namespace}}Element> (*ConstructorFunction)(const QualifiedName&, Document&, HTMLFormElement*, bool createdByParser);
+typedef HashMap<StringImpl*, ConstructorFunction> FunctionMap;
+
+static FunctionMap* g_constructors = 0;
+
+{%- for tag in tags|sort if not tag.mapToTagName and not tag.noConstructor %}
+static PassRefPtr<{{namespace}}Element> {{tag|symbol}}Constructor(const QualifiedName& tagName, Document& document, HTMLFormElement* formElement, bool createdByParser)
+{
+{%- if tag.wrapperOnlyIfMediaIsAvailable %}
+    Settings* settings = document.settings();
+    if (!RuntimeEnabledFeatures::mediaEnabled() || (settings && !settings->mediaEnabled()))
+        return 0;
+{%- endif %}
+{%- if tag.contextConditional %}
+    if (!ContextFeatures::{{tag.contextConditional}}Enabled(&document))
+        return 0;
+{%- endif %}
+    return {{tag|interface}}::create(tagName, document
+{%- if tag.constructorNeedsFormElement %}, formElement{% endif -%}
+{%- if tag.constructorNeedsCreatedByParser %}, createdByParser{% endif -%}
+    );
+}
+{%- endfor %}
+
+{%- for tag in tags|sort if tag.mapToTagName %}
+static PassRefPtr<HTMLElement> {{tag|symbol}}Constructor(const QualifiedName& tagName, Document& document, HTMLFormElement* formElement, bool createdByParser)
+{
+    return {{tag.mapToTagName}}Constructor(QualifiedName(tagName.prefix(), {{tag.mapToTagName}}Tag.localName(), tagName.namespaceURI()), document, formElement, createdByParser);
+}
+{%- endfor %}
+
+static void addTag(const QualifiedName& tag, ConstructorFunction func)
+{
+    g_constructors->set(tag.localName().impl(), func);
+}
+
+static void createFunctionMap()
+{
+    ASSERT(!g_constructors);
+    g_constructors = new FunctionMap;
+{%- for tag in tags|sort if not tag.noConstructor %}
+    addTag({{tag|symbol}}Tag, {{tag|symbol}}Constructor);
+{%- endfor %}
+}
+
+PassRefPtr<{{namespace}}Element> {{namespace}}ElementFactory::create{{namespace}}Element(const QualifiedName& qName, Document* document, HTMLFormElement* formElement, bool createdByParser)
+{
+    if (!document)
+        return 0;
+
+    if (CustomElement::isValidName(qName.localName()) && document->registrationContext()) {
+        RefPtr<Element> element = document->registrationContext()->createCustomTagElement(*document, qName, createdByParser ? CustomElementRegistrationContext::CreatedByParser : CustomElementRegistrationContext::NotCreatedByParser);
+        ASSERT_WITH_SECURITY_IMPLICATION(element->is{{namespace}}Element());
+        return static_pointer_cast<{{namespace}}Element>(element.release());
+    }
+
+    if (!g_constructors)
+        createFunctionMap();
+    if (ConstructorFunction function = g_constructors->get(qName.localName().impl())) {
+        if (PassRefPtr<{{namespace}}Element> element = function(qName, *document, formElement, createdByParser))
+            return element;
+    }
+
+    return {{fallback_interface}}::create(qName, *document);
+}
+
+} // namespace WebCore