Move matching Element traversal functions from LiveNodeListBase to ElementTraversal

Source/core/html/HTMLCollection.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003-2008, 2011, 2012, 2014 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Samsung Electronics. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 237 matching lines @@
     case WindowNamedItems:
     case NameNodeListType:
     case RadioNodeListType:
     case RadioImgNodeListType:
     case LabelsNodeListType:
         ASSERT_NOT_REACHED();
     }
     return false;
 }
 
-template <class NodeListType>
-inline bool isMatchingElement(const NodeListType&, const Element&);
-
-template <> inline bool isMatchingElement(const HTMLCollection& htmlCollection, const Element& element)
+inline bool HTMLCollection::elementMatches(const Element& element) const
 {
     // These collections apply to any kind of Elements, not just HTMLElements.
-    switch (htmlCollection.type()) {
+    switch (type()) {
     case DocAll:
     case NodeChildren:
         return true;
     case ClassCollectionType:
-        return toClassCollection(htmlCollection).elementMatches(element);
+        return toClassCollection(*this).elementMatches(element);
     case TagCollectionType:
-        return toTagCollection(htmlCollection).elementMatches(element);
+        return toTagCollection(*this).elementMatches(element);
     case HTMLTagCollectionType:
-        return toHTMLTagCollection(htmlCollection).elementMatches(element);
+        return toHTMLTagCollection(*this).elementMatches(element);
     case DocumentNamedItems:
-        return toDocumentNameCollection(htmlCollection).elementMatches(element);
+        return toDocumentNameCollection(*this).elementMatches(element);
     case WindowNamedItems:
-        return toWindowNameCollection(htmlCollection).elementMatches(element);
+        return toWindowNameCollection(*this).elementMatches(element);
     default:
         break;
     }
 
     // The following only applies to HTMLElements.
-    return element.isHTMLElement() && isMatchingHTMLElement(htmlCollection, toHTMLElement(element));
+    return element.isHTMLElement() && isMatchingHTMLElement(*this, toHTMLElement(element));
 }
 
-template <> inline bool isMatchingElement(const ClassCollection& collection, const Element& element)
-{
-    return collection.elementMatches(element);
-}
+template <class HTMLCollectionType>
+class IsMatch {
+public:
+    IsMatch(const HTMLCollectionType& list)
+        : m_list(list)
+    { }
 
-template <> inline bool isMatchingElement(const HTMLTagCollection& collection, const Element& element)
-{
-    return collection.elementMatches(element);
-}
+    bool operator() (Element& element) const
+    {
+        return m_list.elementMatches(element);
+    }
+
+private:
+    const HTMLCollectionType& m_list;
+};
 
 Element* HTMLCollection::virtualItemAfter(Element*) const
 {
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 static inline bool nameShouldBeVisibleInDocumentAll(const HTMLElement& element)
 {
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/common-dom-interfaces.html#dom-htmlallcollection-nameditem:
     // The document.all collection returns only certain types of elements by name,
     // although it returns any type of element by id.
     return element.hasTagName(aTag)
         || element.hasTagName(appletTag)
         || element.hasTagName(areaTag)
         || element.hasTagName(embedTag)
         || element.hasTagName(formTag)
         || element.hasTagName(frameTag)
         || element.hasTagName(framesetTag)
         || element.hasTagName(iframeTag)
         || element.hasTagName(imgTag)
         || element.hasTagName(inputTag)
         || element.hasTagName(objectTag)
         || element.hasTagName(selectTag);
 }
 
-inline Element* firstMatchingChildElement(const HTMLCollection& nodeList)
-{
-    Element* element = ElementTraversal::firstChild(nodeList.rootNode());
-    while (element && !isMatchingElement(nodeList, *element))
-        element = ElementTraversal::nextSibling(*element);
-    return element;
-}
-
-inline Element* lastMatchingChildElement(const HTMLCollection& nodeList)
-{
-    Element* element = ElementTraversal::lastChild(nodeList.rootNode());
-    while (element && !isMatchingElement(nodeList, *element))
-        element = ElementTraversal::previousSibling(*element);
-    return element;
-}
-
-inline Element* nextMatchingChildElement(const HTMLCollection& nodeList, Element& current)
-{
-    Element* next = &current;
-    do {
-        next = ElementTraversal::nextSibling(*next);
-    } while (next && !isMatchingElement(nodeList, *next));
-    return next;
-}
-
-inline Element* previousMatchingChildElement(const HTMLCollection& nodeList, Element& current)
-{
-    Element* previous = &current;
-    do {
-        previous = ElementTraversal::previousSibling(*previous);
-    } while (previous && !isMatchingElement(nodeList, *previous));
-    return previous;
-}
-
 Element* HTMLCollection::traverseToFirstElement() const
 {
     switch (type()) {
     case HTMLTagCollectionType:
-        return firstMatchingElement(toHTMLTagCollection(*this));
+        return ElementTraversal::firstWithin(rootNode(), IsMatch<HTMLTagCollection>(toHTMLTagCollection(*this)));
     case ClassCollectionType:
-        return firstMatchingElement(toClassCollection(*this));
+        return ElementTraversal::firstWithin(rootNode(), IsMatch<ClassCollection>(toClassCollection(*this)));
     default:
         if (overridesItemAfter())
             return virtualItemAfter(0);
         if (shouldOnlyIncludeDirectChildren())
-            return firstMatchingChildElement(*this);
-        return firstMatchingElement(*this);
+            return ElementTraversal::firstChild(rootNode(), IsMatch<HTMLCollection>(*this));
+        return ElementTraversal::firstWithin(rootNode(), IsMatch<HTMLCollection>(*this));
     }
 }
 
 Element* HTMLCollection::traverseToLastElement() const
 {
     ASSERT(canTraverseBackward());
     if (shouldOnlyIncludeDirectChildren())
-        return lastMatchingChildElement(*this);
-    return lastMatchingElement(*this);
+        return ElementTraversal::lastChild(rootNode(), IsMatch<HTMLCollection>(*this));
+    return ElementTraversal::lastWithin(rootNode(), IsMatch<HTMLCollection>(*this));
 }
 
 Element* HTMLCollection::traverseForwardToOffset(unsigned offset, Element& currentElement, unsigned& currentOffset) const
 {
     ASSERT(currentOffset < offset);
     switch (type()) {
     case HTMLTagCollectionType:
-        return traverseMatchingElementsForwardToOffset(toHTMLTagCollection(*this), offset, currentElement, currentOffset);
+        return traverseMatchingElementsForwardToOffset(currentElement, &rootNode(), offset, currentOffset, IsMatch<HTMLTagCollection>(toHTMLTagCollection(*this)));
     case ClassCollectionType:
-        return traverseMatchingElementsForwardToOffset(toClassCollection(*this), offset, currentElement, currentOffset);
+        return traverseMatchingElementsForwardToOffset(currentElement, &rootNode(), offset, currentOffset, IsMatch<ClassCollection>(toClassCollection(*this)));
     default:
         if (overridesItemAfter()) {
             for (Element* next = virtualItemAfter(&currentElement); next; next = virtualItemAfter(next)) {
                 if (++currentOffset == offset)
                     return next;
             }
             return 0;
         }
         if (shouldOnlyIncludeDirectChildren()) {
-            for (Element* next = nextMatchingChildElement(*this, currentElement); next; next = nextMatchingChildElement(*this, *next)) {
+            IsMatch<HTMLCollection> isMatch(*this);
+            for (Element* next = ElementTraversal::nextSibling(currentElement, isMatch); next; next = ElementTraversal::nextSibling(*next, isMatch)) {
                 if (++currentOffset == offset)
                     return next;
             }
             return 0;
         }
-        return traverseMatchingElementsForwardToOffset(*this, offset, currentElement, currentOffset);
+        return traverseMatchingElementsForwardToOffset(currentElement, &rootNode(), offset, currentOffset, IsMatch<HTMLCollection>(*this));
     }
 }
 
 Element* HTMLCollection::traverseBackwardToOffset(unsigned offset, Element& currentElement, unsigned& currentOffset) const
 {
     ASSERT(currentOffset > offset);
     ASSERT(canTraverseBackward());
     if (shouldOnlyIncludeDirectChildren()) {
-        for (Element* previous = previousMatchingChildElement(*this, currentElement); previous; previous = previousMatchingChildElement(*this, *previous)) {
+        IsMatch<HTMLCollection> isMatch(*this);
+        for (Element* previous = ElementTraversal::previousSibling(currentElement, isMatch); previous; previous = ElementTraversal::previousSibling(*previous, isMatch)) {
             if (--currentOffset == offset)
                 return previous;
         }
         return 0;
     }
-    return traverseMatchingElementsBackwardToOffset(*this, offset, currentElement, currentOffset);
+    return traverseMatchingElementsBackwardToOffset(currentElement, &rootNode(), offset, currentOffset, IsMatch<HTMLCollection>(*this));
 }
 
 Element* HTMLCollection::namedItem(const AtomicString& name) const
 {
     // http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/nameditem.asp
     // This method first searches for an object with a matching id
     // attribute. If a match is not found, the method then searches for an
     // object with a matching name attribute, but only on those elements
     // that are allowed a name attribute.
     updateIdNameCache();
@@ skipping 97 matching lines @@
 }
 
 void HTMLCollection::trace(Visitor* visitor)
 {
     visitor->trace(m_namedItemCache);
     visitor->trace(m_collectionIndexCache);
     LiveNodeListBase::trace(visitor);
 }
 
 } // namespace blink