View difference between Paste ID: GQU9FJJK and YPQvrCaP

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
  * distribution.
  *     * Neither the name of Google Inc. nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef HTMLElementTypeHelpers_h
 #define HTMLElementTypeHelpers_h
 
 #include "core/dom/ContextFeatures.h"
 #include "core/dom/Element.h"
 #include "HTMLNames.h"
 #include "RuntimeEnabledFeatures.h"
 
 namespace WebCore {
 // Type checking.
 
 class HTMLAnchorElement;
 void isHTMLAnchorElement(const HTMLAnchorElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLAnchorElement(const HTMLAnchorElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLAnchorElement(const Element& element) {
     return element.hasTagName(HTMLNames::aTag);
 }
 inline bool isHTMLAnchorElement(const Element* element) { ASSERT(element); return isHTMLAnchorElement(*element); }
 inline bool isHTMLAnchorElement(const Node& node) { return node.isElementNode() ? isHTMLAnchorElement(toElement(node)) : false; }
 inline bool isHTMLAnchorElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLAnchorElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLAnchorElement>(const Element& element) { return isHTMLAnchorElement(element); }
 
 class HTMLAreaElement;
 void isHTMLAreaElement(const HTMLAreaElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLAreaElement(const HTMLAreaElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLAreaElement(const Element& element) {
     return element.hasTagName(HTMLNames::areaTag);
 }
 inline bool isHTMLAreaElement(const Element* element) { ASSERT(element); return isHTMLAreaElement(*element); }
 inline bool isHTMLAreaElement(const Node& node) { return node.isElementNode() ? isHTMLAreaElement(toElement(node)) : false; }
 inline bool isHTMLAreaElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLAreaElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLAreaElement>(const Element& element) { return isHTMLAreaElement(element); }
 
 class HTMLAudioElement;
 void isHTMLAudioElement(const HTMLAudioElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLAudioElement(const HTMLAudioElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLAudioElement(const Element& element) {
     if (!RuntimeEnabledFeatures::mediaEnabled())
         return false;
     return element.hasTagName(HTMLNames::audioTag);
 }
 inline bool isHTMLAudioElement(const Element* element) { ASSERT(element); return isHTMLAudioElement(*element); }
 inline bool isHTMLAudioElement(const Node& node) { return node.isElementNode() ? isHTMLAudioElement(toElement(node)) : false; }
 inline bool isHTMLAudioElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLAudioElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLAudioElement>(const Element& element) { return isHTMLAudioElement(element); }
 
 class HTMLBRElement;
 void isHTMLBRElement(const HTMLBRElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLBRElement(const HTMLBRElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLBRElement(const Element& element) {
     return element.hasTagName(HTMLNames::brTag);
 }
 inline bool isHTMLBRElement(const Element* element) { ASSERT(element); return isHTMLBRElement(*element); }
 inline bool isHTMLBRElement(const Node& node) { return node.isElementNode() ? isHTMLBRElement(toElement(node)) : false; }
 inline bool isHTMLBRElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLBRElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLBRElement>(const Element& element) { return isHTMLBRElement(element); }
 
 class HTMLBaseElement;
 void isHTMLBaseElement(const HTMLBaseElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLBaseElement(const HTMLBaseElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLBaseElement(const Element& element) {
     return element.hasTagName(HTMLNames::baseTag);
 }
 inline bool isHTMLBaseElement(const Element* element) { ASSERT(element); return isHTMLBaseElement(*element); }
 inline bool isHTMLBaseElement(const Node& node) { return node.isElementNode() ? isHTMLBaseElement(toElement(node)) : false; }
 inline bool isHTMLBaseElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLBaseElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLBaseElement>(const Element& element) { return isHTMLBaseElement(element); }
 
 class HTMLBodyElement;
 void isHTMLBodyElement(const HTMLBodyElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLBodyElement(const HTMLBodyElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLBodyElement(const Element& element) {
     return element.hasTagName(HTMLNames::bodyTag);
 }
 inline bool isHTMLBodyElement(const Element* element) { ASSERT(element); return isHTMLBodyElement(*element); }
 inline bool isHTMLBodyElement(const Node& node) { return node.isElementNode() ? isHTMLBodyElement(toElement(node)) : false; }
 inline bool isHTMLBodyElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLBodyElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLBodyElement>(const Element& element) { return isHTMLBodyElement(element); }
 
 class HTMLCanvasElement;
 void isHTMLCanvasElement(const HTMLCanvasElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLCanvasElement(const HTMLCanvasElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLCanvasElement(const Element& element) {
     return element.hasTagName(HTMLNames::canvasTag);
 }
 inline bool isHTMLCanvasElement(const Element* element) { ASSERT(element); return isHTMLCanvasElement(*element); }
 inline bool isHTMLCanvasElement(const Node& node) { return node.isElementNode() ? isHTMLCanvasElement(toElement(node)) : false; }
 inline bool isHTMLCanvasElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLCanvasElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLCanvasElement>(const Element& element) { return isHTMLCanvasElement(element); }
 
 class HTMLContentElement;
 void isHTMLContentElement(const HTMLContentElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLContentElement(const HTMLContentElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLContentElement(const Element& element) {
     return element.hasTagName(HTMLNames::contentTag);
 }
 inline bool isHTMLContentElement(const Element* element) { ASSERT(element); return isHTMLContentElement(*element); }
 inline bool isHTMLContentElement(const Node& node) { return node.isElementNode() ? isHTMLContentElement(toElement(node)) : false; }
 inline bool isHTMLContentElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLContentElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLContentElement>(const Element& element) { return isHTMLContentElement(element); }
 
 class HTMLDListElement;
 void isHTMLDListElement(const HTMLDListElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLDListElement(const HTMLDListElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLDListElement(const Element& element) {
     return element.hasTagName(HTMLNames::dlTag);
 }
 inline bool isHTMLDListElement(const Element* element) { ASSERT(element); return isHTMLDListElement(*element); }
 inline bool isHTMLDListElement(const Node& node) { return node.isElementNode() ? isHTMLDListElement(toElement(node)) : false; }
 inline bool isHTMLDListElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLDListElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLDListElement>(const Element& element) { return isHTMLDListElement(element); }
 
 class HTMLDataListElement;
 void isHTMLDataListElement(const HTMLDataListElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLDataListElement(const HTMLDataListElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLDataListElement(const Element& element) {
     return element.hasTagName(HTMLNames::datalistTag);
 }
 inline bool isHTMLDataListElement(const Element* element) { ASSERT(element); return isHTMLDataListElement(*element); }
 inline bool isHTMLDataListElement(const Node& node) { return node.isElementNode() ? isHTMLDataListElement(toElement(node)) : false; }
 inline bool isHTMLDataListElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLDataListElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLDataListElement>(const Element& element) { return isHTMLDataListElement(element); }
 
 class HTMLDetailsElement;
 void isHTMLDetailsElement(const HTMLDetailsElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLDetailsElement(const HTMLDetailsElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLDetailsElement(const Element& element) {
     return element.hasTagName(HTMLNames::detailsTag);
 }
 inline bool isHTMLDetailsElement(const Element* element) { ASSERT(element); return isHTMLDetailsElement(*element); }
 inline bool isHTMLDetailsElement(const Node& node) { return node.isElementNode() ? isHTMLDetailsElement(toElement(node)) : false; }
 inline bool isHTMLDetailsElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLDetailsElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLDetailsElement>(const Element& element) { return isHTMLDetailsElement(element); }
 
 class HTMLDirectoryElement;
 void isHTMLDirectoryElement(const HTMLDirectoryElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLDirectoryElement(const HTMLDirectoryElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLDirectoryElement(const Element& element) {
     return element.hasTagName(HTMLNames::dirTag);
 }
 inline bool isHTMLDirectoryElement(const Element* element) { ASSERT(element); return isHTMLDirectoryElement(*element); }
 inline bool isHTMLDirectoryElement(const Node& node) { return node.isElementNode() ? isHTMLDirectoryElement(toElement(node)) : false; }
 inline bool isHTMLDirectoryElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLDirectoryElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLDirectoryElement>(const Element& element) { return isHTMLDirectoryElement(element); }
 
 class HTMLDivElement;
 void isHTMLDivElement(const HTMLDivElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLDivElement(const HTMLDivElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLDivElement(const Element& element) {
     return element.hasTagName(HTMLNames::divTag);
 }
 inline bool isHTMLDivElement(const Element* element) { ASSERT(element); return isHTMLDivElement(*element); }
 inline bool isHTMLDivElement(const Node& node) { return node.isElementNode() ? isHTMLDivElement(toElement(node)) : false; }
 inline bool isHTMLDivElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLDivElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLDivElement>(const Element& element) { return isHTMLDivElement(element); }
 
 class HTMLFontElement;
 void isHTMLFontElement(const HTMLFontElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLFontElement(const HTMLFontElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLFontElement(const Element& element) {
     return element.hasTagName(HTMLNames::fontTag);
 }
 inline bool isHTMLFontElement(const Element* element) { ASSERT(element); return isHTMLFontElement(*element); }
 inline bool isHTMLFontElement(const Node& node) { return node.isElementNode() ? isHTMLFontElement(toElement(node)) : false; }
 inline bool isHTMLFontElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLFontElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLFontElement>(const Element& element) { return isHTMLFontElement(element); }
 
 class HTMLFormElement;
 void isHTMLFormElement(const HTMLFormElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLFormElement(const HTMLFormElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLFormElement(const Element& element) {
     return element.hasTagName(HTMLNames::formTag);
 }
 inline bool isHTMLFormElement(const Element* element) { ASSERT(element); return isHTMLFormElement(*element); }
 inline bool isHTMLFormElement(const Node& node) { return node.isElementNode() ? isHTMLFormElement(toElement(node)) : false; }
 inline bool isHTMLFormElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLFormElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLFormElement>(const Element& element) { return isHTMLFormElement(element); }
 
 class HTMLFrameElement;
 void isHTMLFrameElement(const HTMLFrameElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLFrameElement(const HTMLFrameElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLFrameElement(const Element& element) {
     return element.hasTagName(HTMLNames::frameTag);
 }
 inline bool isHTMLFrameElement(const Element* element) { ASSERT(element); return isHTMLFrameElement(*element); }
 inline bool isHTMLFrameElement(const Node& node) { return node.isElementNode() ? isHTMLFrameElement(toElement(node)) : false; }
 inline bool isHTMLFrameElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLFrameElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLFrameElement>(const Element& element) { return isHTMLFrameElement(element); }
 
 class HTMLFrameSetElement;
 void isHTMLFrameSetElement(const HTMLFrameSetElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLFrameSetElement(const HTMLFrameSetElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLFrameSetElement(const Element& element) {
     return element.hasTagName(HTMLNames::framesetTag);
 }
 inline bool isHTMLFrameSetElement(const Element* element) { ASSERT(element); return isHTMLFrameSetElement(*element); }
 inline bool isHTMLFrameSetElement(const Node& node) { return node.isElementNode() ? isHTMLFrameSetElement(toElement(node)) : false; }
 inline bool isHTMLFrameSetElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLFrameSetElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLFrameSetElement>(const Element& element) { return isHTMLFrameSetElement(element); }
 
 class HTMLHRElement;
 void isHTMLHRElement(const HTMLHRElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLHRElement(const HTMLHRElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLHRElement(const Element& element) {
     return element.hasTagName(HTMLNames::hrTag);
 }
 inline bool isHTMLHRElement(const Element* element) { ASSERT(element); return isHTMLHRElement(*element); }
 inline bool isHTMLHRElement(const Node& node) { return node.isElementNode() ? isHTMLHRElement(toElement(node)) : false; }
 inline bool isHTMLHRElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLHRElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLHRElement>(const Element& element) { return isHTMLHRElement(element); }
 
 class HTMLHeadElement;
 void isHTMLHeadElement(const HTMLHeadElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLHeadElement(const HTMLHeadElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLHeadElement(const Element& element) {
     return element.hasTagName(HTMLNames::headTag);
 }
 inline bool isHTMLHeadElement(const Element* element) { ASSERT(element); return isHTMLHeadElement(*element); }
 inline bool isHTMLHeadElement(const Node& node) { return node.isElementNode() ? isHTMLHeadElement(toElement(node)) : false; }
 inline bool isHTMLHeadElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLHeadElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLHeadElement>(const Element& element) { return isHTMLHeadElement(element); }
 
 class HTMLHtmlElement;
 void isHTMLHtmlElement(const HTMLHtmlElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLHtmlElement(const HTMLHtmlElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLHtmlElement(const Element& element) {
     return element.hasTagName(HTMLNames::htmlTag);
 }
 inline bool isHTMLHtmlElement(const Element* element) { ASSERT(element); return isHTMLHtmlElement(*element); }
 inline bool isHTMLHtmlElement(const Node& node) { return node.isElementNode() ? isHTMLHtmlElement(toElement(node)) : false; }
 inline bool isHTMLHtmlElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLHtmlElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLHtmlElement>(const Element& element) { return isHTMLHtmlElement(element); }
 
 class HTMLIFrameElement;
 void isHTMLIFrameElement(const HTMLIFrameElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLIFrameElement(const HTMLIFrameElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLIFrameElement(const Element& element) {
     return element.hasTagName(HTMLNames::iframeTag);
 }
 inline bool isHTMLIFrameElement(const Element* element) { ASSERT(element); return isHTMLIFrameElement(*element); }
 inline bool isHTMLIFrameElement(const Node& node) { return node.isElementNode() ? isHTMLIFrameElement(toElement(node)) : false; }
 inline bool isHTMLIFrameElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLIFrameElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLIFrameElement>(const Element& element) { return isHTMLIFrameElement(element); }
 
 class HTMLLIElement;
 void isHTMLLIElement(const HTMLLIElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLLIElement(const HTMLLIElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLLIElement(const Element& element) {
     return element.hasTagName(HTMLNames::liTag);
 }
 inline bool isHTMLLIElement(const Element* element) { ASSERT(element); return isHTMLLIElement(*element); }
 inline bool isHTMLLIElement(const Node& node) { return node.isElementNode() ? isHTMLLIElement(toElement(node)) : false; }
 inline bool isHTMLLIElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLLIElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLLIElement>(const Element& element) { return isHTMLLIElement(element); }
 
 class HTMLLabelElement;
 void isHTMLLabelElement(const HTMLLabelElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLLabelElement(const HTMLLabelElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLLabelElement(const Element& element) {
     return element.hasTagName(HTMLNames::labelTag);
 }
 inline bool isHTMLLabelElement(const Element* element) { ASSERT(element); return isHTMLLabelElement(*element); }
 inline bool isHTMLLabelElement(const Node& node) { return node.isElementNode() ? isHTMLLabelElement(toElement(node)) : false; }
 inline bool isHTMLLabelElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLLabelElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLLabelElement>(const Element& element) { return isHTMLLabelElement(element); }
 
 class HTMLLegendElement;
 void isHTMLLegendElement(const HTMLLegendElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLLegendElement(const HTMLLegendElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLLegendElement(const Element& element) {
     return element.hasTagName(HTMLNames::legendTag);
 }
 inline bool isHTMLLegendElement(const Element* element) { ASSERT(element); return isHTMLLegendElement(*element); }
 inline bool isHTMLLegendElement(const Node& node) { return node.isElementNode() ? isHTMLLegendElement(toElement(node)) : false; }
 inline bool isHTMLLegendElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLLegendElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLLegendElement>(const Element& element) { return isHTMLLegendElement(element); }
 
 class HTMLMapElement;
 void isHTMLMapElement(const HTMLMapElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLMapElement(const HTMLMapElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLMapElement(const Element& element) {
     return element.hasTagName(HTMLNames::mapTag);
 }
 inline bool isHTMLMapElement(const Element* element) { ASSERT(element); return isHTMLMapElement(*element); }
 inline bool isHTMLMapElement(const Node& node) { return node.isElementNode() ? isHTMLMapElement(toElement(node)) : false; }
 inline bool isHTMLMapElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLMapElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLMapElement>(const Element& element) { return isHTMLMapElement(element); }
 
 class HTMLMarqueeElement;
 void isHTMLMarqueeElement(const HTMLMarqueeElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLMarqueeElement(const HTMLMarqueeElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLMarqueeElement(const Element& element) {
     return element.hasTagName(HTMLNames::marqueeTag);
 }
 inline bool isHTMLMarqueeElement(const Element* element) { ASSERT(element); return isHTMLMarqueeElement(*element); }
 inline bool isHTMLMarqueeElement(const Node& node) { return node.isElementNode() ? isHTMLMarqueeElement(toElement(node)) : false; }
 inline bool isHTMLMarqueeElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLMarqueeElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLMarqueeElement>(const Element& element) { return isHTMLMarqueeElement(element); }
 
 class HTMLMenuElement;
 void isHTMLMenuElement(const HTMLMenuElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLMenuElement(const HTMLMenuElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLMenuElement(const Element& element) {
     return element.hasTagName(HTMLNames::menuTag);
 }
 inline bool isHTMLMenuElement(const Element* element) { ASSERT(element); return isHTMLMenuElement(*element); }
 inline bool isHTMLMenuElement(const Node& node) { return node.isElementNode() ? isHTMLMenuElement(toElement(node)) : false; }
 inline bool isHTMLMenuElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLMenuElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLMenuElement>(const Element& element) { return isHTMLMenuElement(element); }
 
 class HTMLMetaElement;
 void isHTMLMetaElement(const HTMLMetaElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLMetaElement(const HTMLMetaElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLMetaElement(const Element& element) {
     return element.hasTagName(HTMLNames::metaTag);
 }
 inline bool isHTMLMetaElement(const Element* element) { ASSERT(element); return isHTMLMetaElement(*element); }
 inline bool isHTMLMetaElement(const Node& node) { return node.isElementNode() ? isHTMLMetaElement(toElement(node)) : false; }
 inline bool isHTMLMetaElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLMetaElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLMetaElement>(const Element& element) { return isHTMLMetaElement(element); }
 
 class HTMLMeterElement;
 void isHTMLMeterElement(const HTMLMeterElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLMeterElement(const HTMLMeterElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLMeterElement(const Element& element) {
     return element.hasTagName(HTMLNames::meterTag);
 }
 inline bool isHTMLMeterElement(const Element* element) { ASSERT(element); return isHTMLMeterElement(*element); }
 inline bool isHTMLMeterElement(const Node& node) { return node.isElementNode() ? isHTMLMeterElement(toElement(node)) : false; }
 inline bool isHTMLMeterElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLMeterElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLMeterElement>(const Element& element) { return isHTMLMeterElement(element); }
 
 class HTMLOListElement;
 void isHTMLOListElement(const HTMLOListElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLOListElement(const HTMLOListElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLOListElement(const Element& element) {
     return element.hasTagName(HTMLNames::olTag);
 }
 inline bool isHTMLOListElement(const Element* element) { ASSERT(element); return isHTMLOListElement(*element); }
 inline bool isHTMLOListElement(const Node& node) { return node.isElementNode() ? isHTMLOListElement(toElement(node)) : false; }
 inline bool isHTMLOListElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLOListElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLOListElement>(const Element& element) { return isHTMLOListElement(element); }
 
 class HTMLOptGroupElement;
 void isHTMLOptGroupElement(const HTMLOptGroupElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLOptGroupElement(const HTMLOptGroupElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLOptGroupElement(const Element& element) {
     return element.hasTagName(HTMLNames::optgroupTag);
 }
 inline bool isHTMLOptGroupElement(const Element* element) { ASSERT(element); return isHTMLOptGroupElement(*element); }
 inline bool isHTMLOptGroupElement(const Node& node) { return node.isElementNode() ? isHTMLOptGroupElement(toElement(node)) : false; }
 inline bool isHTMLOptGroupElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLOptGroupElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLOptGroupElement>(const Element& element) { return isHTMLOptGroupElement(element); }
 
 class HTMLOptionElement;
 void isHTMLOptionElement(const HTMLOptionElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLOptionElement(const HTMLOptionElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLOptionElement(const Element& element) {
     return element.hasTagName(HTMLNames::optionTag);
 }
 inline bool isHTMLOptionElement(const Element* element) { ASSERT(element); return isHTMLOptionElement(*element); }
 inline bool isHTMLOptionElement(const Node& node) { return node.isElementNode() ? isHTMLOptionElement(toElement(node)) : false; }
 inline bool isHTMLOptionElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLOptionElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLOptionElement>(const Element& element) { return isHTMLOptionElement(element); }
 
 class HTMLParagraphElement;
 void isHTMLParagraphElement(const HTMLParagraphElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLParagraphElement(const HTMLParagraphElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLParagraphElement(const Element& element) {
     return element.hasTagName(HTMLNames::pTag);
 }
 inline bool isHTMLParagraphElement(const Element* element) { ASSERT(element); return isHTMLParagraphElement(*element); }
 inline bool isHTMLParagraphElement(const Node& node) { return node.isElementNode() ? isHTMLParagraphElement(toElement(node)) : false; }
 inline bool isHTMLParagraphElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLParagraphElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLParagraphElement>(const Element& element) { return isHTMLParagraphElement(element); }
 
 class HTMLParamElement;
 void isHTMLParamElement(const HTMLParamElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLParamElement(const HTMLParamElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLParamElement(const Element& element) {
     return element.hasTagName(HTMLNames::paramTag);
 }
 inline bool isHTMLParamElement(const Element* element) { ASSERT(element); return isHTMLParamElement(*element); }
 inline bool isHTMLParamElement(const Node& node) { return node.isElementNode() ? isHTMLParamElement(toElement(node)) : false; }
 inline bool isHTMLParamElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLParamElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLParamElement>(const Element& element) { return isHTMLParamElement(element); }
 
 class HTMLProgressElement;
 void isHTMLProgressElement(const HTMLProgressElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLProgressElement(const HTMLProgressElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLProgressElement(const Element& element) {
     return element.hasTagName(HTMLNames::progressTag);
 }
 inline bool isHTMLProgressElement(const Element* element) { ASSERT(element); return isHTMLProgressElement(*element); }
 inline bool isHTMLProgressElement(const Node& node) { return node.isElementNode() ? isHTMLProgressElement(toElement(node)) : false; }
 inline bool isHTMLProgressElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLProgressElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLProgressElement>(const Element& element) { return isHTMLProgressElement(element); }
 
 class HTMLShadowElement;
 void isHTMLShadowElement(const HTMLShadowElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLShadowElement(const HTMLShadowElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLShadowElement(const Element& element) {
     return element.hasTagName(HTMLNames::shadowTag);
 }
 inline bool isHTMLShadowElement(const Element* element) { ASSERT(element); return isHTMLShadowElement(*element); }
 inline bool isHTMLShadowElement(const Node& node) { return node.isElementNode() ? isHTMLShadowElement(toElement(node)) : false; }
 inline bool isHTMLShadowElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLShadowElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLShadowElement>(const Element& element) { return isHTMLShadowElement(element); }
 
 class HTMLSourceElement;
 void isHTMLSourceElement(const HTMLSourceElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLSourceElement(const HTMLSourceElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLSourceElement(const Element& element) {
     if (!RuntimeEnabledFeatures::mediaEnabled())
         return false;
     return element.hasTagName(HTMLNames::sourceTag);
 }
 inline bool isHTMLSourceElement(const Element* element) { ASSERT(element); return isHTMLSourceElement(*element); }
 inline bool isHTMLSourceElement(const Node& node) { return node.isElementNode() ? isHTMLSourceElement(toElement(node)) : false; }
 inline bool isHTMLSourceElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLSourceElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLSourceElement>(const Element& element) { return isHTMLSourceElement(element); }
 
 class HTMLSpanElement;
 void isHTMLSpanElement(const HTMLSpanElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLSpanElement(const HTMLSpanElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLSpanElement(const Element& element) {
     return element.hasTagName(HTMLNames::spanTag);
 }
 inline bool isHTMLSpanElement(const Element* element) { ASSERT(element); return isHTMLSpanElement(*element); }
 inline bool isHTMLSpanElement(const Node& node) { return node.isElementNode() ? isHTMLSpanElement(toElement(node)) : false; }
 inline bool isHTMLSpanElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLSpanElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLSpanElement>(const Element& element) { return isHTMLSpanElement(element); }
 
 class HTMLTableCaptionElement;
 void isHTMLTableCaptionElement(const HTMLTableCaptionElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLTableCaptionElement(const HTMLTableCaptionElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLTableCaptionElement(const Element& element) {
     return element.hasTagName(HTMLNames::captionTag);
 }
 inline bool isHTMLTableCaptionElement(const Element* element) { ASSERT(element); return isHTMLTableCaptionElement(*element); }
 inline bool isHTMLTableCaptionElement(const Node& node) { return node.isElementNode() ? isHTMLTableCaptionElement(toElement(node)) : false; }
 inline bool isHTMLTableCaptionElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLTableCaptionElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLTableCaptionElement>(const Element& element) { return isHTMLTableCaptionElement(element); }
 
 class HTMLTableElement;
 void isHTMLTableElement(const HTMLTableElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLTableElement(const HTMLTableElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLTableElement(const Element& element) {
     return element.hasTagName(HTMLNames::tableTag);
 }
 inline bool isHTMLTableElement(const Element* element) { ASSERT(element); return isHTMLTableElement(*element); }
 inline bool isHTMLTableElement(const Node& node) { return node.isElementNode() ? isHTMLTableElement(toElement(node)) : false; }
 inline bool isHTMLTableElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLTableElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLTableElement>(const Element& element) { return isHTMLTableElement(element); }
 
 class HTMLTableRowElement;
 void isHTMLTableRowElement(const HTMLTableRowElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLTableRowElement(const HTMLTableRowElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLTableRowElement(const Element& element) {
     return element.hasTagName(HTMLNames::trTag);
 }
 inline bool isHTMLTableRowElement(const Element* element) { ASSERT(element); return isHTMLTableRowElement(*element); }
 inline bool isHTMLTableRowElement(const Node& node) { return node.isElementNode() ? isHTMLTableRowElement(toElement(node)) : false; }
 inline bool isHTMLTableRowElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLTableRowElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLTableRowElement>(const Element& element) { return isHTMLTableRowElement(element); }
 
 class HTMLTemplateElement;
 void isHTMLTemplateElement(const HTMLTemplateElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLTemplateElement(const HTMLTemplateElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLTemplateElement(const Element& element) {
     return element.hasTagName(HTMLNames::templateTag);
 }
 inline bool isHTMLTemplateElement(const Element* element) { ASSERT(element); return isHTMLTemplateElement(*element); }
 inline bool isHTMLTemplateElement(const Node& node) { return node.isElementNode() ? isHTMLTemplateElement(toElement(node)) : false; }
 inline bool isHTMLTemplateElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLTemplateElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLTemplateElement>(const Element& element) { return isHTMLTemplateElement(element); }
 
 class HTMLTitleElement;
 void isHTMLTitleElement(const HTMLTitleElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLTitleElement(const HTMLTitleElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLTitleElement(const Element& element) {
     return element.hasTagName(HTMLNames::titleTag);
 }
 inline bool isHTMLTitleElement(const Element* element) { ASSERT(element); return isHTMLTitleElement(*element); }
 inline bool isHTMLTitleElement(const Node& node) { return node.isElementNode() ? isHTMLTitleElement(toElement(node)) : false; }
 inline bool isHTMLTitleElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLTitleElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLTitleElement>(const Element& element) { return isHTMLTitleElement(element); }
 
 class HTMLTrackElement;
 void isHTMLTrackElement(const HTMLTrackElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLTrackElement(const HTMLTrackElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLTrackElement(const Element& element) {
     if (!RuntimeEnabledFeatures::videoTrackEnabled())
         return false;
     return element.hasTagName(HTMLNames::trackTag);
 }
 inline bool isHTMLTrackElement(const Element* element) { ASSERT(element); return isHTMLTrackElement(*element); }
 inline bool isHTMLTrackElement(const Node& node) { return node.isElementNode() ? isHTMLTrackElement(toElement(node)) : false; }
 inline bool isHTMLTrackElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLTrackElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLTrackElement>(const Element& element) { return isHTMLTrackElement(element); }
 
 class HTMLUListElement;
 void isHTMLUListElement(const HTMLUListElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLUListElement(const HTMLUListElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLUListElement(const Element& element) {
     return element.hasTagName(HTMLNames::ulTag);
 }
 inline bool isHTMLUListElement(const Element* element) { ASSERT(element); return isHTMLUListElement(*element); }
 inline bool isHTMLUListElement(const Node& node) { return node.isElementNode() ? isHTMLUListElement(toElement(node)) : false; }
 inline bool isHTMLUListElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLUListElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLUListElement>(const Element& element) { return isHTMLUListElement(element); }
 
 class HTMLVideoElement;
 void isHTMLVideoElement(const HTMLVideoElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLVideoElement(const HTMLVideoElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLVideoElement(const Element& element) {
     if (!RuntimeEnabledFeatures::mediaEnabled())
         return false;
     return element.hasTagName(HTMLNames::videoTag);
 }
 inline bool isHTMLVideoElement(const Element* element) { ASSERT(element); return isHTMLVideoElement(*element); }
 inline bool isHTMLVideoElement(const Node& node) { return node.isElementNode() ? isHTMLVideoElement(toElement(node)) : false; }
 inline bool isHTMLVideoElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLVideoElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLVideoElement>(const Element& element) { return isHTMLVideoElement(element); }
 
 class HTMLDialogElement;
 void isHTMLDialogElement(const HTMLDialogElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLDialogElement(const HTMLDialogElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLDialogElement(const Element& element) {
     if (!ContextFeatures::dialogElementEnabled(&element.document()))
         return false;
     return element.hasTagName(HTMLNames::dialogTag);
 }
 inline bool isHTMLDialogElement(const Element* element) { ASSERT(element); return isHTMLDialogElement(*element); }
 inline bool isHTMLDialogElement(const Node& node) { return node.isElementNode() ? isHTMLDialogElement(toElement(node)) : false; }
 inline bool isHTMLDialogElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLDialogElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLDialogElement>(const Element& element) { return isHTMLDialogElement(element); }
 
 class HTMLButtonElement;
 void isHTMLButtonElement(const HTMLButtonElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLButtonElement(const HTMLButtonElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLButtonElement(const Element& element) {
     return element.hasTagName(HTMLNames::buttonTag);
 }
 inline bool isHTMLButtonElement(const Element* element) { ASSERT(element); return isHTMLButtonElement(*element); }
 inline bool isHTMLButtonElement(const Node& node) { return node.isElementNode() ? isHTMLButtonElement(toElement(node)) : false; }
 inline bool isHTMLButtonElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLButtonElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLButtonElement>(const Element& element) { return isHTMLButtonElement(element); }
 
 class HTMLFieldSetElement;
 void isHTMLFieldSetElement(const HTMLFieldSetElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLFieldSetElement(const HTMLFieldSetElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLFieldSetElement(const Element& element) {
     return element.hasTagName(HTMLNames::fieldsetTag);
 }
 inline bool isHTMLFieldSetElement(const Element* element) { ASSERT(element); return isHTMLFieldSetElement(*element); }
 inline bool isHTMLFieldSetElement(const Node& node) { return node.isElementNode() ? isHTMLFieldSetElement(toElement(node)) : false; }
 inline bool isHTMLFieldSetElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLFieldSetElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLFieldSetElement>(const Element& element) { return isHTMLFieldSetElement(element); }
 
 class HTMLImageElement;
 void isHTMLImageElement(const HTMLImageElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLImageElement(const HTMLImageElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLImageElement(const Element& element) {
     return element.hasTagName(HTMLNames::imgTag);
 }
 inline bool isHTMLImageElement(const Element* element) { ASSERT(element); return isHTMLImageElement(*element); }
 inline bool isHTMLImageElement(const Node& node) { return node.isElementNode() ? isHTMLImageElement(toElement(node)) : false; }
 inline bool isHTMLImageElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLImageElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLImageElement>(const Element& element) { return isHTMLImageElement(element); }
 
 class HTMLKeygenElement;
 void isHTMLKeygenElement(const HTMLKeygenElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLKeygenElement(const HTMLKeygenElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLKeygenElement(const Element& element) {
     return element.hasTagName(HTMLNames::keygenTag);
 }
 inline bool isHTMLKeygenElement(const Element* element) { ASSERT(element); return isHTMLKeygenElement(*element); }
 inline bool isHTMLKeygenElement(const Node& node) { return node.isElementNode() ? isHTMLKeygenElement(toElement(node)) : false; }
 inline bool isHTMLKeygenElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLKeygenElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLKeygenElement>(const Element& element) { return isHTMLKeygenElement(element); }
 
 class HTMLOutputElement;
 void isHTMLOutputElement(const HTMLOutputElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLOutputElement(const HTMLOutputElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLOutputElement(const Element& element) {
     return element.hasTagName(HTMLNames::outputTag);
 }
 inline bool isHTMLOutputElement(const Element* element) { ASSERT(element); return isHTMLOutputElement(*element); }
 inline bool isHTMLOutputElement(const Node& node) { return node.isElementNode() ? isHTMLOutputElement(toElement(node)) : false; }
 inline bool isHTMLOutputElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLOutputElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLOutputElement>(const Element& element) { return isHTMLOutputElement(element); }
 
 class HTMLSelectElement;
 void isHTMLSelectElement(const HTMLSelectElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLSelectElement(const HTMLSelectElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLSelectElement(const Element& element) {
     return element.hasTagName(HTMLNames::selectTag);
 }
 inline bool isHTMLSelectElement(const Element* element) { ASSERT(element); return isHTMLSelectElement(*element); }
 inline bool isHTMLSelectElement(const Node& node) { return node.isElementNode() ? isHTMLSelectElement(toElement(node)) : false; }
 inline bool isHTMLSelectElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLSelectElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLSelectElement>(const Element& element) { return isHTMLSelectElement(element); }
 
 class HTMLTextAreaElement;
 void isHTMLTextAreaElement(const HTMLTextAreaElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLTextAreaElement(const HTMLTextAreaElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLTextAreaElement(const Element& element) {
     return element.hasTagName(HTMLNames::textareaTag);
 }
 inline bool isHTMLTextAreaElement(const Element* element) { ASSERT(element); return isHTMLTextAreaElement(*element); }
 inline bool isHTMLTextAreaElement(const Node& node) { return node.isElementNode() ? isHTMLTextAreaElement(toElement(node)) : false; }
 inline bool isHTMLTextAreaElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLTextAreaElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLTextAreaElement>(const Element& element) { return isHTMLTextAreaElement(element); }
 
 class HTMLAppletElement;
 void isHTMLAppletElement(const HTMLAppletElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLAppletElement(const HTMLAppletElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLAppletElement(const Element& element) {
     return element.hasTagName(HTMLNames::appletTag);
 }
 inline bool isHTMLAppletElement(const Element* element) { ASSERT(element); return isHTMLAppletElement(*element); }
 inline bool isHTMLAppletElement(const Node& node) { return node.isElementNode() ? isHTMLAppletElement(toElement(node)) : false; }
 inline bool isHTMLAppletElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLAppletElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLAppletElement>(const Element& element) { return isHTMLAppletElement(element); }
 
 class HTMLEmbedElement;
 void isHTMLEmbedElement(const HTMLEmbedElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLEmbedElement(const HTMLEmbedElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLEmbedElement(const Element& element) {
     return element.hasTagName(HTMLNames::embedTag);
 }
 inline bool isHTMLEmbedElement(const Element* element) { ASSERT(element); return isHTMLEmbedElement(*element); }
 inline bool isHTMLEmbedElement(const Node& node) { return node.isElementNode() ? isHTMLEmbedElement(toElement(node)) : false; }
 inline bool isHTMLEmbedElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLEmbedElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLEmbedElement>(const Element& element) { return isHTMLEmbedElement(element); }
 
 class HTMLLinkElement;
 void isHTMLLinkElement(const HTMLLinkElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLLinkElement(const HTMLLinkElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLLinkElement(const Element& element) {
     return element.hasTagName(HTMLNames::linkTag);
 }
 inline bool isHTMLLinkElement(const Element* element) { ASSERT(element); return isHTMLLinkElement(*element); }
 inline bool isHTMLLinkElement(const Node& node) { return node.isElementNode() ? isHTMLLinkElement(toElement(node)) : false; }
 inline bool isHTMLLinkElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLLinkElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLLinkElement>(const Element& element) { return isHTMLLinkElement(element); }
 
 class HTMLScriptElement;
 void isHTMLScriptElement(const HTMLScriptElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLScriptElement(const HTMLScriptElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLScriptElement(const Element& element) {
     return element.hasTagName(HTMLNames::scriptTag);
 }
 inline bool isHTMLScriptElement(const Element* element) { ASSERT(element); return isHTMLScriptElement(*element); }
 inline bool isHTMLScriptElement(const Node& node) { return node.isElementNode() ? isHTMLScriptElement(toElement(node)) : false; }
 inline bool isHTMLScriptElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLScriptElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLScriptElement>(const Element& element) { return isHTMLScriptElement(element); }
 
 class HTMLStyleElement;
 void isHTMLStyleElement(const HTMLStyleElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLStyleElement(const HTMLStyleElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLStyleElement(const Element& element) {
     return element.hasTagName(HTMLNames::styleTag);
 }
 inline bool isHTMLStyleElement(const Element* element) { ASSERT(element); return isHTMLStyleElement(*element); }
 inline bool isHTMLStyleElement(const Node& node) { return node.isElementNode() ? isHTMLStyleElement(toElement(node)) : false; }
 inline bool isHTMLStyleElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLStyleElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLStyleElement>(const Element& element) { return isHTMLStyleElement(element); }
 
 class HTMLInputElement;
 void isHTMLInputElement(const HTMLInputElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLInputElement(const HTMLInputElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLInputElement(const Element& element) {
     return element.hasTagName(HTMLNames::inputTag);
 }
 inline bool isHTMLInputElement(const Element* element) { ASSERT(element); return isHTMLInputElement(*element); }
 inline bool isHTMLInputElement(const Node& node) { return node.isElementNode() ? isHTMLInputElement(toElement(node)) : false; }
 inline bool isHTMLInputElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLInputElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLInputElement>(const Element& element) { return isHTMLInputElement(element); }
 
 class HTMLObjectElement;
 void isHTMLObjectElement(const HTMLObjectElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLObjectElement(const HTMLObjectElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLObjectElement(const Element& element) {
     return element.hasTagName(HTMLNames::objectTag);
 }
 inline bool isHTMLObjectElement(const Element* element) { ASSERT(element); return isHTMLObjectElement(*element); }
 inline bool isHTMLObjectElement(const Node& node) { return node.isElementNode() ? isHTMLObjectElement(toElement(node)) : false; }
 inline bool isHTMLObjectElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLObjectElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLObjectElement>(const Element& element) { return isHTMLObjectElement(element); }
 
 class HTMLBDIElement;
 void isHTMLBDIElement(const HTMLBDIElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLBDIElement(const HTMLBDIElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLBDIElement(const Element& element) {
     return element.hasTagName(HTMLNames::bdiTag);
 }
 inline bool isHTMLBDIElement(const Element* element) { ASSERT(element); return isHTMLBDIElement(*element); }
 inline bool isHTMLBDIElement(const Node& node) { return node.isElementNode() ? isHTMLBDIElement(toElement(node)) : false; }
 inline bool isHTMLBDIElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLBDIElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLBDIElement>(const Element& element) { return isHTMLBDIElement(element); }
 
 class HTMLNoEmbedElement;
 void isHTMLNoEmbedElement(const HTMLNoEmbedElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLNoEmbedElement(const HTMLNoEmbedElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLNoEmbedElement(const Element& element) {
     return element.hasTagName(HTMLNames::noembedTag);
 }
 inline bool isHTMLNoEmbedElement(const Element* element) { ASSERT(element); return isHTMLNoEmbedElement(*element); }
 inline bool isHTMLNoEmbedElement(const Node& node) { return node.isElementNode() ? isHTMLNoEmbedElement(toElement(node)) : false; }
 inline bool isHTMLNoEmbedElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLNoEmbedElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLNoEmbedElement>(const Element& element) { return isHTMLNoEmbedElement(element); }
 
 class HTMLNoScriptElement;
 void isHTMLNoScriptElement(const HTMLNoScriptElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLNoScriptElement(const HTMLNoScriptElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLNoScriptElement(const Element& element) {
     return element.hasTagName(HTMLNames::noscriptTag);
 }
 inline bool isHTMLNoScriptElement(const Element* element) { ASSERT(element); return isHTMLNoScriptElement(*element); }
 inline bool isHTMLNoScriptElement(const Node& node) { return node.isElementNode() ? isHTMLNoScriptElement(toElement(node)) : false; }
 inline bool isHTMLNoScriptElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLNoScriptElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLNoScriptElement>(const Element& element) { return isHTMLNoScriptElement(element); }
 
 class HTMLRTElement;
 void isHTMLRTElement(const HTMLRTElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLRTElement(const HTMLRTElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLRTElement(const Element& element) {
     return element.hasTagName(HTMLNames::rtTag);
 }
 inline bool isHTMLRTElement(const Element* element) { ASSERT(element); return isHTMLRTElement(*element); }
 inline bool isHTMLRTElement(const Node& node) { return node.isElementNode() ? isHTMLRTElement(toElement(node)) : false; }
 inline bool isHTMLRTElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLRTElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLRTElement>(const Element& element) { return isHTMLRTElement(element); }
 
 class HTMLRubyElement;
 void isHTMLRubyElement(const HTMLRubyElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLRubyElement(const HTMLRubyElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLRubyElement(const Element& element) {
     return element.hasTagName(HTMLNames::rubyTag);
 }
 inline bool isHTMLRubyElement(const Element* element) { ASSERT(element); return isHTMLRubyElement(*element); }
 inline bool isHTMLRubyElement(const Node& node) { return node.isElementNode() ? isHTMLRubyElement(toElement(node)) : false; }
 inline bool isHTMLRubyElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLRubyElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLRubyElement>(const Element& element) { return isHTMLRubyElement(element); }
 
 class HTMLSummaryElement;
 void isHTMLSummaryElement(const HTMLSummaryElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLSummaryElement(const HTMLSummaryElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLSummaryElement(const Element& element) {
     return element.hasTagName(HTMLNames::summaryTag);
 }
 inline bool isHTMLSummaryElement(const Element* element) { ASSERT(element); return isHTMLSummaryElement(*element); }
 inline bool isHTMLSummaryElement(const Node& node) { return node.isElementNode() ? isHTMLSummaryElement(toElement(node)) : false; }
 inline bool isHTMLSummaryElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLSummaryElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLSummaryElement>(const Element& element) { return isHTMLSummaryElement(element); }
 
 class HTMLWBRElement;
 void isHTMLWBRElement(const HTMLWBRElement&); // Catch unnecessary runtime check of type known at compile time.
 void isHTMLWBRElement(const HTMLWBRElement*); // Catch unnecessary runtime check of type known at compile time.
 inline bool isHTMLWBRElement(const Element& element) {
     return element.hasTagName(HTMLNames::wbrTag);
 }
 inline bool isHTMLWBRElement(const Element* element) { ASSERT(element); return isHTMLWBRElement(*element); }
 inline bool isHTMLWBRElement(const Node& node) { return node.isElementNode() ? isHTMLWBRElement(toElement(node)) : false; }
 inline bool isHTMLWBRElement(const Node* node) { ASSERT(node); return node->isElementNode() ? isHTMLWBRElement(*toElement(node)) : false; }
 template <> inline bool isElementOfType<const HTMLWBRElement>(const Element& element) { return isHTMLWBRElement(element); }
 
 // Type casting.
 template<typename T> inline T& toElement(Node& node)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(isElementOfType<const T>(node));
     return static_cast<T&>(node);
 }
 template<typename T> inline T* toElement(Node* node)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(!node || isElementOfType<const T>(*node));
     return static_cast<T*>(node);
 }
 template<typename T> inline const T& toElement(const Node& node)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(isElementOfType<const T>(node));
     return static_cast<const T&>(node);
 }
 template<typename T> inline const T* toElement(const Node* node)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(!node || isElementOfType<const T>(*node));
     return static_cast<const T*>(node);
 }
 template<typename T, typename U> inline T* toElement(const RefPtr<U>& node) { return toElement<T>(node.get()); }
 
-// Using macros because the types are forward-declared as we don't want to use reinterpret_cast in the
+// 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.
 
 #define toHTMLAnchorElement(x) WebCore::toElement<WebCore::HTMLAnchorElement>(x)
 
 #define toHTMLAreaElement(x) WebCore::toElement<WebCore::HTMLAreaElement>(x)
 
 #define toHTMLAudioElement(x) WebCore::toElement<WebCore::HTMLAudioElement>(x)
 
 #define toHTMLBRElement(x) WebCore::toElement<WebCore::HTMLBRElement>(x)
 
 #define toHTMLBaseElement(x) WebCore::toElement<WebCore::HTMLBaseElement>(x)
 
 #define toHTMLBodyElement(x) WebCore::toElement<WebCore::HTMLBodyElement>(x)
 
 #define toHTMLCanvasElement(x) WebCore::toElement<WebCore::HTMLCanvasElement>(x)
 
 #define toHTMLContentElement(x) WebCore::toElement<WebCore::HTMLContentElement>(x)
 
 #define toHTMLDListElement(x) WebCore::toElement<WebCore::HTMLDListElement>(x)
 
 #define toHTMLDataListElement(x) WebCore::toElement<WebCore::HTMLDataListElement>(x)
 
 #define toHTMLDetailsElement(x) WebCore::toElement<WebCore::HTMLDetailsElement>(x)
 
 #define toHTMLDirectoryElement(x) WebCore::toElement<WebCore::HTMLDirectoryElement>(x)
 
 #define toHTMLDivElement(x) WebCore::toElement<WebCore::HTMLDivElement>(x)
 
 #define toHTMLFontElement(x) WebCore::toElement<WebCore::HTMLFontElement>(x)
 
 #define toHTMLFormElement(x) WebCore::toElement<WebCore::HTMLFormElement>(x)
 
 #define toHTMLFrameElement(x) WebCore::toElement<WebCore::HTMLFrameElement>(x)
 
 #define toHTMLFrameSetElement(x) WebCore::toElement<WebCore::HTMLFrameSetElement>(x)
 
 #define toHTMLHRElement(x) WebCore::toElement<WebCore::HTMLHRElement>(x)
 
 #define toHTMLHeadElement(x) WebCore::toElement<WebCore::HTMLHeadElement>(x)
 
 #define toHTMLHtmlElement(x) WebCore::toElement<WebCore::HTMLHtmlElement>(x)
 
 #define toHTMLIFrameElement(x) WebCore::toElement<WebCore::HTMLIFrameElement>(x)
 
 #define toHTMLLIElement(x) WebCore::toElement<WebCore::HTMLLIElement>(x)
 
 #define toHTMLLabelElement(x) WebCore::toElement<WebCore::HTMLLabelElement>(x)
 
 #define toHTMLLegendElement(x) WebCore::toElement<WebCore::HTMLLegendElement>(x)
 
 #define toHTMLMapElement(x) WebCore::toElement<WebCore::HTMLMapElement>(x)
 
 #define toHTMLMarqueeElement(x) WebCore::toElement<WebCore::HTMLMarqueeElement>(x)
 
 #define toHTMLMenuElement(x) WebCore::toElement<WebCore::HTMLMenuElement>(x)
 
 #define toHTMLMetaElement(x) WebCore::toElement<WebCore::HTMLMetaElement>(x)
 
 #define toHTMLMeterElement(x) WebCore::toElement<WebCore::HTMLMeterElement>(x)
 
 #define toHTMLOListElement(x) WebCore::toElement<WebCore::HTMLOListElement>(x)
 
 #define toHTMLOptGroupElement(x) WebCore::toElement<WebCore::HTMLOptGroupElement>(x)
 
 #define toHTMLOptionElement(x) WebCore::toElement<WebCore::HTMLOptionElement>(x)
 
 #define toHTMLParagraphElement(x) WebCore::toElement<WebCore::HTMLParagraphElement>(x)
 
 #define toHTMLParamElement(x) WebCore::toElement<WebCore::HTMLParamElement>(x)
 
 #define toHTMLProgressElement(x) WebCore::toElement<WebCore::HTMLProgressElement>(x)
 
 #define toHTMLShadowElement(x) WebCore::toElement<WebCore::HTMLShadowElement>(x)
 
 #define toHTMLSourceElement(x) WebCore::toElement<WebCore::HTMLSourceElement>(x)
 
 #define toHTMLSpanElement(x) WebCore::toElement<WebCore::HTMLSpanElement>(x)
 
 #define toHTMLTableCaptionElement(x) WebCore::toElement<WebCore::HTMLTableCaptionElement>(x)
 
 #define toHTMLTableElement(x) WebCore::toElement<WebCore::HTMLTableElement>(x)
 
 #define toHTMLTableRowElement(x) WebCore::toElement<WebCore::HTMLTableRowElement>(x)
 
 #define toHTMLTemplateElement(x) WebCore::toElement<WebCore::HTMLTemplateElement>(x)
 
 #define toHTMLTitleElement(x) WebCore::toElement<WebCore::HTMLTitleElement>(x)
 
 #define toHTMLTrackElement(x) WebCore::toElement<WebCore::HTMLTrackElement>(x)
 
 #define toHTMLUListElement(x) WebCore::toElement<WebCore::HTMLUListElement>(x)
 
 #define toHTMLVideoElement(x) WebCore::toElement<WebCore::HTMLVideoElement>(x)
 
 #define toHTMLDialogElement(x) WebCore::toElement<WebCore::HTMLDialogElement>(x)
 
 #define toHTMLButtonElement(x) WebCore::toElement<WebCore::HTMLButtonElement>(x)
 
 #define toHTMLFieldSetElement(x) WebCore::toElement<WebCore::HTMLFieldSetElement>(x)
 
 #define toHTMLImageElement(x) WebCore::toElement<WebCore::HTMLImageElement>(x)
 
 #define toHTMLKeygenElement(x) WebCore::toElement<WebCore::HTMLKeygenElement>(x)
 
 #define toHTMLOutputElement(x) WebCore::toElement<WebCore::HTMLOutputElement>(x)
 
 #define toHTMLSelectElement(x) WebCore::toElement<WebCore::HTMLSelectElement>(x)
 
 #define toHTMLTextAreaElement(x) WebCore::toElement<WebCore::HTMLTextAreaElement>(x)
 
 #define toHTMLAppletElement(x) WebCore::toElement<WebCore::HTMLAppletElement>(x)
 
 #define toHTMLEmbedElement(x) WebCore::toElement<WebCore::HTMLEmbedElement>(x)
 
 #define toHTMLLinkElement(x) WebCore::toElement<WebCore::HTMLLinkElement>(x)
 
 #define toHTMLScriptElement(x) WebCore::toElement<WebCore::HTMLScriptElement>(x)
 
 #define toHTMLStyleElement(x) WebCore::toElement<WebCore::HTMLStyleElement>(x)
 
 #define toHTMLInputElement(x) WebCore::toElement<WebCore::HTMLInputElement>(x)
 
 #define toHTMLObjectElement(x) WebCore::toElement<WebCore::HTMLObjectElement>(x)
 
 #define toHTMLBDIElement(x) WebCore::toElement<WebCore::HTMLBDIElement>(x)
 
 #define toHTMLNoEmbedElement(x) WebCore::toElement<WebCore::HTMLNoEmbedElement>(x)
 
 #define toHTMLNoScriptElement(x) WebCore::toElement<WebCore::HTMLNoScriptElement>(x)
 
 #define toHTMLRTElement(x) WebCore::toElement<WebCore::HTMLRTElement>(x)
 
 #define toHTMLRubyElement(x) WebCore::toElement<WebCore::HTMLRubyElement>(x)
 
 #define toHTMLSummaryElement(x) WebCore::toElement<WebCore::HTMLSummaryElement>(x)
 
 #define toHTMLWBRElement(x) WebCore::toElement<WebCore::HTMLWBRElement>(x)
 
 } // WebCore
 
 #endif