Add support in generate scripts to handle Conditional

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 17 matching lines @@
     {% if namespace == 'HTML' %}
     HTMLFormElement*,
     {% endif %}
     bool createdByParser);
 
 typedef HashMap<AtomicString, ConstructorFunction> FunctionMap;
 
 static FunctionMap* g_constructors = 0;
 
 {% for tag in tags|sort if not tag.noConstructor %}
+{% filter enable_conditional(tag.Conditional) %}
 static PassRefPtrWillBeRawPtr<{{namespace}}Element> {{tag|symbol}}Constructor(
     Document& document,
     {% if namespace == 'HTML' %}
     HTMLFormElement* formElement,
     {% endif %}
     bool createdByParser)
 {
     {% if tag.contextConditional %}
     if (!ContextFeatures::{{tag.contextConditional}}Enabled(&document))
         return {{fallback_interface}}::create({{tag|symbol}}Tag, document);
     {% endif %}
     {% if tag.runtimeEnabled %}
     if (!RuntimeEnabledFeatures::{{tag.runtimeEnabled}}Enabled())
         return {{fallback_interface}}::create({{tag|symbol}}Tag, document);
     {% 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 -%}
     );
 }
+{% endfilter %}
 {% endfor %}
 
 struct Create{{namespace}}FunctionMapData {
   const QualifiedName& tag;
   ConstructorFunction func;
 };
 
 static void create{{namespace}}FunctionMap()
 {
     ASSERT(!g_constructors);
     g_constructors = new FunctionMap;
     static const Create{{namespace}}FunctionMapData data[] = {

[Nils Barth (inactive), 2014/06/13 02:14:24]

One subtlety: this definition *fails to compile* on MSVC
(and is illegal per C++ standard) if there are no tags;
this is more likely now with conditionals.

It's probably worth adding a comment here that it will *fail* if empty.
(I assume this doesn't actually happen here and this template
isn't v. widely used.)

This issue comes up in the bindings generation code, since we have
automatically generated array declarations that may be empty and thus
must be omitted.

==Details==
Test needed as size 0 arrays definitions are not allowed per standard
(so objects have distinct addresses), which is enforced by MSVC.
8.5.1 Aggregates [dcl.init.aggr]
An array of unknown size initialized with a brace-enclosed
initializer-list containing n initializer-clauses, where n shall be
greater than zero, is defined as having n elements (8.3.4).

[maheshkk, 2014/06/13 20:03:16]

That's a good point. I have added comment for now and FIXME to handle the
condition when there are no tags present. 

     {% for tag in tags|sort if not tag.noConstructor %}
+    {% filter enable_conditional(tag.Conditional) %}
         { {{tag|symbol}}Tag, {{tag|symbol}}Constructor },
+    {% endfilter %}
     {% endfor %}
     };
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(data); i++)
         g_constructors->set(data[i].tag.localName(), data[i].func);
 }
 
 PassRefPtrWillBeRawPtr<{{namespace}}Element> {{namespace}}ElementFactory::create{{namespace}}Element(
     const AtomicString& localName,
     Document& document,
     {% if namespace == 'HTML' %}
     HTMLFormElement* formElement,
     {% endif %}
     bool createdByParser)
 {
     if (!g_constructors)
         create{{namespace}}FunctionMap();
     if (ConstructorFunction function = g_constructors->get(localName))
         return function(document, {% if namespace == 'HTML' %}formElement, {% endif %}createdByParser);
 
     if (document.registrationContext() && CustomElement::isValidName(localName)) {
         RefPtrWillBeRawPtr<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