Changeset 154481 in webkit


Ignore:
Timestamp:
Aug 23, 2013 5:40:49 AM (11 years ago)
Author:
Antti Koivisto
Message:

<https://webkit.org/b/120166> Add Traversal<ElementType> template

Reviewed by Andreas Kling.

It is common to traverse through a subtree looking for elements of specific type and then casting to the type. This pattern can be generalized.

This patch adds a new Traversal<typename ElementType> template. It works like ElementTraversal except that the traversal is limited to the specified type.
The patch also uses the template in a bunch of applicable places.

  • WebCore.exp.in:
  • accessibility/AccessibilityRenderObject.cpp:

(WebCore::AccessibilityRenderObject::addImageMapChildren):

  • dom/Document.cpp:

(WebCore::Document::removeTitle):
(WebCore::Document::updateBaseURL):
(WebCore::Document::processBaseElement):

  • dom/Element.h:
  • dom/ElementTraversal.h:

(WebCore::::firstChildTemplate):
(WebCore::::firstWithinTemplate):
(WebCore::::lastChildTemplate):
(WebCore::::lastWithinTemplate):
(WebCore::::nextTemplate):
(WebCore::::previousTemplate):
(WebCore::::nextSiblingTemplate):
(WebCore::::previousSiblingTemplate):
(WebCore::::nextSkippingChildrenTemplate):
(WebCore::::firstChild):
(WebCore::::lastChild):
(WebCore::::firstWithin):
(WebCore::::lastWithin):
(WebCore::::next):
(WebCore::::previous):
(WebCore::::nextSibling):
(WebCore::::previousSibling):
(WebCore::::nextSkippingChildren):
(WebCore::ElementTraversal::previousIncludingPseudo):
(WebCore::ElementTraversal::nextIncludingPseudo):
(WebCore::ElementTraversal::nextIncludingPseudoSkippingChildren):
(WebCore::ElementTraversal::pseudoAwarePreviousSibling):

  • dom/Node.cpp:

(WebCore::Node::numberOfScopedHTMLStyleChildren):

  • dom/NodeIterator.cpp:

(WebCore::NodeIterator::NodeIterator):

  • dom/NodeIterator.h:
  • dom/Traversal.cpp:

(WebCore::NodeIteratorBase::NodeIteratorBase):
(WebCore::NodeIteratorBase::acceptNode):

  • dom/Traversal.h:


Renamed existing class called Traversal to less generic NodeIteratorBase.

  • dom/TreeScope.cpp:

(WebCore::TreeScope::labelElementForId):
(WebCore::TreeScope::findAnchor):

  • dom/TreeWalker.cpp:

(WebCore::TreeWalker::TreeWalker):

  • dom/TreeWalker.h:
  • editing/FrameSelection.cpp:

(WebCore::scanForForm):

  • editing/markup.cpp:

(WebCore::createContextualFragment):

  • html/HTMLAnchorElement.h:

(WebCore::isHTMLAnchorElement):
(WebCore::HTMLAnchorElement):

  • html/HTMLAreaElement.h:

(WebCore::isHTMLAreaElement):
(WebCore::HTMLAreaElement):

  • html/HTMLBaseElement.h:

(WebCore::isHTMLBaseElement):
(WebCore::HTMLBaseElement):

  • html/HTMLElement.h:

(WebCore::HTMLElement):

  • html/HTMLFieldSetElement.cpp:

(WebCore::HTMLFieldSetElement::invalidateDisabledStateUnder):
(WebCore::HTMLFieldSetElement::childrenChanged):
(WebCore::HTMLFieldSetElement::legend):

  • html/HTMLFormControlElement.h:

(WebCore::toHTMLFormControlElement):
(WebCore::HTMLFormControlElement):

  • html/HTMLLabelElement.cpp:

(WebCore::nodeAsSupportedLabelableElement):
(WebCore::HTMLLabelElement::control):

  • html/HTMLLabelElement.h:

(WebCore::isHTMLLabelElement):
(WebCore::HTMLLabelElement):

  • html/HTMLLegendElement.h:

(WebCore::isHTMLLegendElement):
(WebCore::HTMLLegendElement):

  • html/HTMLMapElement.cpp:

(WebCore::HTMLMapElement::mapMouseEvent):

  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::finishParsingChildren):

  • html/HTMLStyleElement.h:

(WebCore::isHTMLStyleElement):
(WebCore::HTMLStyleElement):

  • html/HTMLTitleElement.h:

(WebCore::HTMLTitleElement):

  • html/HTMLTrackElement.h:

(WebCore::isHTMLTrackElement):
(WebCore::HTMLTrackElement):

  • html/LabelableElement.h:

(WebCore::isLabelableElement):
(WebCore::LabelableElement):

  • rendering/FilterEffectRenderer.cpp:

(WebCore::FilterEffectRenderer::buildReferenceFilter):

  • svg/SVGElement.h:

(WebCore::SVGElement):

  • svg/SVGForeignObjectElement.h:

(WebCore::isSVGForeignObjectElement):
(WebCore::SVGForeignObjectElement):

  • svg/SVGSVGElement.cpp:

(WebCore::SVGSVGElement::collectIntersectionOrEnclosureList):
(WebCore::SVGSVGElement::getElementById):

  • svg/SVGStyledElement.cpp:

(WebCore::SVGStyledElement::title):

  • svg/SVGTitleElement.h:

(WebCore::SVGTitleElement):

  • svg/animation/SMILTimeContainer.cpp:

(WebCore::SMILTimeContainer::updateDocumentOrderIndexes):

  • svg/animation/SVGSMILElement.cpp:

(WebCore::SVGSMILElement::isSMILElement):

  • svg/animation/SVGSMILElement.h:

(WebCore::SVGSMILElement):

  • svg/graphics/SVGImage.cpp:

(WebCore::SVGImage::hasSingleSecurityOrigin):

Location:
trunk/Source/WebCore
Files:
41 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r154479 r154481  
     12013-08-23  Antti Koivisto  <antti@apple.com>
     2
     3        <https://webkit.org/b/120166> Add Traversal<ElementType> template
     4
     5        Reviewed by Andreas Kling.
     6
     7        It is common to traverse through a subtree looking for elements of specific type and then casting to the type. This pattern can be generalized.
     8       
     9        This patch adds a new Traversal<typename ElementType> template. It works like ElementTraversal except that the traversal is limited to the specified type.
     10        The patch also uses the template in a bunch of applicable places.
     11
     12        * WebCore.exp.in:
     13        * accessibility/AccessibilityRenderObject.cpp:
     14        (WebCore::AccessibilityRenderObject::addImageMapChildren):
     15        * dom/Document.cpp:
     16        (WebCore::Document::removeTitle):
     17        (WebCore::Document::updateBaseURL):
     18        (WebCore::Document::processBaseElement):
     19        * dom/Element.h:
     20        * dom/ElementTraversal.h:
     21        (WebCore::::firstChildTemplate):
     22        (WebCore::::firstWithinTemplate):
     23        (WebCore::::lastChildTemplate):
     24        (WebCore::::lastWithinTemplate):
     25        (WebCore::::nextTemplate):
     26        (WebCore::::previousTemplate):
     27        (WebCore::::nextSiblingTemplate):
     28        (WebCore::::previousSiblingTemplate):
     29        (WebCore::::nextSkippingChildrenTemplate):
     30        (WebCore::::firstChild):
     31        (WebCore::::lastChild):
     32        (WebCore::::firstWithin):
     33        (WebCore::::lastWithin):
     34        (WebCore::::next):
     35        (WebCore::::previous):
     36        (WebCore::::nextSibling):
     37        (WebCore::::previousSibling):
     38        (WebCore::::nextSkippingChildren):
     39        (WebCore::ElementTraversal::previousIncludingPseudo):
     40        (WebCore::ElementTraversal::nextIncludingPseudo):
     41        (WebCore::ElementTraversal::nextIncludingPseudoSkippingChildren):
     42        (WebCore::ElementTraversal::pseudoAwarePreviousSibling):
     43        * dom/Node.cpp:
     44        (WebCore::Node::numberOfScopedHTMLStyleChildren):
     45        * dom/NodeIterator.cpp:
     46        (WebCore::NodeIterator::NodeIterator):
     47        * dom/NodeIterator.h:
     48        * dom/Traversal.cpp:
     49        (WebCore::NodeIteratorBase::NodeIteratorBase):
     50        (WebCore::NodeIteratorBase::acceptNode):
     51        * dom/Traversal.h:
     52       
     53            Renamed existing class called Traversal to less generic NodeIteratorBase.
     54
     55        * dom/TreeScope.cpp:
     56        (WebCore::TreeScope::labelElementForId):
     57        (WebCore::TreeScope::findAnchor):
     58        * dom/TreeWalker.cpp:
     59        (WebCore::TreeWalker::TreeWalker):
     60        * dom/TreeWalker.h:
     61        * editing/FrameSelection.cpp:
     62        (WebCore::scanForForm):
     63        * editing/markup.cpp:
     64        (WebCore::createContextualFragment):
     65        * html/HTMLAnchorElement.h:
     66        (WebCore::isHTMLAnchorElement):
     67        (WebCore::HTMLAnchorElement):
     68        * html/HTMLAreaElement.h:
     69        (WebCore::isHTMLAreaElement):
     70        (WebCore::HTMLAreaElement):
     71        * html/HTMLBaseElement.h:
     72        (WebCore::isHTMLBaseElement):
     73        (WebCore::HTMLBaseElement):
     74        * html/HTMLElement.h:
     75        (WebCore::HTMLElement):
     76        * html/HTMLFieldSetElement.cpp:
     77        (WebCore::HTMLFieldSetElement::invalidateDisabledStateUnder):
     78        (WebCore::HTMLFieldSetElement::childrenChanged):
     79        (WebCore::HTMLFieldSetElement::legend):
     80        * html/HTMLFormControlElement.h:
     81        (WebCore::toHTMLFormControlElement):
     82        (WebCore::HTMLFormControlElement):
     83        * html/HTMLLabelElement.cpp:
     84        (WebCore::nodeAsSupportedLabelableElement):
     85        (WebCore::HTMLLabelElement::control):
     86        * html/HTMLLabelElement.h:
     87        (WebCore::isHTMLLabelElement):
     88        (WebCore::HTMLLabelElement):
     89        * html/HTMLLegendElement.h:
     90        (WebCore::isHTMLLegendElement):
     91        (WebCore::HTMLLegendElement):
     92        * html/HTMLMapElement.cpp:
     93        (WebCore::HTMLMapElement::mapMouseEvent):
     94        * html/HTMLMediaElement.cpp:
     95        (WebCore::HTMLMediaElement::finishParsingChildren):
     96        * html/HTMLStyleElement.h:
     97        (WebCore::isHTMLStyleElement):
     98        (WebCore::HTMLStyleElement):
     99        * html/HTMLTitleElement.h:
     100        (WebCore::HTMLTitleElement):
     101        * html/HTMLTrackElement.h:
     102        (WebCore::isHTMLTrackElement):
     103        (WebCore::HTMLTrackElement):
     104        * html/LabelableElement.h:
     105        (WebCore::isLabelableElement):
     106        (WebCore::LabelableElement):
     107        * rendering/FilterEffectRenderer.cpp:
     108        (WebCore::FilterEffectRenderer::buildReferenceFilter):
     109        * svg/SVGElement.h:
     110        (WebCore::SVGElement):
     111        * svg/SVGForeignObjectElement.h:
     112        (WebCore::isSVGForeignObjectElement):
     113        (WebCore::SVGForeignObjectElement):
     114        * svg/SVGSVGElement.cpp:
     115        (WebCore::SVGSVGElement::collectIntersectionOrEnclosureList):
     116        (WebCore::SVGSVGElement::getElementById):
     117        * svg/SVGStyledElement.cpp:
     118        (WebCore::SVGStyledElement::title):
     119        * svg/SVGTitleElement.h:
     120        (WebCore::SVGTitleElement):
     121        * svg/animation/SMILTimeContainer.cpp:
     122        (WebCore::SMILTimeContainer::updateDocumentOrderIndexes):
     123        * svg/animation/SVGSMILElement.cpp:
     124        (WebCore::SVGSMILElement::isSMILElement):
     125        * svg/animation/SVGSMILElement.h:
     126        (WebCore::SVGSMILElement):
     127        * svg/graphics/SVGImage.cpp:
     128        (WebCore::SVGImage::hasSingleSecurityOrigin):
     129
    11302013-08-23  Arpita Bahuguna  <a.bah@samsung.com>
    2131
  • trunk/Source/WebCore/WebCore.exp.in

    r154470 r154481  
    26952695
    26962696#if ENABLE(SVG)
    2697 __ZN7WebCore14SVGSMILElement13isSMILElementEPNS_4NodeE
    26982697__ZN7WebCore8Document13svgExtensionsEv
    26992698__ZN7WebCore8Document19accessSVGExtensionsEv
  • trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp

    r154343 r154481  
    27542754        return;
    27552755
    2756     for (Element* current = ElementTraversal::firstWithin(map); current; current = ElementTraversal::next(current, map)) {
     2756    for (HTMLAreaElement* current = Traversal<HTMLAreaElement>::firstWithin(map); current; current = Traversal<HTMLAreaElement>::next(current, map)) {
    27572757        // add an <area> element for this child if it has a link
    2758         if (isHTMLAreaElement(current) && current->isLink()) {
     2758        if (current->isLink()) {
    27592759            AccessibilityImageMapLink* areaObject = static_cast<AccessibilityImageMapLink*>(axObjectCache()->getOrCreate(ImageMapLinkRole));
    27602760            areaObject->setHTMLAreaElement(toHTMLAreaElement(current));
  • trunk/Source/WebCore/dom/Document.cpp

    r154449 r154481  
    7979#include "HTMLAllCollection.h"
    8080#include "HTMLAnchorElement.h"
     81#include "HTMLBaseElement.h"
    8182#include "HTMLCanvasElement.h"
    8283#include "HTMLCollection.h"
     
    15601561    // Update title based on first title element in the head, if one exists.
    15611562    if (HTMLElement* headElement = head()) {
    1562         for (Element* element = ElementTraversal::firstWithin(headElement); element; element = ElementTraversal::nextSibling(element)) {
    1563             if (isHTMLTitleElement(element)) {
    1564                 HTMLTitleElement* titleElement = toHTMLTitleElement(element);
    1565                 setTitleElement(titleElement->textWithDirection(), titleElement);
    1566                 break;
    1567             }
    1568         }
     1563        if (HTMLTitleElement* titleElement = Traversal<HTMLTitleElement>::firstWithin(headElement))
     1564            setTitleElement(titleElement->textWithDirection(), titleElement);
    15691565    }
    15701566
     
    26142610        // Base URL change changes any relative visited links.
    26152611        // FIXME: There are other URLs in the tree that would need to be re-evaluated on dynamic base URL change. Style should be invalidated too.
    2616         for (Element* element = ElementTraversal::firstWithin(this); element; element = ElementTraversal::next(element)) {
    2617             if (isHTMLAnchorElement(element))
    2618                 toHTMLAnchorElement(element)->invalidateCachedVisitedLinkHash();
    2619         }
     2612        for (HTMLAnchorElement* anchor = Traversal<HTMLAnchorElement>::firstWithin(this); anchor; anchor = Traversal<HTMLAnchorElement>::next(anchor))
     2613            anchor->invalidateCachedVisitedLinkHash();
    26202614    }
    26212615}
     
    26322626    const AtomicString* href = 0;
    26332627    const AtomicString* target = 0;
    2634     for (Element* element = ElementTraversal::firstWithin(this); element && (!href || !target); element = ElementTraversal::next(element)) {
    2635         if (element->hasTagName(baseTag)) {
    2636             if (!href) {
    2637                 const AtomicString& value = element->fastGetAttribute(hrefAttr);
    2638                 if (!value.isNull())
    2639                     href = &value;
    2640             }
    2641             if (!target) {
    2642                 const AtomicString& value = element->fastGetAttribute(targetAttr);
    2643                 if (!value.isNull())
    2644                     target = &value;
    2645             }
     2628    for (HTMLBaseElement* base = Traversal<HTMLBaseElement>::firstWithin(this); base && (!href || !target); base = Traversal<HTMLBaseElement>::next(base)) {
     2629        if (!href) {
     2630            const AtomicString& value = base->fastGetAttribute(hrefAttr);
     2631            if (!value.isNull())
     2632                href = &value;
     2633        }
     2634        if (!target) {
     2635            const AtomicString& value = base->fastGetAttribute(targetAttr);
     2636            if (!value.isNull())
     2637                target = &value;
    26462638        }
    26472639    }
  • trunk/Source/WebCore/dom/Element.h

    r154371 r154481  
    693693void toElement(const Element*);
    694694
     695template <typename Type> bool isElementOfType(const Element*);
     696template <typename Type> bool isElementOfType(const Node* node) { return node->isElementNode() && isElementOfType<Type>(toElement(node)); }
     697template <> inline bool isElementOfType<Element>(const Element*) { return true; }
     698
    695699inline bool isDisabledFormControl(const Node* node)
    696700{
  • trunk/Source/WebCore/dom/ElementTraversal.h

    r153942 r154481  
    3030
    3131namespace WebCore {
    32 namespace ElementTraversal {
    33 
    34 // First or last element child of the node.
    35 Element* firstWithin(const Node*);
    36 Element* firstWithin(const ContainerNode*);
    37 Element* lastWithin(const Node*);
    38 Element* lastWithin(const ContainerNode*);
    39 
    40 // Pre-order traversal skipping non-element nodes.
    41 Element* next(const Node*);
    42 Element* next(const Node*, const Node* stayWithin);
    43 Element* next(const ContainerNode*);
    44 Element* next(const ContainerNode*, const Node* stayWithin);
    45 
    46 // Next or previous Element sibling if there is one.
    47 Element* nextSibling(const Node*);
    48 Element* nextSibling(const ContainerNode*);
    49 Element* previousSibling(const Node*);
    50 Element* previousSibling(const ContainerNode*);
    51 
    52 // Like next, but skips children.
    53 Element* nextSkippingChildren(const Node*);
    54 Element* nextSkippingChildren(const Node*, const Node* stayWithin);
    55 Element* nextSkippingChildren(const ContainerNode*);
    56 Element* nextSkippingChildren(const ContainerNode*, const Node* stayWithin);
    57 
    58 // Pre-order traversal including the pseudo-elements.
    59 Element* previousIncludingPseudo(const Node*, const Node* = 0);
    60 Element* nextIncludingPseudo(const Node*, const Node* = 0);
    61 Element* nextIncludingPseudoSkippingChildren(const Node*, const Node* = 0);
    62 
    63 // Utility function to traverse only the element and pseudo-element siblings of a node.
    64 Element* pseudoAwarePreviousSibling(const Node*);
    65 
    66 }
    67 
    68 namespace ElementTraversal {
    69 
    70 template <class NodeType>
    71 inline Element* firstElementWithinTemplate(NodeType* current)
    72 {
    73     // Except for the root containers, only elements can have element children.
     32
     33template <typename ElementType>
     34class Traversal {
     35public:
     36    // First or last ElementType child of the node.
     37    static ElementType* firstChild(const Node*);
     38    static ElementType* firstChild(const ContainerNode*);
     39    static ElementType* lastChild(const Node*);
     40    static ElementType* lastChild(const ContainerNode*);
     41
     42    // First or last ElementType descendant of the node. For Elements this is always the same as first/last child.
     43    static ElementType* firstWithin(const Node*);
     44    static ElementType* firstWithin(const ContainerNode*);
     45    static ElementType* lastWithin(const Node*);
     46    static ElementType* lastWithin(const ContainerNode*);
     47
     48    // Pre-order traversal skipping non-ElementType nodes.
     49    static ElementType* next(const Node*);
     50    static ElementType* next(const Node*, const Node* stayWithin);
     51    static ElementType* next(const ContainerNode*);
     52    static ElementType* next(const ContainerNode*, const Node* stayWithin);
     53    static ElementType* previous(const Node*);
     54    static ElementType* previous(const Node*, const Node* stayWithin);
     55    static ElementType* previous(const ContainerNode*);
     56    static ElementType* previous(const ContainerNode*, const Node* stayWithin);
     57
     58    // Next or previous ElementType sibling if there is one.
     59    static ElementType* nextSibling(const Node*);
     60    static ElementType* nextSibling(const ContainerNode*);
     61    static ElementType* previousSibling(const Node*);
     62    static ElementType* previousSibling(const ContainerNode*);
     63
     64    // Like next, but skips children.
     65    static ElementType* nextSkippingChildren(const Node*);
     66    static ElementType* nextSkippingChildren(const Node*, const Node* stayWithin);
     67    static ElementType* nextSkippingChildren(const ContainerNode*);
     68    static ElementType* nextSkippingChildren(const ContainerNode*, const Node* stayWithin);
     69
     70private:
     71    template <typename CurrentType> static ElementType* firstChildTemplate(CurrentType*);
     72    template <typename CurrentType> static ElementType* lastChildTemplate(CurrentType*);
     73    template <typename CurrentType> static ElementType* firstWithinTemplate(CurrentType*);
     74    template <typename CurrentType> static ElementType* lastWithinTemplate(CurrentType*);
     75    template <typename CurrentType> static ElementType* nextTemplate(CurrentType*);
     76    template <typename CurrentType> static ElementType* nextTemplate(CurrentType*, const Node* stayWithin);
     77    template <typename CurrentType> static ElementType* previousTemplate(CurrentType*);
     78    template <typename CurrentType> static ElementType* previousTemplate(CurrentType*, const Node* stayWithin);
     79    template <typename CurrentType> static ElementType* nextSiblingTemplate(CurrentType*);
     80    template <typename CurrentType> static ElementType* previousSiblingTemplate(CurrentType*);
     81    template <typename CurrentType> static ElementType* nextSkippingChildrenTemplate(CurrentType*);
     82    template <typename CurrentType> static ElementType* nextSkippingChildrenTemplate(CurrentType*, const Node* stayWithin);
     83};
     84
     85class ElementTraversal : public Traversal<Element> {
     86public:
     87    // FIXME: These should go somewhere else.
     88    // Pre-order traversal including the pseudo-elements.
     89    static Element* previousIncludingPseudo(const Node*, const Node* = 0);
     90    static Element* nextIncludingPseudo(const Node*, const Node* = 0);
     91    static Element* nextIncludingPseudoSkippingChildren(const Node*, const Node* = 0);
     92
     93    // Utility function to traverse only the element and pseudo-element siblings of a node.
     94    static Element* pseudoAwarePreviousSibling(const Node*);
     95};
     96
     97// Specialized for pure Element to exploit the fact that Elements parent is always either another Element or the root.
     98template <>
     99template <typename CurrentType>
     100inline Element* Traversal<Element>::firstWithinTemplate(CurrentType* current)
     101{
     102    return firstChildTemplate(current);
     103}
     104
     105template <>
     106template <typename CurrentType>
     107inline Element* Traversal<Element>::lastWithinTemplate(CurrentType* current)
     108{
     109    return lastChildTemplate(current);
     110}
     111
     112template <>
     113template <typename CurrentType>
     114inline Element* Traversal<Element>::nextTemplate(CurrentType* current)
     115{
     116    Node* node = NodeTraversal::next(current);
     117    while (node && !node->isElementNode())
     118        node = NodeTraversal::nextSkippingChildren(node);
     119    return static_cast<Element*>(node);
     120}
     121
     122template <>
     123template <typename CurrentType>
     124inline Element* Traversal<Element>::nextTemplate(CurrentType* current, const Node* stayWithin)
     125{
     126    Node* node = NodeTraversal::next(current, stayWithin);
     127    while (node && !node->isElementNode())
     128        node = NodeTraversal::nextSkippingChildren(node, stayWithin);
     129    return static_cast<Element*>(node);
     130}
     131
     132template <>
     133template <typename CurrentType>
     134inline Element* Traversal<Element>::previousTemplate(CurrentType* current)
     135{
     136    Node* node = NodeTraversal::previous(current);
     137    while (node && !node->isElementNode())
     138        node = NodeTraversal::previousSkippingChildren(node);
     139    return static_cast<Element*>(node);
     140}
     141
     142template <>
     143template <typename CurrentType>
     144inline Element* Traversal<Element>::previousTemplate(CurrentType* current, const Node* stayWithin)
     145{
     146    Node* node = NodeTraversal::previous(current, stayWithin);
     147    while (node && !node->isElementNode())
     148        node = NodeTraversal::previousSkippingChildren(node, stayWithin);
     149    return static_cast<Element*>(node);
     150}
     151
     152// Generic versions.
     153template <typename ElementType>
     154template <typename CurrentType>
     155inline ElementType* Traversal<ElementType>::firstChildTemplate(CurrentType* current)
     156{
    74157    Node* node = current->firstChild();
    75     while (node && !node->isElementNode())
     158    while (node && !isElementOfType<ElementType>(node))
    76159        node = node->nextSibling();
    77     return toElement(node);
    78 }
    79 inline Element* firstWithin(const ContainerNode* current) { return firstElementWithinTemplate(current); }
    80 inline Element* firstWithin(const Node* current) { return firstElementWithinTemplate(current); }
    81 
    82 template <class NodeType>
    83 inline Element* lastElementWithinTemplate(NodeType* current)
     160    return static_cast<ElementType*>(node);
     161}
     162
     163template <typename ElementType>
     164template <typename CurrentType>
     165inline ElementType* Traversal<ElementType>::lastChildTemplate(CurrentType* current)
    84166{
    85167    Node* node = current->lastChild();
    86     while (node && !node->isElementNode())
     168    while (node && !isElementOfType<ElementType>(node))
    87169        node = node->previousSibling();
    88     return toElement(node);
    89 }
    90 inline Element* lastWithin(const ContainerNode* current) { return lastElementWithinTemplate(current); }
    91 inline Element* lastWithin(const Node* current) { return lastElementWithinTemplate(current); }
    92 
    93 template <class NodeType>
    94 inline Element* traverseNextElementTemplate(NodeType* current)
    95 {
    96     Node* node = NodeTraversal::next(current);
    97     while (node && !node->isElementNode())
     170    return static_cast<ElementType*>(node);
     171}
     172
     173template <typename ElementType>
     174template <typename CurrentType>
     175inline ElementType* Traversal<ElementType>::firstWithinTemplate(CurrentType* current)
     176{
     177    Element* element = Traversal<Element>::firstWithin(current);
     178    while (element && !isElementOfType<ElementType>(element))
     179        element = Traversal<Element>::next(element, current);
     180    return static_cast<ElementType*>(element);
     181}
     182
     183template <typename ElementType>
     184template <typename CurrentType>
     185inline ElementType* Traversal<ElementType>::lastWithinTemplate(CurrentType* current)
     186{
     187    Element* element = Traversal<Element>::lastWithin(current);
     188    while (element && !isElementOfType<ElementType>(element))
     189        element = Traversal<Element>::previous(element, current);
     190    return static_cast<ElementType*>(element);
     191}
     192
     193template <typename ElementType>
     194template <typename CurrentType>
     195inline ElementType* Traversal<ElementType>::nextTemplate(CurrentType* current)
     196{
     197    Element* element = Traversal<Element>::next(current);
     198    while (element && !isElementOfType<ElementType>(element))
     199        element = Traversal<Element>::next(element);
     200    return static_cast<ElementType*>(element);
     201}
     202
     203template <typename ElementType>
     204template <typename CurrentType>
     205inline ElementType* Traversal<ElementType>::nextTemplate(CurrentType* current, const Node* stayWithin)
     206{
     207    Element* element = Traversal<Element>::next(current, stayWithin);
     208    while (element && !isElementOfType<ElementType>(element))
     209        element = Traversal<Element>::next(element, stayWithin);
     210    return static_cast<ElementType*>(element);
     211}
     212
     213template <typename ElementType>
     214template <typename CurrentType>
     215inline ElementType* Traversal<ElementType>::previousTemplate(CurrentType* current)
     216{
     217    Element* element = Traversal<Element>::previous(current);
     218    while (element && !isElementOfType<ElementType>(element))
     219        element = Traversal<Element>::previous(element);
     220    return static_cast<ElementType*>(element);
     221}
     222
     223template <typename ElementType>
     224template <typename CurrentType>
     225inline ElementType* Traversal<ElementType>::previousTemplate(CurrentType* current, const Node* stayWithin)
     226{
     227    Element* element = Traversal<Element>::previous(current, stayWithin);
     228    while (element && !isElementOfType<ElementType>(element))
     229        element = Traversal<Element>::previous(element, stayWithin);
     230    return static_cast<ElementType*>(element);
     231}
     232
     233template <typename ElementType>
     234template <typename CurrentType>
     235inline ElementType* Traversal<ElementType>::nextSiblingTemplate(CurrentType* current)
     236{
     237    Node* node = current->nextSibling();
     238    while (node && !isElementOfType<ElementType>(node))
     239        node = node->nextSibling();
     240    return static_cast<ElementType*>(node);
     241}
     242
     243template <typename ElementType>
     244template <typename CurrentType>
     245inline ElementType* Traversal<ElementType>::previousSiblingTemplate(CurrentType* current)
     246{
     247    Node* node = current->previousSibling();
     248    while (node && !isElementOfType<ElementType>(node))
     249        node = node->previousSibling();
     250    return static_cast<ElementType*>(node);
     251}
     252
     253template <typename ElementType>
     254template <typename CurrentType>
     255inline ElementType* Traversal<ElementType>::nextSkippingChildrenTemplate(CurrentType* current)
     256{
     257    Node* node = NodeTraversal::nextSkippingChildren(current);
     258    while (node && !isElementOfType<ElementType>(node))
    98259        node = NodeTraversal::nextSkippingChildren(node);
    99     return toElement(node);
    100 }
    101 inline Element* next(const ContainerNode* current) { return traverseNextElementTemplate(current); }
    102 inline Element* next(const Node* current) { return traverseNextElementTemplate(current); }
    103 
    104 template <class NodeType>
    105 inline Element* traverseNextElementTemplate(NodeType* current, const Node* stayWithin)
    106 {
    107     Node* node = NodeTraversal::next(current, stayWithin);
    108     while (node && !node->isElementNode())
     260    return static_cast<ElementType*>(node);
     261}
     262
     263template <typename ElementType>
     264template <typename CurrentType>
     265inline ElementType* Traversal<ElementType>::nextSkippingChildrenTemplate(CurrentType* current, const Node* stayWithin)
     266{
     267    Node* node = NodeTraversal::nextSkippingChildren(current, stayWithin);
     268    while (node && !isElementOfType<ElementType>(node))
    109269        node = NodeTraversal::nextSkippingChildren(node, stayWithin);
    110     return toElement(node);
    111 }
    112 inline Element* next(const ContainerNode* current, const Node* stayWithin) { return traverseNextElementTemplate(current, stayWithin); }
    113 inline Element* next(const Node* current, const Node* stayWithin) { return traverseNextElementTemplate(current, stayWithin); }
    114 
    115 template <class NodeType>
    116 inline Element* traverseNextSiblingElementTemplate(NodeType* current)
    117 {
    118     Node* node = current->nextSibling();
    119     while (node && !node->isElementNode())
    120         node = node->nextSibling();
    121     return toElement(node);
    122 }
    123 inline Element* nextSibling(const ContainerNode* current) { return traverseNextSiblingElementTemplate(current); }
    124 inline Element* nextSibling(const Node* current) { return traverseNextSiblingElementTemplate(current); }
    125 
    126 template <class NodeType>
    127 inline Element* traversePreviousSiblingElementTemplate(NodeType* current)
    128 {
    129     Node* node = current->previousSibling();
    130     while (node && !node->isElementNode())
    131         node = node->previousSibling();
    132     return toElement(node);
    133 }
    134 inline Element* previousSibling(const ContainerNode* current) { return traversePreviousSiblingElementTemplate(current); }
    135 inline Element* previousSibling(const Node* current) { return traversePreviousSiblingElementTemplate(current); }
    136 
    137 template <class NodeType>
    138 inline Element* traverseNextElementSkippingChildrenTemplate(NodeType* current)
    139 {
    140     Node* node = NodeTraversal::nextSkippingChildren(current);
    141     while (node && !node->isElementNode())
    142         node = NodeTraversal::nextSkippingChildren(node);
    143     return toElement(node);
    144 }
    145 inline Element* nextSkippingChildren(const ContainerNode* current) { return traverseNextElementSkippingChildrenTemplate(current); }
    146 inline Element* nextSkippingChildren(const Node* current) { return traverseNextElementSkippingChildrenTemplate(current); }
    147 
    148 template <class NodeType>
    149 inline Element* traverseNextElementSkippingChildrenTemplate(NodeType* current, const Node* stayWithin)
    150 {
    151     Node* node = NodeTraversal::nextSkippingChildren(current, stayWithin);
    152     while (node && !node->isElementNode())
    153         node = NodeTraversal::nextSkippingChildren(node, stayWithin);
    154     return toElement(node);
    155 }
    156 inline Element* nextSkippingChildren(const ContainerNode* current, const Node* stayWithin) { return traverseNextElementSkippingChildrenTemplate(current, stayWithin); }
    157 inline Element* nextSkippingChildren(const Node* current, const Node* stayWithin) { return traverseNextElementSkippingChildrenTemplate(current, stayWithin); }
    158 
    159 inline Element* previousIncludingPseudo(const Node* current, const Node* stayWithin)
     270    return static_cast<ElementType*>(node);
     271}
     272
     273template <typename ElementType>
     274inline ElementType* Traversal<ElementType>::firstChild(const ContainerNode* current) { return firstWithinTemplate(current); }
     275template <typename ElementType>
     276inline ElementType* Traversal<ElementType>::firstChild(const Node* current) { return firstWithinTemplate(current); }
     277template <typename ElementType>
     278
     279inline ElementType* Traversal<ElementType>::lastChild(const ContainerNode* current) { return lastWithinTemplate(current); }
     280template <typename ElementType>
     281inline ElementType* Traversal<ElementType>::lastChild(const Node* current) { return lastWithinTemplate(current); }
     282
     283template <typename ElementType>
     284inline ElementType* Traversal<ElementType>::firstWithin(const ContainerNode* current) { return firstWithinTemplate(current); }
     285template <typename ElementType>
     286inline ElementType* Traversal<ElementType>::firstWithin(const Node* current) { return firstWithinTemplate(current); }
     287template <typename ElementType>
     288
     289inline ElementType* Traversal<ElementType>::lastWithin(const ContainerNode* current) { return lastWithinTemplate(current); }
     290template <typename ElementType>
     291inline ElementType* Traversal<ElementType>::lastWithin(const Node* current) { return lastWithinTemplate(current); }
     292
     293template <typename ElementType>
     294inline ElementType* Traversal<ElementType>::next(const ContainerNode* current) { return nextTemplate(current); }
     295template <typename ElementType>
     296inline ElementType* Traversal<ElementType>::next(const Node* current) { return nextTemplate(current); }
     297template <typename ElementType>
     298inline ElementType* Traversal<ElementType>::next(const ContainerNode* current, const Node* stayWithin) { return nextTemplate(current, stayWithin); }
     299template <typename ElementType>
     300inline ElementType* Traversal<ElementType>::next(const Node* current, const Node* stayWithin) { return nextTemplate(current, stayWithin); }
     301
     302template <typename ElementType>
     303inline ElementType* Traversal<ElementType>::previous(const ContainerNode* current) { return previousTemplate(current); }
     304template <typename ElementType>
     305inline ElementType* Traversal<ElementType>::previous(const Node* current) { return previousTemplate(current); }
     306template <typename ElementType>
     307inline ElementType* Traversal<ElementType>::previous(const ContainerNode* current, const Node* stayWithin) { return previousTemplate(current, stayWithin); }
     308template <typename ElementType>
     309inline ElementType* Traversal<ElementType>::previous(const Node* current, const Node* stayWithin) { return previousTemplate(current, stayWithin); }
     310
     311template <typename ElementType>
     312inline ElementType* Traversal<ElementType>::nextSibling(const ContainerNode* current) { return nextSiblingTemplate(current); }
     313template <typename ElementType>
     314inline ElementType* Traversal<ElementType>::nextSibling(const Node* current) { return nextSiblingTemplate(current); }
     315
     316template <typename ElementType>
     317inline ElementType* Traversal<ElementType>::previousSibling(const ContainerNode* current) { return previousSiblingTemplate(current); }
     318template <typename ElementType>
     319inline ElementType* Traversal<ElementType>::previousSibling(const Node* current) { return previousSiblingTemplate(current); }
     320
     321template <typename ElementType>
     322inline ElementType* Traversal<ElementType>::nextSkippingChildren(const ContainerNode* current) { return nextSkippingChildrenTemplate(current); }
     323template <typename ElementType>
     324inline ElementType* Traversal<ElementType>::nextSkippingChildren(const Node* current) { return nextSkippingChildrenTemplate(current); }
     325template <typename ElementType>
     326inline ElementType* Traversal<ElementType>::nextSkippingChildren(const ContainerNode* current, const Node* stayWithin) { return nextSkippingChildrenTemplate(current, stayWithin); }
     327template <typename ElementType>
     328inline ElementType* Traversal<ElementType>::nextSkippingChildren(const Node* current, const Node* stayWithin) { return nextSkippingChildrenTemplate(current, stayWithin); }
     329
     330// FIXME: These should go somewhere else.
     331inline Element* ElementTraversal::previousIncludingPseudo(const Node* current, const Node* stayWithin)
    160332{
    161333    Node* node = NodeTraversal::previousIncludingPseudo(current, stayWithin);
     
    165337}
    166338
    167 inline Element* nextIncludingPseudo(const Node* current, const Node* stayWithin)
     339inline Element* ElementTraversal::nextIncludingPseudo(const Node* current, const Node* stayWithin)
    168340{
    169341    Node* node = NodeTraversal::nextIncludingPseudo(current, stayWithin);
     
    173345}
    174346
    175 inline Element* nextIncludingPseudoSkippingChildren(const Node* current, const Node* stayWithin)
     347inline Element* ElementTraversal::nextIncludingPseudoSkippingChildren(const Node* current, const Node* stayWithin)
    176348{
    177349    Node* node = NodeTraversal::nextIncludingPseudoSkippingChildren(current, stayWithin);
     
    181353}
    182354
    183 inline Element* pseudoAwarePreviousSibling(const Node* current)
     355inline Element* ElementTraversal::pseudoAwarePreviousSibling(const Node* current)
    184356{
    185357    Node* node = current->pseudoAwarePreviousSibling();
     
    190362
    191363}
    192 }
    193364
    194365#endif
  • trunk/Source/WebCore/dom/Node.cpp

    r154327 r154481  
    23812381{
    23822382    size_t count = 0;
    2383     for (Element* element = ElementTraversal::firstWithin(this); element; element = ElementTraversal::next(element, this))
    2384         if (isHTMLStyleElement(element) && toHTMLStyleElement(element)->isRegisteredAsScoped())
     2383    for (HTMLStyleElement* style = Traversal<HTMLStyleElement>::firstWithin(this); style; style = Traversal<HTMLStyleElement>::next(style, this)) {
     2384        if (style->isRegisteredAsScoped())
    23852385            count++;
     2386    }
    23862387
    23872388    return count;
  • trunk/Source/WebCore/dom/NodeIterator.cpp

    r137221 r154481  
    7474
    7575NodeIterator::NodeIterator(PassRefPtr<Node> rootNode, unsigned whatToShow, PassRefPtr<NodeFilter> filter, bool expandEntityReferences)
    76     : Traversal(rootNode, whatToShow, filter, expandEntityReferences)
     76    : NodeIteratorBase(rootNode, whatToShow, filter, expandEntityReferences)
    7777    , m_referenceNode(root(), true)
    7878    , m_detached(false)
  • trunk/Source/WebCore/dom/NodeIterator.h

    r135058 r154481  
    3636    typedef int ExceptionCode;
    3737
    38     class NodeIterator : public ScriptWrappable, public RefCounted<NodeIterator>, public Traversal {
     38    class NodeIterator : public ScriptWrappable, public RefCounted<NodeIterator>, public NodeIteratorBase {
    3939    public:
    4040        static PassRefPtr<NodeIterator> create(PassRefPtr<Node> rootNode, unsigned whatToShow, PassRefPtr<NodeFilter> filter, bool expandEntityReferences)
  • trunk/Source/WebCore/dom/Traversal.cpp

    r84520 r154481  
    3131namespace WebCore {
    3232
    33 Traversal::Traversal(PassRefPtr<Node> rootNode, unsigned whatToShow, PassRefPtr<NodeFilter> nodeFilter, bool expandEntityReferences)
     33NodeIteratorBase::NodeIteratorBase(PassRefPtr<Node> rootNode, unsigned whatToShow, PassRefPtr<NodeFilter> nodeFilter, bool expandEntityReferences)
    3434    : m_root(rootNode)
    3535    , m_whatToShow(whatToShow)
     
    3939}
    4040
    41 short Traversal::acceptNode(ScriptState* state, Node* node) const
     41short NodeIteratorBase::acceptNode(ScriptState* state, Node* node) const
    4242{
    4343    // FIXME: To handle XML properly we would have to check m_expandEntityReferences.
  • trunk/Source/WebCore/dom/Traversal.h

    r63042 r154481  
    3434    class NodeFilter;
    3535
    36     class Traversal {
     36    class NodeIteratorBase {
    3737    public:
    3838        Node* root() const { return m_root.get(); }
     
    4242
    4343    protected:
    44         Traversal(PassRefPtr<Node>, unsigned whatToShow, PassRefPtr<NodeFilter>, bool expandEntityReferences);
     44        NodeIteratorBase(PassRefPtr<Node>, unsigned whatToShow, PassRefPtr<NodeFilter>, bool expandEntityReferences);
    4545        short acceptNode(ScriptState*, Node*) const;
    4646
  • trunk/Source/WebCore/dom/TreeScope.cpp

    r154165 r154481  
    299299        // Populate the map on first access.
    300300        m_labelsByForAttribute = adoptPtr(new DocumentOrderedMap);
    301         for (Element* element = ElementTraversal::firstWithin(rootNode()); element; element = ElementTraversal::next(element)) {
    302             if (isHTMLLabelElement(element)) {
    303                 HTMLLabelElement* label = toHTMLLabelElement(element);
    304                 const AtomicString& forValue = label->fastGetAttribute(forAttr);
    305                 if (!forValue.isEmpty())
    306                     addLabel(forValue, label);
    307             }
     301        for (HTMLLabelElement* label = Traversal<HTMLLabelElement>::firstWithin(rootNode()); label; label = Traversal<HTMLLabelElement>::next(label)) {
     302            const AtomicString& forValue = label->fastGetAttribute(forAttr);
     303            if (!forValue.isEmpty())
     304                addLabel(forValue, label);
    308305        }
    309306    }
     
    343340    if (Element* element = getElementById(name))
    344341        return element;
    345     for (Element* element = ElementTraversal::firstWithin(rootNode()); element; element = ElementTraversal::next(element)) {
    346         if (isHTMLAnchorElement(element)) {
    347             HTMLAnchorElement* anchor = toHTMLAnchorElement(element);
    348             if (rootNode()->document()->inQuirksMode()) {
    349                 // Quirks mode, case insensitive comparison of names.
    350                 if (equalIgnoringCase(anchor->name(), name))
    351                     return anchor;
    352             } else {
    353                 // Strict mode, names need to match exactly.
    354                 if (anchor->name() == name)
    355                     return anchor;
    356             }
     342    for (HTMLAnchorElement* anchor = Traversal<HTMLAnchorElement>::firstWithin(rootNode()); anchor; anchor = Traversal<HTMLAnchorElement>::next(anchor)) {
     343        if (rootNode()->document()->inQuirksMode()) {
     344            // Quirks mode, case insensitive comparison of names.
     345            if (equalIgnoringCase(anchor->name(), name))
     346                return anchor;
     347        } else {
     348            // Strict mode, names need to match exactly.
     349            if (anchor->name() == name)
     350                return anchor;
    357351        }
    358352    }
  • trunk/Source/WebCore/dom/TreeWalker.cpp

    r137221 r154481  
    3636
    3737TreeWalker::TreeWalker(PassRefPtr<Node> rootNode, unsigned whatToShow, PassRefPtr<NodeFilter> filter, bool expandEntityReferences)
    38     : Traversal(rootNode, whatToShow, filter, expandEntityReferences)
     38    : NodeIteratorBase(rootNode, whatToShow, filter, expandEntityReferences)
    3939    , m_current(root())
    4040{
  • trunk/Source/WebCore/dom/TreeWalker.h

    r135058 r154481  
    3636    typedef int ExceptionCode;
    3737
    38     class TreeWalker : public ScriptWrappable, public RefCounted<TreeWalker>, public Traversal {
     38    class TreeWalker : public ScriptWrappable, public RefCounted<TreeWalker>, public NodeIteratorBase {
    3939    public:
    4040        static PassRefPtr<TreeWalker> create(PassRefPtr<Node> rootNode, unsigned whatToShow, PassRefPtr<NodeFilter> filter, bool expandEntityReferences)
  • trunk/Source/WebCore/editing/FrameSelection.cpp

    r154286 r154481  
    19711971    if (!start)
    19721972        return 0;
    1973     Element* element = start->isElementNode() ? toElement(start) : ElementTraversal::next(start);
    1974     for (; element; element = ElementTraversal::next(element)) {
     1973    HTMLElement* element = start->isHTMLElement() ? toHTMLElement(start) : Traversal<HTMLElement>::next(start);
     1974    for (; element; element = Traversal<HTMLElement>::next(element)) {
    19751975        if (isHTMLFormElement(element))
    19761976            return toHTMLFormElement(element);
    1977         if (element->isHTMLElement() && toHTMLElement(element)->isFormControlElement())
     1977        if (element->isFormControlElement())
    19781978            return static_cast<HTMLFormControlElement*>(element)->form();
    19791979        if (element->hasTagName(frameTag) || element->hasTagName(iframeTag))
  • trunk/Source/WebCore/editing/markup.cpp

    r154252 r154481  
    10561056    // child of an element.
    10571057
    1058     RefPtr<Element> nextElement;
    1059     for (RefPtr<Element> element = ElementTraversal::firstWithin(fragment.get()); element; element = nextElement) {
    1060         nextElement = ElementTraversal::nextSibling(element.get());
     1058    RefPtr<HTMLElement> nextElement;
     1059    for (RefPtr<HTMLElement> element = Traversal<HTMLElement>::firstWithin(fragment.get()); element; element = nextElement) {
     1060        nextElement = Traversal<HTMLElement>::nextSibling(element.get());
    10611061        if (element->hasTagName(htmlTag) || element->hasTagName(headTag) || element->hasTagName(bodyTag)) {
    1062             HTMLElement* htmlElement = toHTMLElement(element.get());
    1063             if (Element* firstChild = ElementTraversal::firstWithin(htmlElement))
     1062            if (HTMLElement* firstChild = Traversal<HTMLElement>::firstChild(element.get()))
    10641063                nextElement = firstChild;
    1065             removeElementPreservingChildren(fragment, htmlElement);
     1064            removeElementPreservingChildren(fragment, element.get());
    10661065        }
    10671066    }
  • trunk/Source/WebCore/html/HTMLAnchorElement.h

    r153876 r154481  
    150150}
    151151
    152 inline bool isHTMLAnchorElement(Node* node)
     152inline bool isHTMLAnchorElement(const Node* node)
    153153{
    154154    return node->hasTagName(HTMLNames::aTag);
    155155}
    156156
    157 inline bool isHTMLAnchorElement(Element* element)
     157inline bool isHTMLAnchorElement(const Element* element)
    158158{
    159159    return element->hasTagName(HTMLNames::aTag);
     
    166166}
    167167
     168template <> inline bool isElementOfType<HTMLAnchorElement>(const Element* element) { return isHTMLAnchorElement(element); }
     169
    168170// Functions shared with the other anchor elements (i.e., SVG).
    169171
  • trunk/Source/WebCore/html/HTMLAreaElement.h

    r153772 r154481  
    7171};
    7272
    73 inline bool isHTMLAreaElement(Node* node)
     73inline bool isHTMLAreaElement(const Node* node)
    7474{
    7575    return node->hasTagName(HTMLNames::areaTag);
    7676}
    7777
    78 inline bool isHTMLAreaElement(Element* element)
     78inline bool isHTMLAreaElement(const Element* element)
    7979{
    8080    return element->hasTagName(HTMLNames::areaTag);
    8181}
     82
     83template <> inline bool isElementOfType<HTMLAreaElement>(const Element* element) { return isHTMLAreaElement(element); }
    8284
    8385inline HTMLAreaElement* toHTMLAreaElement(Node* node)
  • trunk/Source/WebCore/html/HTMLBaseElement.h

    r149960 r154481  
    4545};
    4646
     47inline bool isHTMLBaseElement(const Node* node)
     48{
     49    return node->hasTagName(HTMLNames::baseTag);
     50}
     51
     52inline bool isHTMLBaseElement(const Element* element)
     53{
     54    return element->hasTagName(HTMLNames::baseTag);
     55}
     56
     57template <> inline bool isElementOfType<HTMLBaseElement>(const Element* element) { return isHTMLBaseElement(element); }
     58
    4759} // namespace
    4860
  • trunk/Source/WebCore/html/HTMLElement.h

    r154358 r154481  
    155155}
    156156
     157template <> inline bool isElementOfType<HTMLElement>(const Element* element) { return element->isHTMLElement(); }
     158
    157159} // namespace WebCore
    158160
  • trunk/Source/WebCore/html/HTMLFieldSetElement.cpp

    r153942 r154481  
    5252void HTMLFieldSetElement::invalidateDisabledStateUnder(Element* base)
    5353{
    54     for (Element* element = ElementTraversal::firstWithin(base); element; element = ElementTraversal::next(element, base)) {
    55         if (element->isFormControlElement())
    56             static_cast<HTMLFormControlElement*>(element)->ancestorDisabledStateWasChanged();
    57     }
     54    for (HTMLFormControlElement* control = Traversal<HTMLFormControlElement>::firstWithin(base); control; control = Traversal<HTMLFormControlElement>::next(control, base))
     55        control->ancestorDisabledStateWasChanged();
    5856}
    5957
     
    6866{
    6967    HTMLFormControlElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
    70     for (Element* element = ElementTraversal::firstWithin(this); element; element = ElementTraversal::nextSibling(element)) {
    71         if (element->hasTagName(legendTag))
    72             invalidateDisabledStateUnder(element);
    73     }
     68    for (HTMLLegendElement* legend = Traversal<HTMLLegendElement>::firstChild(this); legend; legend = Traversal<HTMLLegendElement>::nextSibling(legend))
     69        invalidateDisabledStateUnder(legend);
    7470}
    7571
     
    9288HTMLLegendElement* HTMLFieldSetElement::legend() const
    9389{
    94     for (Element* child = ElementTraversal::firstWithin(this); child; child = ElementTraversal::nextSibling(child)) {
    95         if (child->hasTagName(legendTag))
    96             return static_cast<HTMLLegendElement*>(child);
    97     }
    98     return 0;
     90    return Traversal<HTMLLegendElement>::firstWithin(this);
    9991}
    10092
  • trunk/Source/WebCore/html/HTMLFormControlElement.h

    r154371 r154481  
    181181    return static_cast<HTMLFormControlElement*>(node);
    182182}
    183 
    184183// This will catch anyone doing an unnecessary cast.
    185184void toHTMLFormControlElement(const HTMLFormControlElement*);
     185
     186template <> inline bool isElementOfType<HTMLFormControlElement>(const Element* element) { return isHTMLFormControlElement(element); }
     187
    186188
    187189} // namespace
  • trunk/Source/WebCore/html/HTMLLabelElement.cpp

    r153939 r154481  
    3737using namespace HTMLNames;
    3838
    39 static LabelableElement* nodeAsLabelableElement(Node* node)
     39static LabelableElement* nodeAsSupportedLabelableElement(Node* node)
    4040{
    41     if (!node || !node->isHTMLElement())
     41    if (!node || !isLabelableElement(node))
    4242        return 0;
    43    
    44     HTMLElement* element = static_cast<HTMLElement*>(node);
    45     if (!element->isLabelable())
    46         return 0;
    47 
    48     LabelableElement* labelableElement = static_cast<LabelableElement*>(element);
     43    LabelableElement* labelableElement = static_cast<LabelableElement*>(node);
    4944    if (!labelableElement->supportLabels())
    5045        return 0;
    51 
    5246    return labelableElement;
    5347}
     
    7670        // per http://dev.w3.org/html5/spec/Overview.html#the-label-element
    7771        // the form element must be "labelable form-associated element".
    78         Element* element = this;
    79         while ((element = ElementTraversal::next(element, this))) {
    80             if (LabelableElement* labelableElement = nodeAsLabelableElement(element))
     72
     73        LabelableElement* labelableElement = Traversal<LabelableElement>::firstWithin(this);
     74        for (; labelableElement; labelableElement = Traversal<LabelableElement>::next(labelableElement, this)) {
     75            if (labelableElement->supportLabels())
    8176                return labelableElement;
    8277        }
     
    8681    // Find the first element whose id is controlId. If it is found and it is a labelable form control,
    8782    // return it, otherwise return 0.
    88     return nodeAsLabelableElement(treeScope()->getElementById(controlId));
     83    return nodeAsSupportedLabelableElement(treeScope()->getElementById(controlId));
    8984}
    9085
  • trunk/Source/WebCore/html/HTMLLabelElement.h

    r152353 r154481  
    5656};
    5757
    58 inline bool isHTMLLabelElement(Node* node)
     58inline bool isHTMLLabelElement(const Node* node)
    5959{
    6060    return node->hasTagName(HTMLNames::labelTag);
    6161}
    6262
    63 inline bool isHTMLLabelElement(Element* element)
     63inline bool isHTMLLabelElement(const Element* element)
    6464{
    6565    return element->hasTagName(HTMLNames::labelTag);
    6666}
     67
     68template <> inline bool isElementOfType<HTMLLabelElement>(const Element* element) { return isHTMLLabelElement(element); }
    6769
    6870inline HTMLLabelElement* toHTMLLabelElement(Node* node)
  • trunk/Source/WebCore/html/HTMLLegendElement.h

    r149960 r154481  
    4646};
    4747
     48inline bool isHTMLLegendElement(const Node* node)
     49{
     50    return node->hasTagName(HTMLNames::legendTag);
     51}
     52
     53inline bool isHTMLLegendElement(const Element* element)
     54{
     55    return element->hasTagName(HTMLNames::legendTag);
     56}
     57
     58template <> inline bool isElementOfType<HTMLLegendElement>(const Element* element) { return isHTMLLegendElement(element); }
     59
    4860} //namespace
    4961
  • trunk/Source/WebCore/html/HTMLMapElement.cpp

    r153939 r154481  
    6363{
    6464    HTMLAreaElement* defaultArea = 0;
    65     Element* element = this;
    66     while ((element = ElementTraversal::next(element, this))) {
    67         if (isHTMLAreaElement(element)) {
    68             HTMLAreaElement* areaElt = toHTMLAreaElement(element);
    69             if (areaElt->isDefault()) {
    70                 if (!defaultArea)
    71                     defaultArea = areaElt;
    72             } else if (areaElt->mapMouseEvent(location, size, result))
    73                 return true;
    74         }
     65    for (HTMLAreaElement* area = Traversal<HTMLAreaElement>::firstWithin(this); area; area = Traversal<HTMLAreaElement>::next(area, this)) {
     66        if (area->isDefault()) {
     67            if (!defaultArea)
     68                defaultArea = area;
     69        } else if (area->mapMouseEvent(location, size, result))
     70            return true;
    7571    }
    7672   
  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r154449 r154481  
    536536        return;
    537537
    538     for (Element* element = ElementTraversal::firstWithin(this); element; element = ElementTraversal::nextSibling(element)) {
    539         if (element->hasTagName(trackTag)) {
    540             scheduleDelayedAction(ConfigureTextTracks);
    541             break;
    542         }
    543     }
     538    if (Traversal<HTMLTrackElement>::firstWithin(this))
     539        scheduleDelayedAction(ConfigureTextTracks);
    544540#endif
    545541}
  • trunk/Source/WebCore/html/HTMLStyleElement.h

    r154271 r154481  
    9494};
    9595
    96 inline bool isHTMLStyleElement(Node* node)
     96inline bool isHTMLStyleElement(const Node* node)
    9797{
    9898    return node->hasTagName(HTMLNames::styleTag);
    9999}
    100100
    101 inline bool isHTMLStyleElement(Element* element)
     101inline bool isHTMLStyleElement(const Element* element)
    102102{
    103103    return element->hasTagName(HTMLNames::styleTag);
     
    110110}
    111111
     112template <> inline bool isElementOfType<HTMLStyleElement>(const Element* element) { return isHTMLStyleElement(element); }
     113
    112114} //namespace
    113115
  • trunk/Source/WebCore/html/HTMLTitleElement.h

    r152567 r154481  
    6363}
    6464
     65template <> inline bool isElementOfType<HTMLTitleElement>(const Element* element) { return isHTMLTitleElement(element); }
     66
    6567} //namespace
    6668
  • trunk/Source/WebCore/html/HTMLTrackElement.h

    r153926 r154481  
    9898};
    9999
     100inline bool isHTMLTrackElement(const Node* node)
     101{
     102    return node->hasTagName(HTMLNames::trackTag);
     103}
     104
     105inline bool isHTMLTrackElement(const Element* element)
     106{
     107    return element->hasTagName(HTMLNames::trackTag);
     108}
     109
     110template <> inline bool isElementOfType<HTMLTrackElement>(const Element* element) { return isHTMLTrackElement(element); }
     111
     112
    100113}
    101114
  • trunk/Source/WebCore/html/LabelableElement.h

    r110927 r154481  
    5151};
    5252
     53inline bool isLabelableElement(const Node* node)
     54{
     55    if (!node->isHTMLElement())
     56        return false;
     57    return static_cast<const HTMLElement*>(node)->isLabelable();
     58}
     59
     60template <> inline bool isElementOfType<LabelableElement>(const Element* element) { return isLabelableElement(element); }
     61
    5362} // namespace WebCore
    5463
  • trunk/Source/WebCore/rendering/FilterEffectRenderer.cpp

    r154133 r154481  
    161161    RefPtr<SVGFilterBuilder> builder = SVGFilterBuilder::create(previousEffect, SourceAlpha::create(this));
    162162
    163     for (Element* element = ElementTraversal::firstWithin(filter); element; element = ElementTraversal::nextSibling(element)) {
    164         if (!element->isSVGElement())
    165             continue;
    166         SVGElement* svgElement = toSVGElement(element);
     163    for (SVGElement* svgElement = Traversal<SVGElement>::firstChild(filter); svgElement; svgElement = Traversal<SVGElement>::nextSibling(svgElement)) {
    167164        if (!svgElement->isFilterEffect())
    168165            continue;
  • trunk/Source/WebCore/svg/SVGElement.cpp

    r154462 r154481  
    5252#include "SVGRenderSupport.h"
    5353#include "SVGSVGElement.h"
     54#include "SVGTitleElement.h"
    5455#include "SVGUseElement.h"
    5556#include "ScriptEventListener.h"
     
    878879    // If we aren't an instance in a <use> or the <use> title was not found, then find the first
    879880    // <title> child of this element.
    880     Element* titleElement = ElementTraversal::firstWithin(this);
    881     for (; titleElement; titleElement = ElementTraversal::nextSibling(titleElement)) {
    882         if (titleElement->hasTagName(SVGNames::titleTag) && titleElement->isSVGElement())
    883             break;
    884     }
    885 
    886881    // If a title child was found, return the text contents.
    887     if (titleElement)
     882    if (SVGTitleElement* titleElement = Traversal<SVGTitleElement>::firstWithin(this))
    888883        return titleElement->innerText();
    889884
  • trunk/Source/WebCore/svg/SVGElement.h

    r154462 r154481  
    218218}
    219219
     220template <> inline bool isElementOfType<SVGElement>(const Element* element) { return element->isSVGElement(); }
     221
    220222}
    221223
  • trunk/Source/WebCore/svg/SVGForeignObjectElement.h

    r154371 r154481  
    2626#include "SVGExternalResourcesRequired.h"
    2727#include "SVGGraphicsElement.h"
     28#include "SVGNames.h"
    2829#include "SVGURIReference.h"
    2930
     
    5960};
    6061
     62inline bool isSVGForeignObjectElement(const Node* node)
     63{
     64    return node->hasTagName(SVGNames::foreignObjectTag);
     65}
     66
     67inline bool isSVGForeignObjectElement(const Element* element)
     68{
     69    return element->hasTagName(SVGNames::foreignObjectTag);
     70}
     71
     72template <> inline bool isElementOfType<SVGForeignObjectElement>(const Element* element) { return isSVGForeignObjectElement(element); }
     73
     74
    6175} // namespace WebCore
    6276
  • trunk/Source/WebCore/svg/SVGSVGElement.cpp

    r154358 r154481  
    343343{
    344344    Vector<RefPtr<Node> > nodes;
    345     Element* element = ElementTraversal::next(referenceElement ? referenceElement : this);
    346     while (element) {
    347         if (element->isSVGElement()) {
    348             SVGElement* svgElement = toSVGElement(element);
    349             if (collect == CollectIntersectionList) {
    350                 if (checkIntersection(svgElement, rect))
    351                     nodes.append(element);
    352             } else {
    353                 if (checkEnclosure(svgElement, rect))
    354                     nodes.append(element);
    355             }
     345    SVGElement* svgElement = Traversal<SVGElement>::firstWithin(referenceElement ? referenceElement : this);
     346    while (svgElement) {
     347        if (collect == CollectIntersectionList) {
     348            if (checkIntersection(svgElement, rect))
     349                nodes.append(svgElement);
     350        } else {
     351            if (checkEnclosure(svgElement, rect))
     352                nodes.append(svgElement);
    356353        }
    357 
    358         element = ElementTraversal::next(element, referenceElement ? referenceElement : this);
     354        svgElement = Traversal<SVGElement>::next(svgElement, referenceElement ? referenceElement : this);
    359355    }
    360356    return StaticNodeList::adopt(nodes);
     
    786782    // Fall back to traversing our subtree. Duplicate ids are allowed, the first found will
    787783    // be returned.
    788     for (Node* node = firstChild(); node; node = NodeTraversal::next(node, this)) {
    789         if (!node->isElementNode())
    790             continue;
    791 
    792         Element* element = toElement(node);
     784    for (Element* element = ElementTraversal::firstWithin(this); element; element = ElementTraversal::next(element, this)) {
    793785        if (element->getIdAttribute() == id)
    794786            return element;
  • trunk/Source/WebCore/svg/SVGTitleElement.h

    r154462 r154481  
    2424
    2525#include "SVGElement.h"
     26#include "SVGNames.h"
    2627
    2728namespace WebCore {
     
    4142};
    4243
     44template <> inline bool isElementOfType<SVGTitleElement>(const Element* element) { return element->hasTagName(SVGNames::titleTag); }
     45
    4346} // namespace WebCore
    4447
  • trunk/Source/WebCore/svg/animation/SMILTimeContainer.cpp

    r153939 r154481  
    223223{
    224224    unsigned timingElementCount = 0;
    225     for (Element* element = m_ownerSVGElement; element; element = ElementTraversal::next(element, m_ownerSVGElement)) {
    226         if (SVGSMILElement::isSMILElement(element))
    227             toSVGSMILElement(element)->setDocumentOrderIndex(timingElementCount++);
    228     }
     225    SVGSMILElement* smilElement = Traversal<SVGSMILElement>::firstWithin(m_ownerSVGElement);
     226    for (; smilElement; smilElement = Traversal<SVGSMILElement>::next(smilElement, m_ownerSVGElement))
     227        smilElement->setDocumentOrderIndex(timingElementCount++);
    229228    m_documentOrderIndexesDirty = false;
    230229}
  • trunk/Source/WebCore/svg/animation/SVGSMILElement.cpp

    r153559 r154481  
    416416}
    417417
    418 bool SVGSMILElement::isSMILElement(Node* node)
     418bool SVGSMILElement::isSMILElement(const Node* node)
    419419{
    420420    if (!node)
  • trunk/Source/WebCore/svg/animation/SVGSMILElement.h

    r154462 r154481  
    4343    virtual ~SVGSMILElement();
    4444
    45     static bool isSMILElement(Node*);
     45    static bool isSMILElement(const Node*);
    4646
    4747    bool isSupportedAttribute(const QualifiedName&);
     
    243243}
    244244
     245template <> inline bool isElementOfType<SVGSMILElement>(const Element* element) { return SVGSMILElement::isSMILElement(element); }
     246
    245247}
    246248
  • trunk/Source/WebCore/svg/graphics/SVGImage.cpp

    r154272 r154481  
    4141#include "RenderStyle.h"
    4242#include "SVGDocument.h"
     43#include "SVGForeignObjectElement.h"
    4344#include "SVGImageChromeClient.h"
    4445#include "SVGSVGElement.h"
     
    7576
    7677    // Don't allow foreignObject elements since they can leak information with arbitrary HTML (like spellcheck or control theme).
    77     for (Element* current = ElementTraversal::firstWithin(rootElement); current; current = ElementTraversal::next(current, rootElement)) {
    78         if (current->hasTagName(SVGNames::foreignObjectTag))
    79             return false;
    80     }
     78    if (Traversal<SVGForeignObjectElement>::firstWithin(rootElement))
     79        return false;
    8180
    8281    // Because SVG image rendering disallows external resources and links,
Note: See TracChangeset for help on using the changeset viewer.