Move traverseLiveNodeListForwardToOffset() to LiveNodeList class

Source/core/html/HTMLCollection.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. 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 269 matching lines @@
 {
     return onlyIncludeDirectChildren ? rootNode.lastChild() : lastDescendent(rootNode);
 }
 
 ALWAYS_INLINE Node* LiveNodeListBase::iterateForPreviousNode(Node* current) const
 {
     bool onlyIncludeDirectChildren = shouldOnlyIncludeDirectChildren();
     CollectionType collectionType = type();
     Node& rootNode = this->rootNode();
     for (; current; current = previousNode(rootNode, *current, onlyIncludeDirectChildren)) {
-        if (isNodeList(collectionType)) {
+        if (isLiveNodeListType(collectionType)) {
             if (current->isElementNode() && isMatchingElement(static_cast<const LiveNodeList*>(this), toElement(current)))
                 return toElement(current);
         } else {
             if (current->isElementNode() && isMatchingElement(static_cast<const HTMLCollection*>(this), toElement(current)))
                 return toElement(current);
         }
     }
     return 0;
 }
 
@@ skipping 34 matching lines @@
 {
     ASSERT(currentOffset < offset);
     Element* next = &currentElement;
     while ((next = nextMatchingElement(nodeList, *next, root))) {
         if (++currentOffset == offset)
             return next;
     }
     return 0;
 }
 
-// FIXME: This should be in ChildNodeList
-inline Node* LiveNodeListBase::traverseChildNodeListForwardToOffset(unsigned offset, Node* currentNode, unsigned& currentOffset) const
+static inline Node* traverseSiblingsForwardToOffset(unsigned offset, Node& currentNode, unsigned& currentOffset)
 {
-    ASSERT(type() == ChildNodeListType);
     ASSERT(currentOffset < offset);
-    while ((currentNode = currentNode->nextSibling())) {
+    Node* next = &currentNode;
+    while ((next = next->nextSibling())) {
         if (++currentOffset == offset)
-            return currentNode;
+            return next;
     }
     return 0;
 }
 
 // FIXME: This should be in LiveNodeList
 inline Element* LiveNodeListBase::traverseLiveNodeListFirstElement(ContainerNode& root) const
 {
-    ASSERT(isNodeList(type()));
+    ASSERT(isLiveNodeListType(type()));
     ASSERT(type() != ChildNodeListType);
     if (type() == HTMLTagNodeListType)
         return firstMatchingElement(static_cast<const HTMLTagNodeList*>(this), root);
     if (type() == ClassNodeListType)
         return firstMatchingElement(static_cast<const ClassNodeList*>(this), root);
     return firstMatchingElement(static_cast<const LiveNodeList*>(this), root);
 }
 
-// FIXME: This should be in LiveNodeList
-inline Element* LiveNodeListBase::traverseLiveNodeListForwardToOffset(unsigned offset, Element& currentElement, unsigned& currentOffset, ContainerNode* root) const
+// FIXME: This should be in LiveNodeList.cpp but it needs to stay here until traverseMatchingElementsForwardToOffset()
+// and others are moved to a separate header.
+inline Node* LiveNodeList::traverseForwardToOffset(unsigned offset, Node& currentNode, unsigned& currentOffset, ContainerNode* root) const
 {
-    ASSERT(isNodeList(type()));
-    ASSERT(type() != ChildNodeListType);
-    if (type() == HTMLTagNodeListType)
-        return traverseMatchingElementsForwardToOffset(static_cast<const HTMLTagNodeList*>(this), offset, currentElement, currentOffset, root);
-    if (type() == ClassNodeListType)
-        return traverseMatchingElementsForwardToOffset(static_cast<const ClassNodeList*>(this), offset, currentElement, currentOffset, root);
-    return traverseMatchingElementsForwardToOffset(static_cast<const LiveNodeList*>(this), offset, currentElement, currentOffset, root);
+    switch (type()) {
+    case ChildNodeListType:
+        return traverseSiblingsForwardToOffset(offset, currentNode, currentOffset);
+    case HTMLTagNodeListType:
+        return traverseMatchingElementsForwardToOffset(static_cast<const HTMLTagNodeList*>(this), offset, toElement(currentNode), currentOffset, root);
+    case ClassNodeListType:
+        return traverseMatchingElementsForwardToOffset(static_cast<const ClassNodeList*>(this), offset, toElement(currentNode), currentOffset, root);
+    default:
+        return traverseMatchingElementsForwardToOffset(this, offset, toElement(currentNode), currentOffset, root);
+    }
 }
 
 bool ALWAYS_INLINE LiveNodeListBase::isLastItemCloserThanLastOrCachedItem(unsigned offset) const
 {
     ASSERT(isLengthCacheValid());
     unsigned distanceFromLastItem = cachedLength() - offset;
     if (!isItemCacheValid())
         return distanceFromLastItem < offset;
 
     return cachedItemOffset() < offset && distanceFromLastItem < offset - cachedItemOffset();
@@ skipping 37 matching lines @@
     }
 
     if (isLengthCacheValid() && !overridesItemAfter() && isLastItemCloserThanLastOrCachedItem(offset)) {
         Node* lastItem = itemBefore(0);
         ASSERT(lastItem);
         setItemCache(lastItem, cachedLength() - 1);
     } else if (!isItemCacheValid() || isFirstItemCloserThanCachedItem(offset) || (overridesItemAfter() && offset < cachedItemOffset())) {
         Node* firstItem;
         if (type() == ChildNodeListType)
             firstItem = root->firstChild();
-        else if (isNodeList(type()))
+        else if (isLiveNodeListType(type()))
             firstItem = traverseLiveNodeListFirstElement(*root);
         else
             firstItem = static_cast<const HTMLCollection*>(this)->traverseFirstElement(*root);
 
         if (!firstItem) {
             setLengthCache(0);
             return 0;
         }
         setItemCache(firstItem, 0);
         ASSERT(!cachedItemOffset());
@@ skipping 19 matching lines @@
             currentOffset--;
             if (currentOffset == offset) {
                 setItemCache(currentItem, currentOffset);
                 return currentItem;
             }
         }
         ASSERT_NOT_REACHED();
         return 0;
     }
 
-    if (type() == ChildNodeListType)
-        currentItem = traverseChildNodeListForwardToOffset(offset, currentItem, currentOffset);
-    else if (isNodeList(type()))
-        currentItem = traverseLiveNodeListForwardToOffset(offset, toElement(*currentItem), currentOffset, root);
+    if (isLiveNodeListType(type()))
+        currentItem = static_cast<const LiveNodeList*>(this)->traverseForwardToOffset(offset, *currentItem, currentOffset, root);
     else
         currentItem = static_cast<const HTMLCollection*>(this)->traverseForwardToOffset(offset, toElement(*currentItem), currentOffset, root);
 
     if (!currentItem) {
         // Did not find the item. On plus side, we now know the length.
         setLengthCache(currentOffset + 1);
         return 0;
     }
     setItemCache(currentItem, currentOffset);
     return currentItem;
@@ skipping 166 matching lines @@
 
 void HTMLCollection::append(NodeCacheMap& map, const AtomicString& key, Element* element)
 {
     OwnPtr<Vector<Element*> >& vector = map.add(key.impl(), nullptr).iterator->value;
     if (!vector)
         vector = adoptPtr(new Vector<Element*>);
     vector->append(element);
 }
 
 } // namespace WebCore