Have ChildNodeList subclass NodeList instead of LiveNodeList

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 47 matching lines @@
     case SelectedOptions:
     case DataListOptions:
     case WindowNamedItems:
     case FormControls:
         return false;
     case NodeChildren:
     case TRCells:
     case TSectionRows:
     case TableTBodies:
         return true;
-    case ChildNodeListType:
     case NameNodeListType:
     case RadioNodeListType:
     case RadioImgNodeListType:
     case LabelsNodeListType:
         break;
     }
     ASSERT_NOT_REACHED();
     return false;
 }
 
@@ skipping 18 matching lines @@
     case NodeChildren:
     case TableTBodies:
     case TSectionRows:
     case TableRows:
     case TRCells:
     case SelectOptions:
     case SelectedOptions:
     case DataListOptions:
     case MapAreas:
         return NodeListIsRootedAtNode;
-    case ChildNodeListType:
     case NameNodeListType:
     case RadioNodeListType:
     case RadioImgNodeListType:
     case LabelsNodeListType:
         break;
     }
     ASSERT_NOT_REACHED();
     return NodeListIsRootedAtNode;
 }
 
@@ skipping 25 matching lines @@
     case DocLinks:
         return InvalidateOnHRefAttrChange;
     case WindowNamedItems:
         return InvalidateOnIdNameAttrChange;
     case DocumentNamedItems:
         return InvalidateOnIdNameAttrChange;
     case FormControls:
         return InvalidateForFormControls;
     case ClassCollectionType:
         return InvalidateOnClassAttrChange;
-    case ChildNodeListType:
     case NameNodeListType:
     case RadioNodeListType:
     case RadioImgNodeListType:
     case LabelsNodeListType:
         break;
     }
     ASSERT_NOT_REACHED();
     return DoNotInvalidateOnAttributeChanges;
 }
 
@@ skipping 88 matching lines @@
         return element.hasLocalName(aTag) && element.fastHasAttribute(nameAttr);
     case ClassCollectionType:
     case TagCollectionType:
     case HTMLTagCollectionType:
     case DocAll:
     case NodeChildren:
     case FormControls:
     case DocumentNamedItems:
     case TableRows:
     case WindowNamedItems:
-    case ChildNodeListType:
     case NameNodeListType:
     case RadioNodeListType:
     case RadioImgNodeListType:
     case LabelsNodeListType:
         ASSERT_NOT_REACHED();
     }
     return false;
 }
 
 template <> inline bool isMatchingElement(const ClassCollection& collection, const Element& element)
@@ skipping 35 matching lines @@
     bool onlyIncludeDirectChildren = collection.shouldOnlyIncludeDirectChildren();
     Node& rootNode = collection.rootNode();
     for (; current; current = previousNode(rootNode, *current, onlyIncludeDirectChildren)) {
         if (current->isElementNode() && isMatchingElement(collection, toElement(*current)))
             return toElement(current);
     }
     return 0;
 }
 
 template <typename Collection>
-Element* LiveNodeListBase::itemBefore(const Collection& collection, const Node* previous)
+Element* LiveNodeListBase::itemBefore(const Collection& collection, const Element* previous)
 {
     Node* current;
     if (LIKELY(!!previous)) // Without this LIKELY, length() and item() can be 10% slower.
         current = previousNode(collection.rootNode(), *previous, collection.shouldOnlyIncludeDirectChildren());
     else
         current = lastNode(collection.rootNode(), collection.shouldOnlyIncludeDirectChildren());
 
     return iterateForPreviousNode(collection, current);
 }
 
-Node* LiveNodeList::itemBefore(const Node* previous) const
+Element* LiveNodeList::itemBefore(const Element* previous) const
 {
-    if (type() == ChildNodeListType)
-        return LIKELY(!!previous) ? previous->previousSibling() : rootNode().lastChild();
     return LiveNodeListBase::itemBefore(*this, previous);
 }
 
-Element* HTMLCollection::itemBefore(const Node* previous) const
+Element* HTMLCollection::itemBefore(const Element* previous) const
 {
     return LiveNodeListBase::itemBefore(*this, previous);
 }
 
 template <class NodeListType>
 inline Element* firstMatchingElement(const NodeListType& nodeList, const ContainerNode& root)
 {
     Element* element = ElementTraversal::firstWithin(root);
     while (element && !isMatchingElement(nodeList, *element))
         element = ElementTraversal::next(*element, &root);
@@ skipping 15 matching lines @@
 {
     ASSERT(currentOffset < offset);
     Element* next = &currentElement;
     while ((next = nextMatchingElement(nodeList, *next, root))) {
         if (++currentOffset == offset)
             return next;
     }
     return 0;
 }
 
-static inline Node* traverseSiblingsForwardToOffset(unsigned offset, Node& currentNode, unsigned& currentOffset)
-{
-    ASSERT(currentOffset < offset);
-    Node* next = &currentNode;
-    while ((next = next->nextSibling())) {
-        if (++currentOffset == offset)
-            return next;
-    }
-    return 0;
-}
-
 // FIXME: This should be in LiveNodeList.cpp but it needs to stay here until firstMatchingElement()
 // and others are moved to a separate header.
-Node* LiveNodeList::traverseToFirstElement(const ContainerNode& root) const
+Element* LiveNodeList::traverseToFirstElement(const ContainerNode& root) const
 {
-    ASSERT(isLiveNodeListType(type()));
-    switch (type()) {
-    case ChildNodeListType:
-        return root.firstChild();
-    default:
-        return firstMatchingElement(static_cast<const LiveNodeList&>(*this), root);
-    }
+    return firstMatchingElement(*this, root);
 }
 
 // FIXME: This should be in LiveNodeList.cpp but it needs to stay here until traverseMatchingElementsForwardToOffset()
 // and others are moved to a separate header.
-Node* LiveNodeList::traverseForwardToOffset(unsigned offset, Node& currentNode, unsigned& currentOffset, const ContainerNode& root) const
+Element* LiveNodeList::traverseForwardToOffset(unsigned offset, Element& currentNode, unsigned& currentOffset, const ContainerNode& root) const
 {
-    switch (type()) {
-    case ChildNodeListType:
-        return traverseSiblingsForwardToOffset(offset, currentNode, currentOffset);
-    default:
-        return traverseMatchingElementsForwardToOffset(*this, offset, toElement(currentNode), currentOffset, root);
-    }
+    return traverseMatchingElementsForwardToOffset(*this, offset, currentNode, currentOffset, root);
 }
 
 Element* HTMLCollection::virtualItemAfter(Element*) const
 {
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 static inline bool nameShouldBeVisibleInDocumentAll(const HTMLElement& element)
 {
@@ skipping 164 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