Have HTMLCollection::item() return an Element as per specification

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 273 matching lines @@
     for (Node* current = descendant; current; current = current->lastChild())
         descendant = current;
     return descendant;
 }
 
 static Node* lastNode(const Node& rootNode, bool onlyIncludeDirectChildren)
 {
     return onlyIncludeDirectChildren ? rootNode.lastChild() : lastDescendant(rootNode);
 }
 
-ALWAYS_INLINE Node* LiveNodeListBase::iterateForPreviousNode(Node* current) const
+template <typename Collection>
+ALWAYS_INLINE Element* LiveNodeListBase::iterateForPreviousNode(const Collection& collection, Node* current)
 {
-    bool onlyIncludeDirectChildren = shouldOnlyIncludeDirectChildren();
-    CollectionType collectionType = type();
-    Node& rootNode = this->rootNode();
+    bool onlyIncludeDirectChildren = collection.shouldOnlyIncludeDirectChildren();
+    Node& rootNode = collection.rootNode();
     for (; current; current = previousNode(rootNode, *current, onlyIncludeDirectChildren)) {
-        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);
-        }
+        if (current->isElementNode() && isMatchingElement(collection, toElement(*current)))
+            return toElement(current);
     }
     return 0;
 }
 
-Node* LiveNodeListBase::itemBefore(const Node* previous) const
+template <typename Collection>
+Element* LiveNodeListBase::itemBefore(const Collection& collection, const Node* previous)
 {
     Node* current;
     if (LIKELY(!!previous)) // Without this LIKELY, length() and item() can be 10% slower.
-        current = previousNode(rootNode(), *previous, shouldOnlyIncludeDirectChildren());
+        current = previousNode(collection.rootNode(), *previous, collection.shouldOnlyIncludeDirectChildren());
     else
-        current = lastNode(rootNode(), shouldOnlyIncludeDirectChildren());
+        current = lastNode(collection.rootNode(), collection.shouldOnlyIncludeDirectChildren());
 
+    return iterateForPreviousNode(collection, current);
+}
+
+Node* LiveNodeList::itemBefore(const Node* previous) const
+{
     if (type() == ChildNodeListType)
-        return current;
-    return iterateForPreviousNode(current);
+        return LIKELY(!!previous) ? previous->previousSibling() : rootNode().lastChild();
+    return LiveNodeListBase::itemBefore(*this, previous);
+}
+
+Element* HTMLCollection::itemBefore(const Node* 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);
     return element;
 }
@@ skipping 118 matching lines @@
 
 inline Element* HTMLCollection::traverseNextElement(Element& previous, const ContainerNode& root) const
 {
     if (overridesItemAfter())
         return virtualItemAfter(&previous);
     if (shouldOnlyIncludeDirectChildren())
         return nextMatchingChildElement(*this, previous, root);
     return nextMatchingElement(*this, previous, root);
 }
 
-Element* HTMLCollection::traverseForwardToOffset(unsigned offset, Node& currentElement, unsigned& currentOffset, const ContainerNode& root) const
+Element* HTMLCollection::traverseForwardToOffset(unsigned offset, Element& currentElement, unsigned& currentOffset, const ContainerNode& root) const
 {
     ASSERT(currentOffset < offset);
     if (overridesItemAfter()) {
-        Element* next = &toElement(currentElement);
+        Element* next = &currentElement;
         while ((next = virtualItemAfter(next))) {
             if (++currentOffset == offset)
                 return next;
         }
         return 0;
     }
     if (shouldOnlyIncludeDirectChildren()) {
-        Element* next = &toElement(currentElement);
+        Element* next = &currentElement;
         while ((next = nextMatchingChildElement(*this, *next, root))) {
             if (++currentOffset == offset)
                 return next;
         }
         return 0;
     }
-    return traverseMatchingElementsForwardToOffset(*this, offset, toElement(currentElement), currentOffset, root);
+    return traverseMatchingElementsForwardToOffset(*this, offset, currentElement, currentOffset, root);
 }
 
 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.
 
@@ skipping 59 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