Use new is*Element() helper functions in DOM code

Source/build/scripts/templates/ElementTypeHelpers.h.tmpl

 {% from "macros.tmpl" import license -%}
 {{ license() }}
 
 #ifndef {{namespace}}ElementTypeHelpers_h
 #define {{namespace}}ElementTypeHelpers_h
 
 #include "core/dom/ContextFeatures.h"
 #include "core/dom/Element.h"
 #include "{{namespace}}Names.h"
 #include "RuntimeEnabledFeatures.h"
 
 namespace WebCore {
 // Type checking.
 {% for tag in tags|sort if not tag.multipleTagNames and not tag.noTypeHelpers %}
 class {{tag.interface}};
 void is{{tag.interface}}(const {{tag.interface}}&); // Catch unnecessary runtime check of type known at compile time.
 void is{{tag.interface}}(const {{tag.interface}}*); // Catch unnecessary runtime check of type known at compile time.
 inline bool is{{tag.interface}}(const Element& element) {
 {%- if tag.contextConditional %}
     if (!ContextFeatures::{{tag.contextConditional}}Enabled(&element.document()))
         return false;
 {%- endif %}
 {%- if tag.runtimeEnabled %}
     if (!RuntimeEnabledFeatures::{{tag.runtimeEnabled}}Enabled())
         return false;
 {%- endif %}
     return element.hasTagName({{namespace}}Names::{{tag|symbol}}Tag);
 }
 inline bool is{{tag.interface}}(const Element* element) { return element && is{{tag.interface}}(*element); }
+template<typename T> inline bool is{{tag.interface}}(const RefPtr<T>& node) { return is{{tag.interface}}(node.get()); }

[adamk, 2014/03/10 18:23:24]

This seems possibly-dangerous, as passing a PassRefPtr into this method will
null it out (due to the RefPtr(PassRefPtr) implicit constructor), so the
conversion from

node->hasTagName(fooTag)

to

isHTMLFooElement(node)

will have a difference in behavior. I think you can make this safe at the cost
of an extra ref by using const PassRefPtr& as the type.

[Inactive, 2014/03/10 18:28:29]

You are right, I believe we had the exact same discussion on the Node comparison
operators. I actually importing this line from the
DEFINE_NODE_TYPE_CASTS_WITH_FUNCTION() macro without paying enough attention. I
will fix this here and in the Node macro and reupload.

 inline bool is{{tag.interface}}(const Node& node) { return node.isElementNode() ? is{{tag.interface}}(toElement(node)) : false; }
 inline bool is{{tag.interface}}(const Node* node) { return node && node->isElementNode() ? is{{tag.interface}}(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const {{tag.interface}}>(const Element& element) { return is{{tag.interface}}(element); }
 {% endfor %}
 
 // Using macros because the types are forward-declared and we don't want to use reinterpret_cast in the
 // casting functions above. reinterpret_cast would be unsafe due to multiple inheritence.
 {% for tag in tags|sort if not tag.multipleTagNames and not tag.noTypeHelpers %}
 #define to{{tag.interface}}(x) WebCore::toElement<WebCore::{{tag.interface}}>(x)
 {% endfor %}
 } // WebCore
 
 #endif