Have ElementTraversal / NodeTraversal's next() methods take a reference

Source/core/dom/SelectorQuery.cpp

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 64 matching lines @@
     {
         Node* current = m_currentElement;
         ASSERT(current);
         m_currentElement = nextInternal(ElementTraversal::nextSkippingChildren(m_currentElement, m_rootNode));
         return current;
     }
 
 private:
     Element* nextInternal(Element* element)
     {
-        for (; element; element = ElementTraversal::next(element, m_rootNode)) {
+        for (; element; element = ElementTraversal::next(*element, m_rootNode)) {
             if (element->hasClass() && element->classNames().contains(m_className))
                 return element;
         }
         return 0;
     }
 
     const AtomicString& m_className;
     Node* m_rootNode;
     Element* m_currentElement;
 };
 
 class ClassElementList : public SimpleNodeList {
 public:
     ClassElementList(Node* rootNode, const AtomicString& className)
         : m_className(className)
         , m_rootNode(rootNode)
         , m_currentElement(nextInternal(ElementTraversal::firstWithin(rootNode))) { }
 
     bool isEmpty() const { return !m_currentElement; }
 
     Node* next()
     {
         Node* current = m_currentElement;
         ASSERT(current);
-        m_currentElement = nextInternal(ElementTraversal::next(m_currentElement, m_rootNode));
+        m_currentElement = nextInternal(ElementTraversal::next(*m_currentElement, m_rootNode));
         return current;
     }
 
 private:
     Element* nextInternal(Element* element)
     {
-        for (; element; element = ElementTraversal::next(element, m_rootNode)) {
+        for (; element; element = ElementTraversal::next(*element, m_rootNode)) {
             if (element->hasClass() && element->classNames().contains(m_className))
                 return element;
         }
         return 0;
     }
 
     const AtomicString& m_className;
     Node* m_rootNode;
     Element* m_currentElement;
 };
@@ skipping 52 matching lines @@
 }
 
 static inline bool isTreeScopeRoot(Node* node)
 {
     ASSERT(node);
     return node->isDocumentNode() || node->isShadowRoot();
 }
 
 void SelectorDataList::collectElementsByClassName(Node& rootNode, const AtomicString& className, Vector<RefPtr<Node> >& traversalRoots) const
 {
-    for (Element* element = ElementTraversal::firstWithin(&rootNode); element; element = ElementTraversal::next(element, &rootNode)) {
+    for (Element* element = ElementTraversal::firstWithin(&rootNode); element; element = ElementTraversal::next(*element, &rootNode)) {
         if (element->hasClass() && element->classNames().contains(className))
             traversalRoots.append(element);
     }
 }
 
 void SelectorDataList::collectElementsByTagName(Node& rootNode, const QualifiedName& tagName, Vector<RefPtr<Node> >& traversalRoots) const
 {
-    for (Element* element = ElementTraversal::firstWithin(&rootNode); element; element = ElementTraversal::next(element, &rootNode)) {
+    for (Element* element = ElementTraversal::firstWithin(&rootNode); element; element = ElementTraversal::next(*element, &rootNode)) {
         if (SelectorChecker::tagMatches(*element, tagName))
             traversalRoots.append(element);
     }
 }
 
 Element* SelectorDataList::findElementByClassName(Node& rootNode, const AtomicString& className) const
 {
-    for (Element* element = ElementTraversal::firstWithin(&rootNode); element; element = ElementTraversal::next(element, &rootNode)) {
+    for (Element* element = ElementTraversal::firstWithin(&rootNode); element; element = ElementTraversal::next(*element, &rootNode)) {
         if (element->hasClass() && element->classNames().contains(className))
             return element;
     }
     return 0;
 }
 
 Element* SelectorDataList::findElementByTagName(Node& rootNode, const QualifiedName& tagName) const
 {
-    for (Element* element = ElementTraversal::firstWithin(&rootNode); element; element = ElementTraversal::next(element, &rootNode)) {
+    for (Element* element = ElementTraversal::firstWithin(&rootNode); element; element = ElementTraversal::next(*element, &rootNode)) {
         if (SelectorChecker::tagMatches(*element, tagName))
             return element;
     }
     return 0;
 }
 
 inline bool SelectorDataList::canUseFastQuery(const Node& rootNode) const
 {
     return m_selectors.size() == 1 && rootNode.inDocument() && !rootNode.document().inQuirksMode();
 }
@@ skipping 70 matching lines @@
         else
             startFromParent = false;
     }
 
     matchTraverseRoots = false;
     return adoptPtr(new SingleNodeList(rootNode));
 }
 
 void SelectorDataList::executeSlowQueryAll(Node& rootNode, Vector<RefPtr<Node> >& matchedElements) const
 {
-    for (Element* element = ElementTraversal::firstWithin(&rootNode); element; element = ElementTraversal::next(element, &rootNode)) {
+    for (Element* element = ElementTraversal::firstWithin(&rootNode); element; element = ElementTraversal::next(*element, &rootNode)) {
         for (unsigned i = 0; i < m_selectors.size(); ++i) {
             if (selectorMatches(m_selectors[i], *element, rootNode)) {
                 matchedElements.append(element);
                 break;
             }
         }
     }
 }
 
 void SelectorDataList::executeQueryAll(Node& rootNode, Vector<RefPtr<Node> >& matchedElements) const
@@ skipping 40 matching lines @@
             Node& node = *traverseRoots->next();
             Element& element = toElement(node);
             if (selectorMatches(selector, element, rootNode))
                 matchedElements.append(&element);
         }
         return;
     }
 
     while (!traverseRoots->isEmpty()) {
         Node* traverseRoot = traverseRoots->next();
-        for (Element* element = ElementTraversal::firstWithin(traverseRoot); element; element = ElementTraversal::next(element, traverseRoot)) {
+        for (Element* element = ElementTraversal::firstWithin(traverseRoot); element; element = ElementTraversal::next(*element, traverseRoot)) {
             if (selectorMatches(selector, *element, rootNode))
                 matchedElements.append(element);
         }
     }
 }
 
 // If matchTraverseRoot is true, the returned Node is the single Element that may match the selector query.
 //
 // If matchTraverseRoot is false, the returned Node is the rootNode parameter or a descendant of rootNode representing
 // the subtree for which we can limit the querySelector traversal.
@@ skipping 33 matching lines @@
             startFromParent = true;
         else
             startFromParent = false;
     }
     matchTraverseRoot = false;
     return &rootNode;
 }
 
 Element* SelectorDataList::executeSlowQueryFirst(Node& rootNode) const
 {
-    for (Element* element = ElementTraversal::firstWithin(&rootNode); element; element = ElementTraversal::next(element, &rootNode)) {
+    for (Element* element = ElementTraversal::firstWithin(&rootNode); element; element = ElementTraversal::next(*element, &rootNode)) {
         for (unsigned i = 0; i < m_selectors.size(); ++i) {
             if (selectorMatches(m_selectors[i], *element, rootNode))
                 return element;
         }
     }
     return 0;
 }
 
 Element* SelectorDataList::executeQueryFirst(Node& rootNode) const
 {
@@ skipping 28 matching lines @@
     Node* traverseRootNode = findTraverseRoot(rootNode, matchTraverseRoot);
     if (!traverseRootNode)
         return 0;
     if (matchTraverseRoot) {
         ASSERT(m_selectors.size() == 1);
         ASSERT(traverseRootNode->isElementNode());
         Element& element = toElement(*traverseRootNode);
         return selectorMatches(m_selectors[0], element, rootNode) ? &element : 0;
     }
 
-    for (Element* element = ElementTraversal::firstWithin(traverseRootNode); element; element = ElementTraversal::next(element, traverseRootNode)) {
+    for (Element* element = ElementTraversal::firstWithin(traverseRootNode); element; element = ElementTraversal::next(*element, traverseRootNode)) {
         if (selectorMatches(m_selectors[0], *element, rootNode))
             return element;
     }
     return 0;
 }
 
 SelectorQuery::SelectorQuery(const CSSSelectorList& selectorList)
     : m_selectorList(selectorList)
 {
     m_selectors.initialize(m_selectorList);
@@ skipping 44 matching lines @@
     m_entries.add(selectors, selectorQuery.release());
     return rawSelectorQuery;
 }
 
 void SelectorQueryCache::invalidate()
 {
     m_entries.clear();
 }
 
 }