Have LiveNodeList::rootNode() return a reference

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 235 matching lines @@
 template <> inline bool isMatchingElement(const HTMLTagNodeList* nodeList, Element* element)
 {
     return nodeList->nodeMatchesInlined(element);
 }
 
 template <> inline bool isMatchingElement(const ClassNodeList* nodeList, Element* element)
 {
     return nodeList->nodeMatchesInlined(element);
 }
 
-static Node* previousNode(Node* base, Node* previous, bool onlyIncludeDirectChildren)
+static Node* previousNode(Node& base, Node& previous, bool onlyIncludeDirectChildren)
 {
-    return onlyIncludeDirectChildren ? previous->previousSibling() : NodeTraversal::previous(previous, base);
+    return onlyIncludeDirectChildren ? previous.previousSibling() : NodeTraversal::previous(&previous, &base);
 }
 
-static inline Node* lastDescendent(Node* node)
+static inline Node* lastDescendent(Node& node)
 {
-    node = node->lastChild();
-    for (Node* current = node; current; current = current->lastChild())
-        node = current;
-    return node;
+    Node* descendent = node.lastChild();
+    for (Node* current = descendent; current; current = current->lastChild())
+        descendent = current;
+    return descendent;
 }
 
-static Node* lastNode(Node* rootNode, bool onlyIncludeDirectChildren)
+static Node* lastNode(Node& rootNode, bool onlyIncludeDirectChildren)
 {
-    return onlyIncludeDirectChildren ? rootNode->lastChild() : lastDescendent(rootNode);
+    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)) {
+    Node& rootNode = this->rootNode();
+    for (; current; current = previousNode(rootNode, *current, onlyIncludeDirectChildren)) {
         if (isNodeList(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;
 }
 
 ALWAYS_INLINE Node* LiveNodeListBase::itemBefore(Node* previous) const
 {
     Node* current;
     if (LIKELY(!!previous)) // Without this LIKELY, length() and item() can be 10% slower.
-        current = previousNode(rootNode(), previous, shouldOnlyIncludeDirectChildren());
+        current = previousNode(rootNode(), *previous, shouldOnlyIncludeDirectChildren());
     else
         current = lastNode(rootNode(), shouldOnlyIncludeDirectChildren());
 
     if (type() == ChildNodeListType)
         return current;
     return iterateForPreviousNode(current);
 }
 
 template <class NodeListType>
 inline Element* firstMatchingElement(const NodeListType* nodeList, ContainerNode* root)
@@ skipping 372 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