/*
 * 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 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