Changeset 154481 in webkit
- Timestamp:
- Aug 23, 2013 5:40:49 AM (11 years ago)
- Location:
- trunk/Source/WebCore
- Files:
-
- 41 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/WebCore/ChangeLog
r154479 r154481 1 2013-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 1 130 2013-08-23 Arpita Bahuguna <a.bah@samsung.com> 2 131 -
trunk/Source/WebCore/WebCore.exp.in
r154470 r154481 2695 2695 2696 2696 #if ENABLE(SVG) 2697 __ZN7WebCore14SVGSMILElement13isSMILElementEPNS_4NodeE2698 2697 __ZN7WebCore8Document13svgExtensionsEv 2699 2698 __ZN7WebCore8Document19accessSVGExtensionsEv -
trunk/Source/WebCore/accessibility/AccessibilityRenderObject.cpp
r154343 r154481 2754 2754 return; 2755 2755 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)) { 2757 2757 // add an <area> element for this child if it has a link 2758 if ( isHTMLAreaElement(current) &¤t->isLink()) {2758 if (current->isLink()) { 2759 2759 AccessibilityImageMapLink* areaObject = static_cast<AccessibilityImageMapLink*>(axObjectCache()->getOrCreate(ImageMapLinkRole)); 2760 2760 areaObject->setHTMLAreaElement(toHTMLAreaElement(current)); -
trunk/Source/WebCore/dom/Document.cpp
r154449 r154481 79 79 #include "HTMLAllCollection.h" 80 80 #include "HTMLAnchorElement.h" 81 #include "HTMLBaseElement.h" 81 82 #include "HTMLCanvasElement.h" 82 83 #include "HTMLCollection.h" … … 1560 1561 // Update title based on first title element in the head, if one exists. 1561 1562 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); 1569 1565 } 1570 1566 … … 2614 2610 // Base URL change changes any relative visited links. 2615 2611 // 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(); 2620 2614 } 2621 2615 } … … 2632 2626 const AtomicString* href = 0; 2633 2627 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; 2646 2638 } 2647 2639 } -
trunk/Source/WebCore/dom/Element.h
r154371 r154481 693 693 void toElement(const Element*); 694 694 695 template <typename Type> bool isElementOfType(const Element*); 696 template <typename Type> bool isElementOfType(const Node* node) { return node->isElementNode() && isElementOfType<Type>(toElement(node)); } 697 template <> inline bool isElementOfType<Element>(const Element*) { return true; } 698 695 699 inline bool isDisabledFormControl(const Node* node) 696 700 { -
trunk/Source/WebCore/dom/ElementTraversal.h
r153942 r154481 30 30 31 31 namespace 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 33 template <typename ElementType> 34 class Traversal { 35 public: 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 70 private: 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 85 class ElementTraversal : public Traversal<Element> { 86 public: 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. 98 template <> 99 template <typename CurrentType> 100 inline Element* Traversal<Element>::firstWithinTemplate(CurrentType* current) 101 { 102 return firstChildTemplate(current); 103 } 104 105 template <> 106 template <typename CurrentType> 107 inline Element* Traversal<Element>::lastWithinTemplate(CurrentType* current) 108 { 109 return lastChildTemplate(current); 110 } 111 112 template <> 113 template <typename CurrentType> 114 inline 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 122 template <> 123 template <typename CurrentType> 124 inline 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 132 template <> 133 template <typename CurrentType> 134 inline 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 142 template <> 143 template <typename CurrentType> 144 inline 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. 153 template <typename ElementType> 154 template <typename CurrentType> 155 inline ElementType* Traversal<ElementType>::firstChildTemplate(CurrentType* current) 156 { 74 157 Node* node = current->firstChild(); 75 while (node && ! node->isElementNode())158 while (node && !isElementOfType<ElementType>(node)) 76 159 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 163 template <typename ElementType> 164 template <typename CurrentType> 165 inline ElementType* Traversal<ElementType>::lastChildTemplate(CurrentType* current) 84 166 { 85 167 Node* node = current->lastChild(); 86 while (node && ! node->isElementNode())168 while (node && !isElementOfType<ElementType>(node)) 87 169 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 173 template <typename ElementType> 174 template <typename CurrentType> 175 inline 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 183 template <typename ElementType> 184 template <typename CurrentType> 185 inline 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 193 template <typename ElementType> 194 template <typename CurrentType> 195 inline 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 203 template <typename ElementType> 204 template <typename CurrentType> 205 inline 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 213 template <typename ElementType> 214 template <typename CurrentType> 215 inline 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 223 template <typename ElementType> 224 template <typename CurrentType> 225 inline 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 233 template <typename ElementType> 234 template <typename CurrentType> 235 inline 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 243 template <typename ElementType> 244 template <typename CurrentType> 245 inline 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 253 template <typename ElementType> 254 template <typename CurrentType> 255 inline ElementType* Traversal<ElementType>::nextSkippingChildrenTemplate(CurrentType* current) 256 { 257 Node* node = NodeTraversal::nextSkippingChildren(current); 258 while (node && !isElementOfType<ElementType>(node)) 98 259 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 263 template <typename ElementType> 264 template <typename CurrentType> 265 inline ElementType* Traversal<ElementType>::nextSkippingChildrenTemplate(CurrentType* current, const Node* stayWithin) 266 { 267 Node* node = NodeTraversal::nextSkippingChildren(current, stayWithin); 268 while (node && !isElementOfType<ElementType>(node)) 109 269 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 273 template <typename ElementType> 274 inline ElementType* Traversal<ElementType>::firstChild(const ContainerNode* current) { return firstWithinTemplate(current); } 275 template <typename ElementType> 276 inline ElementType* Traversal<ElementType>::firstChild(const Node* current) { return firstWithinTemplate(current); } 277 template <typename ElementType> 278 279 inline ElementType* Traversal<ElementType>::lastChild(const ContainerNode* current) { return lastWithinTemplate(current); } 280 template <typename ElementType> 281 inline ElementType* Traversal<ElementType>::lastChild(const Node* current) { return lastWithinTemplate(current); } 282 283 template <typename ElementType> 284 inline ElementType* Traversal<ElementType>::firstWithin(const ContainerNode* current) { return firstWithinTemplate(current); } 285 template <typename ElementType> 286 inline ElementType* Traversal<ElementType>::firstWithin(const Node* current) { return firstWithinTemplate(current); } 287 template <typename ElementType> 288 289 inline ElementType* Traversal<ElementType>::lastWithin(const ContainerNode* current) { return lastWithinTemplate(current); } 290 template <typename ElementType> 291 inline ElementType* Traversal<ElementType>::lastWithin(const Node* current) { return lastWithinTemplate(current); } 292 293 template <typename ElementType> 294 inline ElementType* Traversal<ElementType>::next(const ContainerNode* current) { return nextTemplate(current); } 295 template <typename ElementType> 296 inline ElementType* Traversal<ElementType>::next(const Node* current) { return nextTemplate(current); } 297 template <typename ElementType> 298 inline ElementType* Traversal<ElementType>::next(const ContainerNode* current, const Node* stayWithin) { return nextTemplate(current, stayWithin); } 299 template <typename ElementType> 300 inline ElementType* Traversal<ElementType>::next(const Node* current, const Node* stayWithin) { return nextTemplate(current, stayWithin); } 301 302 template <typename ElementType> 303 inline ElementType* Traversal<ElementType>::previous(const ContainerNode* current) { return previousTemplate(current); } 304 template <typename ElementType> 305 inline ElementType* Traversal<ElementType>::previous(const Node* current) { return previousTemplate(current); } 306 template <typename ElementType> 307 inline ElementType* Traversal<ElementType>::previous(const ContainerNode* current, const Node* stayWithin) { return previousTemplate(current, stayWithin); } 308 template <typename ElementType> 309 inline ElementType* Traversal<ElementType>::previous(const Node* current, const Node* stayWithin) { return previousTemplate(current, stayWithin); } 310 311 template <typename ElementType> 312 inline ElementType* Traversal<ElementType>::nextSibling(const ContainerNode* current) { return nextSiblingTemplate(current); } 313 template <typename ElementType> 314 inline ElementType* Traversal<ElementType>::nextSibling(const Node* current) { return nextSiblingTemplate(current); } 315 316 template <typename ElementType> 317 inline ElementType* Traversal<ElementType>::previousSibling(const ContainerNode* current) { return previousSiblingTemplate(current); } 318 template <typename ElementType> 319 inline ElementType* Traversal<ElementType>::previousSibling(const Node* current) { return previousSiblingTemplate(current); } 320 321 template <typename ElementType> 322 inline ElementType* Traversal<ElementType>::nextSkippingChildren(const ContainerNode* current) { return nextSkippingChildrenTemplate(current); } 323 template <typename ElementType> 324 inline ElementType* Traversal<ElementType>::nextSkippingChildren(const Node* current) { return nextSkippingChildrenTemplate(current); } 325 template <typename ElementType> 326 inline ElementType* Traversal<ElementType>::nextSkippingChildren(const ContainerNode* current, const Node* stayWithin) { return nextSkippingChildrenTemplate(current, stayWithin); } 327 template <typename ElementType> 328 inline ElementType* Traversal<ElementType>::nextSkippingChildren(const Node* current, const Node* stayWithin) { return nextSkippingChildrenTemplate(current, stayWithin); } 329 330 // FIXME: These should go somewhere else. 331 inline Element* ElementTraversal::previousIncludingPseudo(const Node* current, const Node* stayWithin) 160 332 { 161 333 Node* node = NodeTraversal::previousIncludingPseudo(current, stayWithin); … … 165 337 } 166 338 167 inline Element* nextIncludingPseudo(const Node* current, const Node* stayWithin)339 inline Element* ElementTraversal::nextIncludingPseudo(const Node* current, const Node* stayWithin) 168 340 { 169 341 Node* node = NodeTraversal::nextIncludingPseudo(current, stayWithin); … … 173 345 } 174 346 175 inline Element* nextIncludingPseudoSkippingChildren(const Node* current, const Node* stayWithin)347 inline Element* ElementTraversal::nextIncludingPseudoSkippingChildren(const Node* current, const Node* stayWithin) 176 348 { 177 349 Node* node = NodeTraversal::nextIncludingPseudoSkippingChildren(current, stayWithin); … … 181 353 } 182 354 183 inline Element* pseudoAwarePreviousSibling(const Node* current)355 inline Element* ElementTraversal::pseudoAwarePreviousSibling(const Node* current) 184 356 { 185 357 Node* node = current->pseudoAwarePreviousSibling(); … … 190 362 191 363 } 192 }193 364 194 365 #endif -
trunk/Source/WebCore/dom/Node.cpp
r154327 r154481 2381 2381 { 2382 2382 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()) 2385 2385 count++; 2386 } 2386 2387 2387 2388 return count; -
trunk/Source/WebCore/dom/NodeIterator.cpp
r137221 r154481 74 74 75 75 NodeIterator::NodeIterator(PassRefPtr<Node> rootNode, unsigned whatToShow, PassRefPtr<NodeFilter> filter, bool expandEntityReferences) 76 : Traversal(rootNode, whatToShow, filter, expandEntityReferences)76 : NodeIteratorBase(rootNode, whatToShow, filter, expandEntityReferences) 77 77 , m_referenceNode(root(), true) 78 78 , m_detached(false) -
trunk/Source/WebCore/dom/NodeIterator.h
r135058 r154481 36 36 typedef int ExceptionCode; 37 37 38 class NodeIterator : public ScriptWrappable, public RefCounted<NodeIterator>, public Traversal{38 class NodeIterator : public ScriptWrappable, public RefCounted<NodeIterator>, public NodeIteratorBase { 39 39 public: 40 40 static PassRefPtr<NodeIterator> create(PassRefPtr<Node> rootNode, unsigned whatToShow, PassRefPtr<NodeFilter> filter, bool expandEntityReferences) -
trunk/Source/WebCore/dom/Traversal.cpp
r84520 r154481 31 31 namespace WebCore { 32 32 33 Traversal::Traversal(PassRefPtr<Node> rootNode, unsigned whatToShow, PassRefPtr<NodeFilter> nodeFilter, bool expandEntityReferences)33 NodeIteratorBase::NodeIteratorBase(PassRefPtr<Node> rootNode, unsigned whatToShow, PassRefPtr<NodeFilter> nodeFilter, bool expandEntityReferences) 34 34 : m_root(rootNode) 35 35 , m_whatToShow(whatToShow) … … 39 39 } 40 40 41 short Traversal::acceptNode(ScriptState* state, Node* node) const41 short NodeIteratorBase::acceptNode(ScriptState* state, Node* node) const 42 42 { 43 43 // FIXME: To handle XML properly we would have to check m_expandEntityReferences. -
trunk/Source/WebCore/dom/Traversal.h
r63042 r154481 34 34 class NodeFilter; 35 35 36 class Traversal{36 class NodeIteratorBase { 37 37 public: 38 38 Node* root() const { return m_root.get(); } … … 42 42 43 43 protected: 44 Traversal(PassRefPtr<Node>, unsigned whatToShow, PassRefPtr<NodeFilter>, bool expandEntityReferences);44 NodeIteratorBase(PassRefPtr<Node>, unsigned whatToShow, PassRefPtr<NodeFilter>, bool expandEntityReferences); 45 45 short acceptNode(ScriptState*, Node*) const; 46 46 -
trunk/Source/WebCore/dom/TreeScope.cpp
r154165 r154481 299 299 // Populate the map on first access. 300 300 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); 308 305 } 309 306 } … … 343 340 if (Element* element = getElementById(name)) 344 341 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; 357 351 } 358 352 } -
trunk/Source/WebCore/dom/TreeWalker.cpp
r137221 r154481 36 36 37 37 TreeWalker::TreeWalker(PassRefPtr<Node> rootNode, unsigned whatToShow, PassRefPtr<NodeFilter> filter, bool expandEntityReferences) 38 : Traversal(rootNode, whatToShow, filter, expandEntityReferences)38 : NodeIteratorBase(rootNode, whatToShow, filter, expandEntityReferences) 39 39 , m_current(root()) 40 40 { -
trunk/Source/WebCore/dom/TreeWalker.h
r135058 r154481 36 36 typedef int ExceptionCode; 37 37 38 class TreeWalker : public ScriptWrappable, public RefCounted<TreeWalker>, public Traversal{38 class TreeWalker : public ScriptWrappable, public RefCounted<TreeWalker>, public NodeIteratorBase { 39 39 public: 40 40 static PassRefPtr<TreeWalker> create(PassRefPtr<Node> rootNode, unsigned whatToShow, PassRefPtr<NodeFilter> filter, bool expandEntityReferences) -
trunk/Source/WebCore/editing/FrameSelection.cpp
r154286 r154481 1971 1971 if (!start) 1972 1972 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)) { 1975 1975 if (isHTMLFormElement(element)) 1976 1976 return toHTMLFormElement(element); 1977 if (element->is HTMLElement() && toHTMLElement(element)->isFormControlElement())1977 if (element->isFormControlElement()) 1978 1978 return static_cast<HTMLFormControlElement*>(element)->form(); 1979 1979 if (element->hasTagName(frameTag) || element->hasTagName(iframeTag)) -
trunk/Source/WebCore/editing/markup.cpp
r154252 r154481 1056 1056 // child of an element. 1057 1057 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()); 1061 1061 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())) 1064 1063 nextElement = firstChild; 1065 removeElementPreservingChildren(fragment, htmlElement);1064 removeElementPreservingChildren(fragment, element.get()); 1066 1065 } 1067 1066 } -
trunk/Source/WebCore/html/HTMLAnchorElement.h
r153876 r154481 150 150 } 151 151 152 inline bool isHTMLAnchorElement( Node* node)152 inline bool isHTMLAnchorElement(const Node* node) 153 153 { 154 154 return node->hasTagName(HTMLNames::aTag); 155 155 } 156 156 157 inline bool isHTMLAnchorElement( Element* element)157 inline bool isHTMLAnchorElement(const Element* element) 158 158 { 159 159 return element->hasTagName(HTMLNames::aTag); … … 166 166 } 167 167 168 template <> inline bool isElementOfType<HTMLAnchorElement>(const Element* element) { return isHTMLAnchorElement(element); } 169 168 170 // Functions shared with the other anchor elements (i.e., SVG). 169 171 -
trunk/Source/WebCore/html/HTMLAreaElement.h
r153772 r154481 71 71 }; 72 72 73 inline bool isHTMLAreaElement( Node* node)73 inline bool isHTMLAreaElement(const Node* node) 74 74 { 75 75 return node->hasTagName(HTMLNames::areaTag); 76 76 } 77 77 78 inline bool isHTMLAreaElement( Element* element)78 inline bool isHTMLAreaElement(const Element* element) 79 79 { 80 80 return element->hasTagName(HTMLNames::areaTag); 81 81 } 82 83 template <> inline bool isElementOfType<HTMLAreaElement>(const Element* element) { return isHTMLAreaElement(element); } 82 84 83 85 inline HTMLAreaElement* toHTMLAreaElement(Node* node) -
trunk/Source/WebCore/html/HTMLBaseElement.h
r149960 r154481 45 45 }; 46 46 47 inline bool isHTMLBaseElement(const Node* node) 48 { 49 return node->hasTagName(HTMLNames::baseTag); 50 } 51 52 inline bool isHTMLBaseElement(const Element* element) 53 { 54 return element->hasTagName(HTMLNames::baseTag); 55 } 56 57 template <> inline bool isElementOfType<HTMLBaseElement>(const Element* element) { return isHTMLBaseElement(element); } 58 47 59 } // namespace 48 60 -
trunk/Source/WebCore/html/HTMLElement.h
r154358 r154481 155 155 } 156 156 157 template <> inline bool isElementOfType<HTMLElement>(const Element* element) { return element->isHTMLElement(); } 158 157 159 } // namespace WebCore 158 160 -
trunk/Source/WebCore/html/HTMLFieldSetElement.cpp
r153942 r154481 52 52 void HTMLFieldSetElement::invalidateDisabledStateUnder(Element* base) 53 53 { 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(); 58 56 } 59 57 … … 68 66 { 69 67 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); 74 70 } 75 71 … … 92 88 HTMLLegendElement* HTMLFieldSetElement::legend() const 93 89 { 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); 99 91 } 100 92 -
trunk/Source/WebCore/html/HTMLFormControlElement.h
r154371 r154481 181 181 return static_cast<HTMLFormControlElement*>(node); 182 182 } 183 184 183 // This will catch anyone doing an unnecessary cast. 185 184 void toHTMLFormControlElement(const HTMLFormControlElement*); 185 186 template <> inline bool isElementOfType<HTMLFormControlElement>(const Element* element) { return isHTMLFormControlElement(element); } 187 186 188 187 189 } // namespace -
trunk/Source/WebCore/html/HTMLLabelElement.cpp
r153939 r154481 37 37 using namespace HTMLNames; 38 38 39 static LabelableElement* nodeAs LabelableElement(Node* node)39 static LabelableElement* nodeAsSupportedLabelableElement(Node* node) 40 40 { 41 if (!node || ! node->isHTMLElement())41 if (!node || !isLabelableElement(node)) 42 42 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); 49 44 if (!labelableElement->supportLabels()) 50 45 return 0; 51 52 46 return labelableElement; 53 47 } … … 76 70 // per http://dev.w3.org/html5/spec/Overview.html#the-label-element 77 71 // 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()) 81 76 return labelableElement; 82 77 } … … 86 81 // Find the first element whose id is controlId. If it is found and it is a labelable form control, 87 82 // return it, otherwise return 0. 88 return nodeAs LabelableElement(treeScope()->getElementById(controlId));83 return nodeAsSupportedLabelableElement(treeScope()->getElementById(controlId)); 89 84 } 90 85 -
trunk/Source/WebCore/html/HTMLLabelElement.h
r152353 r154481 56 56 }; 57 57 58 inline bool isHTMLLabelElement( Node* node)58 inline bool isHTMLLabelElement(const Node* node) 59 59 { 60 60 return node->hasTagName(HTMLNames::labelTag); 61 61 } 62 62 63 inline bool isHTMLLabelElement( Element* element)63 inline bool isHTMLLabelElement(const Element* element) 64 64 { 65 65 return element->hasTagName(HTMLNames::labelTag); 66 66 } 67 68 template <> inline bool isElementOfType<HTMLLabelElement>(const Element* element) { return isHTMLLabelElement(element); } 67 69 68 70 inline HTMLLabelElement* toHTMLLabelElement(Node* node) -
trunk/Source/WebCore/html/HTMLLegendElement.h
r149960 r154481 46 46 }; 47 47 48 inline bool isHTMLLegendElement(const Node* node) 49 { 50 return node->hasTagName(HTMLNames::legendTag); 51 } 52 53 inline bool isHTMLLegendElement(const Element* element) 54 { 55 return element->hasTagName(HTMLNames::legendTag); 56 } 57 58 template <> inline bool isElementOfType<HTMLLegendElement>(const Element* element) { return isHTMLLegendElement(element); } 59 48 60 } //namespace 49 61 -
trunk/Source/WebCore/html/HTMLMapElement.cpp
r153939 r154481 63 63 { 64 64 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; 75 71 } 76 72 -
trunk/Source/WebCore/html/HTMLMediaElement.cpp
r154449 r154481 536 536 return; 537 537 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); 544 540 #endif 545 541 } -
trunk/Source/WebCore/html/HTMLStyleElement.h
r154271 r154481 94 94 }; 95 95 96 inline bool isHTMLStyleElement( Node* node)96 inline bool isHTMLStyleElement(const Node* node) 97 97 { 98 98 return node->hasTagName(HTMLNames::styleTag); 99 99 } 100 100 101 inline bool isHTMLStyleElement( Element* element)101 inline bool isHTMLStyleElement(const Element* element) 102 102 { 103 103 return element->hasTagName(HTMLNames::styleTag); … … 110 110 } 111 111 112 template <> inline bool isElementOfType<HTMLStyleElement>(const Element* element) { return isHTMLStyleElement(element); } 113 112 114 } //namespace 113 115 -
trunk/Source/WebCore/html/HTMLTitleElement.h
r152567 r154481 63 63 } 64 64 65 template <> inline bool isElementOfType<HTMLTitleElement>(const Element* element) { return isHTMLTitleElement(element); } 66 65 67 } //namespace 66 68 -
trunk/Source/WebCore/html/HTMLTrackElement.h
r153926 r154481 98 98 }; 99 99 100 inline bool isHTMLTrackElement(const Node* node) 101 { 102 return node->hasTagName(HTMLNames::trackTag); 103 } 104 105 inline bool isHTMLTrackElement(const Element* element) 106 { 107 return element->hasTagName(HTMLNames::trackTag); 108 } 109 110 template <> inline bool isElementOfType<HTMLTrackElement>(const Element* element) { return isHTMLTrackElement(element); } 111 112 100 113 } 101 114 -
trunk/Source/WebCore/html/LabelableElement.h
r110927 r154481 51 51 }; 52 52 53 inline bool isLabelableElement(const Node* node) 54 { 55 if (!node->isHTMLElement()) 56 return false; 57 return static_cast<const HTMLElement*>(node)->isLabelable(); 58 } 59 60 template <> inline bool isElementOfType<LabelableElement>(const Element* element) { return isLabelableElement(element); } 61 53 62 } // namespace WebCore 54 63 -
trunk/Source/WebCore/rendering/FilterEffectRenderer.cpp
r154133 r154481 161 161 RefPtr<SVGFilterBuilder> builder = SVGFilterBuilder::create(previousEffect, SourceAlpha::create(this)); 162 162 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)) { 167 164 if (!svgElement->isFilterEffect()) 168 165 continue; -
trunk/Source/WebCore/svg/SVGElement.cpp
r154462 r154481 52 52 #include "SVGRenderSupport.h" 53 53 #include "SVGSVGElement.h" 54 #include "SVGTitleElement.h" 54 55 #include "SVGUseElement.h" 55 56 #include "ScriptEventListener.h" … … 878 879 // If we aren't an instance in a <use> or the <use> title was not found, then find the first 879 880 // <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 886 881 // If a title child was found, return the text contents. 887 if ( titleElement)882 if (SVGTitleElement* titleElement = Traversal<SVGTitleElement>::firstWithin(this)) 888 883 return titleElement->innerText(); 889 884 -
trunk/Source/WebCore/svg/SVGElement.h
r154462 r154481 218 218 } 219 219 220 template <> inline bool isElementOfType<SVGElement>(const Element* element) { return element->isSVGElement(); } 221 220 222 } 221 223 -
trunk/Source/WebCore/svg/SVGForeignObjectElement.h
r154371 r154481 26 26 #include "SVGExternalResourcesRequired.h" 27 27 #include "SVGGraphicsElement.h" 28 #include "SVGNames.h" 28 29 #include "SVGURIReference.h" 29 30 … … 59 60 }; 60 61 62 inline bool isSVGForeignObjectElement(const Node* node) 63 { 64 return node->hasTagName(SVGNames::foreignObjectTag); 65 } 66 67 inline bool isSVGForeignObjectElement(const Element* element) 68 { 69 return element->hasTagName(SVGNames::foreignObjectTag); 70 } 71 72 template <> inline bool isElementOfType<SVGForeignObjectElement>(const Element* element) { return isSVGForeignObjectElement(element); } 73 74 61 75 } // namespace WebCore 62 76 -
trunk/Source/WebCore/svg/SVGSVGElement.cpp
r154358 r154481 343 343 { 344 344 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); 356 353 } 357 358 element = ElementTraversal::next(element, referenceElement ? referenceElement : this); 354 svgElement = Traversal<SVGElement>::next(svgElement, referenceElement ? referenceElement : this); 359 355 } 360 356 return StaticNodeList::adopt(nodes); … … 786 782 // Fall back to traversing our subtree. Duplicate ids are allowed, the first found will 787 783 // 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)) { 793 785 if (element->getIdAttribute() == id) 794 786 return element; -
trunk/Source/WebCore/svg/SVGTitleElement.h
r154462 r154481 24 24 25 25 #include "SVGElement.h" 26 #include "SVGNames.h" 26 27 27 28 namespace WebCore { … … 41 42 }; 42 43 44 template <> inline bool isElementOfType<SVGTitleElement>(const Element* element) { return element->hasTagName(SVGNames::titleTag); } 45 43 46 } // namespace WebCore 44 47 -
trunk/Source/WebCore/svg/animation/SMILTimeContainer.cpp
r153939 r154481 223 223 { 224 224 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++); 229 228 m_documentOrderIndexesDirty = false; 230 229 } -
trunk/Source/WebCore/svg/animation/SVGSMILElement.cpp
r153559 r154481 416 416 } 417 417 418 bool SVGSMILElement::isSMILElement( Node* node)418 bool SVGSMILElement::isSMILElement(const Node* node) 419 419 { 420 420 if (!node) -
trunk/Source/WebCore/svg/animation/SVGSMILElement.h
r154462 r154481 43 43 virtual ~SVGSMILElement(); 44 44 45 static bool isSMILElement( Node*);45 static bool isSMILElement(const Node*); 46 46 47 47 bool isSupportedAttribute(const QualifiedName&); … … 243 243 } 244 244 245 template <> inline bool isElementOfType<SVGSMILElement>(const Element* element) { return SVGSMILElement::isSMILElement(element); } 246 245 247 } 246 248 -
trunk/Source/WebCore/svg/graphics/SVGImage.cpp
r154272 r154481 41 41 #include "RenderStyle.h" 42 42 #include "SVGDocument.h" 43 #include "SVGForeignObjectElement.h" 43 44 #include "SVGImageChromeClient.h" 44 45 #include "SVGSVGElement.h" … … 75 76 76 77 // 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; 81 80 82 81 // Because SVG image rendering disallows external resources and links,
Note: See TracChangeset
for help on using the changeset viewer.