Use data driven code when registering constructors.

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"
@@ skipping 40 matching lines @@
 {%- endif %}
     return {{tag.interface}}::create(
 {%- if tag.multipleTagNames -%} {{tag|symbol}}Tag, {% endif -%}
         document
 {%- if namespace == 'HTML' and tag.constructorNeedsFormElement %}, formElement{% endif -%}
 {%- if tag.constructorNeedsCreatedByParser %}, createdByParser{% endif -%}
     );
 }
 {%- endfor %}
 
-static void addTag(const QualifiedName& tag, ConstructorFunction func)
-{
-    g_constructors->set(tag.localName(), func);
-}
-
 static void createFunctionMap()
 {
     ASSERT(!g_constructors);
     g_constructors = new FunctionMap;
+    struct CreateFunctionMapData {
+        const QualifiedName& tag;
+        ConstructorFunction func;
+    };
+    const CreateFunctionMapData data[] = {

[adamk, 2014/02/18 18:28:41]

Not sure if it matters (since this is only called once), but shouldn't this be
static?

[Daniel Bratell, 2014/02/19 13:41:05]

It's a tricky question. For a compile time constant "static const" is the right
thing to do. For an array of function and data pointers? Making it static will
create a data block where all the pointers will have to be resolved at a later
time (at worst, when the function is called and then nothing has been gained).

I wasn't sure when I wrote the code what was correct but since I wanted to avoid
the startup cost of resolving pointers I skipped static. Now I've tried with
both (in clang) and it seems static might be better for code size and the extra
cost for loading the binary will be offset by less work when calling this
function.

Short answer: "Yes".

 {%- for tag in tags|sort if not tag.noConstructor %}
-    addTag({{tag|symbol}}Tag, {{tag|symbol}}Constructor);
+        { {{tag|symbol}}Tag, {{tag|symbol}}Constructor },
 {%- endfor %}
+    };
+    for (size_t i = 0; i < sizeof(data) / sizeof(*data); i++)

[adamk, 2014/02/18 18:28:41]

Nit: you can use WTF_ARRAY_LENGTH() (from wtf/StdLibExtras.h) here instead of
doing sizeof arithmetic.

[Daniel Bratell, 2014/02/19 13:41:05]

Thanks!

+        g_constructors->set(data[i].tag.localName(), data[i].func);
 }
 
 PassRefPtr<{{namespace}}Element> {{namespace}}ElementFactory::create{{namespace}}Element(
     const AtomicString& localName,
     Document& document,
 {%- if namespace == 'HTML' %}
     HTMLFormElement* formElement,
 {%- endif %}
     bool createdByParser)
 {
     if (!g_constructors)
         createFunctionMap();
     if (ConstructorFunction function = g_constructors->get(localName))
         return function(document, {%- if namespace == 'HTML' %}formElement,{% endif %} createdByParser);
 
     if (document.registrationContext() && CustomElement::isValidName(localName)) {
         RefPtr<Element> element = document.registrationContext()->createCustomTagElement(document, QualifiedName(nullAtom, localName, {{namespace_prefix}}NamespaceURI));
         ASSERT_WITH_SECURITY_IMPLICATION(element->is{{namespace}}Element());
         return static_pointer_cast<{{namespace}}Element>(element.release());
     }
 
     return {{fallback_interface}}::create(QualifiedName(nullAtom, localName, {{namespace_prefix}}NamespaceURI), document);
 }
 
 } // namespace WebCore