First argument to DOM traversal functions should be a reference
authorcdumez@apple.com <cdumez@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 26 Jan 2015 22:36:36 +0000 (22:36 +0000)
committercdumez@apple.com <cdumez@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 26 Jan 2015 22:36:36 +0000 (22:36 +0000)
https://bugs.webkit.org/show_bug.cgi?id=140895

Reviewed by Antti Koivisto.

First argument to DOM traversal functions should be a reference instead
of a pointer as it is dereferenced without null-check.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@179143 268f45cc-cd09-0410-ab3c-d52691b4dbfc

80 files changed:
Source/WebCore/ChangeLog
Source/WebCore/WebCore.exp.in
Source/WebCore/accessibility/AccessibilityObject.cpp
Source/WebCore/bindings/js/JSDocumentCustom.cpp
Source/WebCore/css/SelectorChecker.cpp
Source/WebCore/dom/Attr.cpp
Source/WebCore/dom/CharacterData.cpp
Source/WebCore/dom/ContainerNode.cpp
Source/WebCore/dom/Document.cpp
Source/WebCore/dom/DocumentMarkerController.cpp
Source/WebCore/dom/Element.cpp
Source/WebCore/dom/ElementChildIterator.h
Source/WebCore/dom/ElementDescendantIterator.h
Source/WebCore/dom/ElementIterator.h
Source/WebCore/dom/ElementTraversal.h
Source/WebCore/dom/InlineStyleSheetOwner.cpp
Source/WebCore/dom/Node.cpp
Source/WebCore/dom/NodeIterator.cpp
Source/WebCore/dom/NodeTraversal.cpp
Source/WebCore/dom/NodeTraversal.h
Source/WebCore/dom/Range.cpp
Source/WebCore/dom/ScriptElement.cpp
Source/WebCore/dom/ShadowRoot.cpp
Source/WebCore/dom/Text.cpp
Source/WebCore/dom/TextNodeTraversal.cpp
Source/WebCore/dom/TextNodeTraversal.h
Source/WebCore/dom/TreeScopeAdopter.cpp
Source/WebCore/dom/TreeWalker.cpp
Source/WebCore/dom/TypedElementDescendantIterator.h
Source/WebCore/editing/ApplyStyleCommand.cpp
Source/WebCore/editing/BreakBlockquoteCommand.cpp
Source/WebCore/editing/CompositeEditCommand.cpp
Source/WebCore/editing/DeleteSelectionCommand.cpp
Source/WebCore/editing/EditCommand.cpp
Source/WebCore/editing/EditingStyle.cpp
Source/WebCore/editing/Editor.cpp
Source/WebCore/editing/IndentOutdentCommand.cpp
Source/WebCore/editing/InsertListCommand.cpp
Source/WebCore/editing/InsertParagraphSeparatorCommand.cpp
Source/WebCore/editing/ReplaceSelectionCommand.cpp
Source/WebCore/editing/ReplaceSelectionCommand.h
Source/WebCore/editing/SimplifyMarkupCommand.cpp
Source/WebCore/editing/TextIterator.cpp
Source/WebCore/editing/VisibleUnits.cpp
Source/WebCore/editing/cocoa/HTMLConverter.mm
Source/WebCore/editing/htmlediting.cpp
Source/WebCore/editing/ios/EditorIOS.mm
Source/WebCore/editing/mac/EditorMac.mm
Source/WebCore/editing/markup.cpp
Source/WebCore/html/HTMLCollection.cpp
Source/WebCore/html/HTMLElement.cpp
Source/WebCore/html/HTMLFieldSetElement.cpp
Source/WebCore/html/HTMLOptionElement.cpp
Source/WebCore/html/HTMLSelectElement.cpp
Source/WebCore/html/HTMLTableElement.cpp
Source/WebCore/html/HTMLTableRowsCollection.cpp
Source/WebCore/html/HTMLTableRowsCollection.h
Source/WebCore/html/HTMLTextAreaElement.cpp
Source/WebCore/html/HTMLTextFormControlElement.cpp
Source/WebCore/html/HTMLTitleElement.cpp
Source/WebCore/html/RadioInputType.cpp
Source/WebCore/html/TextFieldInputType.cpp
Source/WebCore/html/track/VTTCue.cpp
Source/WebCore/inspector/InspectorNodeFinder.cpp
Source/WebCore/page/FocusController.cpp
Source/WebCore/page/FocusController.h
Source/WebCore/page/Frame.cpp
Source/WebCore/page/ios/FrameIOS.mm
Source/WebCore/rendering/RenderCounter.cpp
Source/WebCore/rendering/RenderListItem.cpp
Source/WebCore/rendering/RenderNamedFlowThread.cpp
Source/WebCore/rendering/RenderView.cpp
Source/WebCore/xml/XPathNodeSet.cpp
Source/WebCore/xml/XPathStep.cpp
Source/WebCore/xml/XPathUtil.cpp
Source/WebKit/mac/ChangeLog
Source/WebKit/mac/WebView/WebFrame.mm
Source/WebKit/mac/WebView/WebHTMLRepresentation.mm
Source/WebKit2/ChangeLog
Source/WebKit2/WebProcess/WebPage/WebFrame.cpp

index 992000a..f1db691 100644 (file)
@@ -1,3 +1,13 @@
+2015-01-26  Chris Dumez  <cdumez@apple.com>
+
+        First argument to DOM traversal functions should be a reference
+        https://bugs.webkit.org/show_bug.cgi?id=140895
+
+        Reviewed by Antti Koivisto.
+
+        First argument to DOM traversal functions should be a reference instead
+        of a pointer as it is dereferenced without null-check.
+
 2015-01-26  Roger Fong  <roger_fong@apple.com>
 
         [WebGL2] Update IDL for WebGL2.
index 08be3e9..1814ed4 100644 (file)
@@ -339,9 +339,9 @@ __ZN7WebCore13MachSendRight5adoptEj
 __ZN7WebCore13MachSendRight6createEj
 __ZN7WebCore13MachSendRightD1Ev
 __ZN7WebCore13MachSendRightaSEOS0_
-__ZN7WebCore13NodeTraversal13deepLastChildEPNS_4NodeE
-__ZN7WebCore13NodeTraversal19nextAncestorSiblingEPKNS_4NodeE
-__ZN7WebCore13NodeTraversal19nextAncestorSiblingEPKNS_4NodeES3_
+__ZN7WebCore13NodeTraversal13deepLastChildERNS_4NodeE
+__ZN7WebCore13NodeTraversal19nextAncestorSiblingERKNS_4NodeE
+__ZN7WebCore13NodeTraversal19nextAncestorSiblingERKNS_4NodeEPS2_
 __ZN7WebCore13ResourceErrorC1EP7NSError
 __ZN7WebCore13ResourceErrorC1EP9__CFError
 __ZN7WebCore13SQLResultDoneE
index 18a65b3..d86e000 100644 (file)
@@ -467,10 +467,10 @@ AccessibilityObject* AccessibilityObject::firstAccessibleObjectFromNode(const No
     
     AccessibilityObject* accessibleObject = cache->getOrCreate(node->renderer());
     while (accessibleObject && accessibleObject->accessibilityIsIgnored()) {
-        node = NodeTraversal::next(node);
+        node = NodeTraversal::next(*node);
 
         while (node && !node->renderer())
-            node = NodeTraversal::nextSkippingChildren(node);
+            node = NodeTraversal::nextSkippingChildren(*node);
 
         if (!node)
             return nullptr;
index 81cb411..695386e 100644 (file)
@@ -106,7 +106,7 @@ JSValue toJS(ExecState* exec, JSDOMGlobalObject* globalObject, Document* documen
     // back/forward cache.
     if (!document->frame()) {
         size_t nodeCount = 0;
-        for (Node* n = document; n; n = NodeTraversal::next(n))
+        for (Node* n = document; n; n = NodeTraversal::next(*n))
             nodeCount++;
         
         exec->heap()->reportExtraMemoryCost(nodeCount * sizeof(Node));
index 2068da9..fa53c9c 100644 (file)
@@ -87,19 +87,19 @@ struct SelectorChecker::CheckingContextWithStatus : public SelectorChecker::Chec
     bool hasSelectionPseudo;
 };
 
-static inline bool isFirstChildElement(const Element* element)
+static inline bool isFirstChildElement(const Element& element)
 {
     return !ElementTraversal::previousSibling(element);
 }
 
-static inline bool isLastChildElement(const Element* element)
+static inline bool isLastChildElement(const Element& element)
 {
     return !ElementTraversal::nextSibling(element);
 }
 
-static inline bool isFirstOfType(Element* element, const QualifiedName& type, bool isResolvingStyle)
+static inline bool isFirstOfType(Element& element, const QualifiedName& type, bool isResolvingStyle)
 {
-    for (Element* sibling = ElementTraversal::previousSibling(element); sibling; sibling = ElementTraversal::previousSibling(sibling)) {
+    for (Element* sibling = ElementTraversal::previousSibling(element); sibling; sibling = ElementTraversal::previousSibling(*sibling)) {
         if (isResolvingStyle)
             sibling->setAffectsNextSiblingElementStyle();
         if (sibling->hasTagName(type))
@@ -108,19 +108,19 @@ static inline bool isFirstOfType(Element* element, const QualifiedName& type, bo
     return true;
 }
 
-static inline bool isLastOfType(const Element* element, const QualifiedName& type)
+static inline bool isLastOfType(const Element& element, const QualifiedName& type)
 {
-    for (const Element* sibling = ElementTraversal::nextSibling(element); sibling; sibling = ElementTraversal::nextSibling(sibling)) {
+    for (const Element* sibling = ElementTraversal::nextSibling(element); sibling; sibling = ElementTraversal::nextSibling(*sibling)) {
         if (sibling->hasTagName(type))
             return false;
     }
     return true;
 }
 
-static inline int countElementsBefore(Element* element, bool isResolvingStyle)
+static inline int countElementsBefore(Element& element, bool isResolvingStyle)
 {
     int count = 0;
-    for (Element* sibling = ElementTraversal::previousSibling(element); sibling; sibling = ElementTraversal::previousSibling(sibling)) {
+    for (Element* sibling = ElementTraversal::previousSibling(element); sibling; sibling = ElementTraversal::previousSibling(*sibling)) {
         if (isResolvingStyle)
             sibling->setAffectsNextSiblingElementStyle();
 
@@ -134,10 +134,10 @@ static inline int countElementsBefore(Element* element, bool isResolvingStyle)
     return count;
 }
 
-static inline int countElementsOfTypeBefore(Element* element, const QualifiedName& type, bool isResolvingStyle)
+static inline int countElementsOfTypeBefore(Element& element, const QualifiedName& type, bool isResolvingStyle)
 {
     int count = 0;
-    for (Element* sibling = ElementTraversal::previousSibling(element); sibling; sibling = ElementTraversal::previousSibling(sibling)) {
+    for (Element* sibling = ElementTraversal::previousSibling(element); sibling; sibling = ElementTraversal::previousSibling(*sibling)) {
         if (isResolvingStyle)
             sibling->setAffectsNextSiblingElementStyle();
 
@@ -147,18 +147,18 @@ static inline int countElementsOfTypeBefore(Element* element, const QualifiedNam
     return count;
 }
 
-static inline int countElementsAfter(const Element* element)
+static inline int countElementsAfter(const Element& element)
 {
     int count = 0;
-    for (const Element* sibling = ElementTraversal::nextSibling(element); sibling; sibling = ElementTraversal::nextSibling(sibling))
+    for (const Element* sibling = ElementTraversal::nextSibling(element); sibling; sibling = ElementTraversal::nextSibling(*sibling))
         ++count;
     return count;
 }
 
-static inline int countElementsOfTypeAfter(const Element* element, const QualifiedName& type)
+static inline int countElementsOfTypeAfter(const Element& element, const QualifiedName& type)
 {
     int count = 0;
-    for (const Element* sibling = ElementTraversal::nextSibling(element); sibling; sibling = ElementTraversal::nextSibling(sibling)) {
+    for (const Element* sibling = ElementTraversal::nextSibling(element); sibling; sibling = ElementTraversal::nextSibling(*sibling)) {
         if (sibling->hasTagName(type))
             ++count;
     }
@@ -643,7 +643,7 @@ bool SelectorChecker::checkOne(const CheckingContextWithStatus& context, PseudoI
         case CSSSelector::PseudoClassFirstChild:
             // first-child matches the first child that is an element
             if (Element* parentElement = element->parentElement()) {
-                bool result = isFirstChildElement(element);
+                bool result = isFirstChildElement(*element);
                 if (context.resolvingMode == Mode::ResolvingStyle) {
                     RenderStyle* childStyle = context.elementStyle ? context.elementStyle : element->renderStyle();
                     parentElement->setChildrenAffectedByFirstChildRules();
@@ -659,13 +659,13 @@ bool SelectorChecker::checkOne(const CheckingContextWithStatus& context, PseudoI
                 if (context.resolvingMode == Mode::ResolvingStyle)
                     element->setStyleIsAffectedByPreviousSibling();
 
-                return isFirstOfType(element, element->tagQName(), context.resolvingMode == Mode::ResolvingStyle);
+                return isFirstOfType(*element, element->tagQName(), context.resolvingMode == Mode::ResolvingStyle);
             }
             break;
         case CSSSelector::PseudoClassLastChild:
             // last-child matches the last child that is an element
             if (Element* parentElement = element->parentElement()) {
-                bool result = parentElement->isFinishedParsingChildren() && isLastChildElement(element);
+                bool result = parentElement->isFinishedParsingChildren() && isLastChildElement(*element);
                 if (context.resolvingMode == Mode::ResolvingStyle) {
                     RenderStyle* childStyle = context.elementStyle ? context.elementStyle : element->renderStyle();
                     parentElement->setChildrenAffectedByLastChildRules();
@@ -682,13 +682,13 @@ bool SelectorChecker::checkOne(const CheckingContextWithStatus& context, PseudoI
                     parentElement->setChildrenAffectedByBackwardPositionalRules();
                 if (!parentElement->isFinishedParsingChildren())
                     return false;
-                return isLastOfType(element, element->tagQName());
+                return isLastOfType(*element, element->tagQName());
             }
             break;
         case CSSSelector::PseudoClassOnlyChild:
             if (Element* parentElement = element->parentElement()) {
-                bool firstChild = isFirstChildElement(element);
-                bool onlyChild = firstChild && parentElement->isFinishedParsingChildren() && isLastChildElement(element);
+                bool firstChild = isFirstChildElement(*element);
+                bool onlyChild = firstChild && parentElement->isFinishedParsingChildren() && isLastChildElement(*element);
                 if (context.resolvingMode == Mode::ResolvingStyle) {
                     RenderStyle* childStyle = context.elementStyle ? context.elementStyle : element->renderStyle();
                     parentElement->setChildrenAffectedByFirstChildRules();
@@ -710,7 +710,7 @@ bool SelectorChecker::checkOne(const CheckingContextWithStatus& context, PseudoI
                 }
                 if (!parentElement->isFinishedParsingChildren())
                     return false;
-                return isFirstOfType(element, element->tagQName(), context.resolvingMode == Mode::ResolvingStyle) && isLastOfType(element, element->tagQName());
+                return isFirstOfType(*element, element->tagQName(), context.resolvingMode == Mode::ResolvingStyle) && isLastOfType(*element, element->tagQName());
             }
             break;
         case CSSSelector::PseudoClassMatches:
@@ -770,7 +770,7 @@ bool SelectorChecker::checkOne(const CheckingContextWithStatus& context, PseudoI
 
                 int count = 1;
                 if (const CSSSelectorList* selectorList = selector->selectorList()) {
-                    for (Element* sibling = ElementTraversal::previousSibling(element); sibling; sibling = ElementTraversal::previousSibling(sibling)) {
+                    for (Element* sibling = ElementTraversal::previousSibling(*element); sibling; sibling = ElementTraversal::previousSibling(*sibling)) {
                         if (context.resolvingMode == Mode::ResolvingStyle)
                             sibling->setAffectsNextSiblingElementStyle();
 
@@ -779,7 +779,7 @@ bool SelectorChecker::checkOne(const CheckingContextWithStatus& context, PseudoI
                             ++count;
                     }
                 } else {
-                    count += countElementsBefore(element, context.resolvingMode == Mode::ResolvingStyle);
+                    count += countElementsBefore(*element, context.resolvingMode == Mode::ResolvingStyle);
                     if (context.resolvingMode == Mode::ResolvingStyle)
                         element->setChildIndex(count);
                 }
@@ -796,7 +796,7 @@ bool SelectorChecker::checkOne(const CheckingContextWithStatus& context, PseudoI
                 if (context.resolvingMode == Mode::ResolvingStyle)
                     element->setStyleIsAffectedByPreviousSibling();
 
-                int count = 1 + countElementsOfTypeBefore(element, element->tagQName(), context.resolvingMode == Mode::ResolvingStyle);
+                int count = 1 + countElementsOfTypeBefore(*element, element->tagQName(), context.resolvingMode == Mode::ResolvingStyle);
                 if (selector->matchNth(count))
                     return true;
             }
@@ -824,13 +824,13 @@ bool SelectorChecker::checkOne(const CheckingContextWithStatus& context, PseudoI
 
                 int count = 1;
                 if (const CSSSelectorList* selectorList = selector->selectorList()) {
-                    for (Element* sibling = ElementTraversal::nextSibling(element); sibling; sibling = ElementTraversal::nextSibling(sibling)) {
+                    for (Element* sibling = ElementTraversal::nextSibling(*element); sibling; sibling = ElementTraversal::nextSibling(*sibling)) {
                         unsigned ignoredSpecificity;
                         if (matchSelectorList(context, *sibling, *selectorList, ignoredSpecificity))
                             ++count;
                     }
                 } else
-                    count += countElementsAfter(element);
+                    count += countElementsAfter(*element);
 
                 if (selector->matchNth(count))
                     return true;
@@ -845,7 +845,7 @@ bool SelectorChecker::checkOne(const CheckingContextWithStatus& context, PseudoI
                 if (!parentElement->isFinishedParsingChildren())
                     return false;
 
-                int count = 1 + countElementsOfTypeAfter(element, element->tagQName());
+                int count = 1 + countElementsOfTypeAfter(*element, element->tagQName());
                 if (selector->matchNth(count))
                     return true;
             }
index afa6eb3..d15559f 100644 (file)
@@ -164,7 +164,7 @@ void Attr::childrenChanged(const ChildChange&)
     invalidateNodeListAndCollectionCachesInAncestors(&qualifiedName(), m_element);
 
     StringBuilder valueBuilder;
-    TextNodeTraversal::appendContents(this, valueBuilder);
+    TextNodeTraversal::appendContents(*this, valueBuilder);
 
     AtomicString oldValue = value();
     AtomicString newValue = valueBuilder.toAtomicString();
index b493d8b..a5623a0 100644 (file)
@@ -97,8 +97,8 @@ unsigned CharacterData::parserAppendData(const String& string, unsigned offset,
     if (parentNode()) {
         ContainerNode::ChildChange change = {
             ContainerNode::TextChanged,
-            ElementTraversal::previousSibling(this),
-            ElementTraversal::nextSibling(this),
+            ElementTraversal::previousSibling(*this),
+            ElementTraversal::nextSibling(*this),
             ContainerNode::ChildChangeSourceParser
         };
         parentNode()->childrenChanged(change);
@@ -217,14 +217,14 @@ void CharacterData::dispatchModifiedEvent(const String& oldData)
         if (parentNode()) {
             ContainerNode::ChildChange change = {
                 ContainerNode::TextChanged,
-                ElementTraversal::previousSibling(this),
-                ElementTraversal::nextSibling(this),
+                ElementTraversal::previousSibling(*this),
+                ElementTraversal::nextSibling(*this),
                 ContainerNode::ChildChangeSourceAPI
             };
             parentNode()->childrenChanged(change);
         }
         if (document().hasListenerType(Document::DOMCHARACTERDATAMODIFIED_LISTENER))
-            dispatchScopedEvent(MutationEvent::create(eventNames().DOMCharacterDataModifiedEvent, true, 0, oldData, m_data));
+            dispatchScopedEvent(MutationEvent::create(eventNames().DOMCharacterDataModifiedEvent, true, nullptr, oldData, m_data));
         dispatchSubtreeModifiedEvent();
     }
 
index 82b237b..1f6a77f 100644 (file)
@@ -331,8 +331,8 @@ void ContainerNode::notifyChildInserted(Node& child, ChildChangeSource source)
 {
     ChildChange change;
     change.type = child.isElementNode() ? ElementInserted : child.isTextNode() ? TextInserted : NonContentsChildChanged;
-    change.previousSiblingElement = ElementTraversal::previousSibling(&child);
-    change.nextSiblingElement = ElementTraversal::nextSibling(&child);
+    change.previousSiblingElement = ElementTraversal::previousSibling(child);
+    change.nextSiblingElement = ElementTraversal::nextSibling(child);
     change.source = source;
 
     childrenChanged(change);
@@ -342,8 +342,8 @@ void ContainerNode::notifyChildRemoved(Node& child, Node* previousSibling, Node*
 {
     ChildChange change;
     change.type = is<Element>(child) ? ElementRemoved : is<Text>(child) ? TextRemoved : NonContentsChildChanged;
-    change.previousSiblingElement = (!previousSibling || is<Element>(*previousSibling)) ? downcast<Element>(previousSibling) : ElementTraversal::previousSibling(previousSibling);
-    change.nextSiblingElement = (!nextSibling || is<Element>(*nextSibling)) ? downcast<Element>(nextSibling) : ElementTraversal::nextSibling(nextSibling);
+    change.previousSiblingElement = (!previousSibling || is<Element>(*previousSibling)) ? downcast<Element>(previousSibling) : ElementTraversal::previousSibling(*previousSibling);
+    change.nextSiblingElement = (!nextSibling || is<Element>(*nextSibling)) ? downcast<Element>(nextSibling) : ElementTraversal::nextSibling(*nextSibling);
     change.source = source;
 
     childrenChanged(change);
@@ -809,7 +809,7 @@ static void dispatchChildInsertionEvents(Node& child)
 
     // dispatch the DOMNodeInsertedIntoDocument event to all descendants
     if (c->inDocument() && document->hasListenerType(Document::DOMNODEINSERTEDINTODOCUMENT_LISTENER)) {
-        for (; c; c = NodeTraversal::next(c.get(), &child))
+        for (; c; c = NodeTraversal::next(*c, &child))
             c->dispatchScopedEvent(MutationEvent::create(eventNames().DOMNodeInsertedIntoDocumentEvent, false));
     }
 }
@@ -835,7 +835,7 @@ static void dispatchChildRemovalEvents(Node& child)
 
     // dispatch the DOMNodeRemovedFromDocument event to all descendants
     if (c->inDocument() && document->hasListenerType(Document::DOMNODEREMOVEDFROMDOCUMENT_LISTENER)) {
-        for (; c; c = NodeTraversal::next(c.get(), &child))
+        for (; c; c = NodeTraversal::next(*c, &child))
             c->dispatchScopedEvent(MutationEvent::create(eventNames().DOMNodeRemovedFromDocumentEvent, false));
     }
 }
index aa71226..a327295 100644 (file)
@@ -2155,7 +2155,7 @@ void Document::removeAllEventListeners()
 #if ENABLE(IOS_TOUCH_EVENTS)
     clearTouchEventListeners();
 #endif
-    for (Node* node = firstChild(); node; node = NodeTraversal::next(node))
+    for (Node* node = firstChild(); node; node = NodeTraversal::next(*node))
         node->removeAllEventListeners();
 }
 
@@ -3272,7 +3272,7 @@ void Document::updateViewportUnitsOnResize()
     ensureStyleResolver().clearCachedPropertiesAffectedByViewportUnits();
 
     // FIXME: Ideally, we should save the list of elements that have viewport units and only iterate over those.
-    for (Element* element = ElementTraversal::firstWithin(&rootNode()); element; element = ElementTraversal::nextIncludingPseudo(element)) {
+    for (Element* element = ElementTraversal::firstWithin(rootNode()); element; element = ElementTraversal::nextIncludingPseudo(*element)) {
         auto* renderer = element->renderer();
         if (renderer && renderer->style().hasViewportUnits())
             element->setNeedsStyleRecalc(InlineStyleChange);
index 41f1270..096c120 100644 (file)
@@ -404,7 +404,7 @@ Vector<RenderedDocumentMarker*> DocumentMarkerController::markersInRange(Range*
     ASSERT(endContainer);
 
     Node* pastLastNode = range->pastLastNode();
-    for (Node* node = range->firstNode(); node != pastLastNode; node = NodeTraversal::next(node)) {
+    for (Node* node = range->firstNode(); node != pastLastNode; node = NodeTraversal::next(*node)) {
         for (auto* marker : markersFor(node)) {
             if (!markerTypes.contains(marker->type()))
                 continue;
@@ -629,7 +629,7 @@ void DocumentMarkerController::setMarkersActive(Range* range, bool active)
 
     Node* pastLastNode = range->pastLastNode();
 
-    for (Node* node = range->firstNode(); node != pastLastNode; node = NodeTraversal::next(node)) {
+    for (Node* node = range->firstNode(); node != pastLastNode; node = NodeTraversal::next(*node)) {
         int startOffset = node == startContainer ? range->startOffset() : 0;
         int endOffset = node == endContainer ? range->endOffset() : INT_MAX;
         setMarkersActive(node, startOffset, endOffset, active);
@@ -675,7 +675,7 @@ bool DocumentMarkerController::hasMarkers(Range* range, DocumentMarker::MarkerTy
     ASSERT(endContainer);
 
     Node* pastLastNode = range->pastLastNode();
-    for (Node* node = range->firstNode(); node != pastLastNode; node = NodeTraversal::next(node)) {
+    for (Node* node = range->firstNode(); node != pastLastNode; node = NodeTraversal::next(*node)) {
         for (auto* marker : markersFor(node)) {
             if (!markerTypes.contains(marker->type()))
                 continue;
@@ -699,7 +699,7 @@ void DocumentMarkerController::clearDescriptionOnMarkersIntersectingRange(Range*
     Node* endContainer = range->endContainer();
 
     Node* pastLastNode = range->pastLastNode();
-    for (Node* node = range->firstNode(); node != pastLastNode; node = NodeTraversal::next(node)) {
+    for (Node* node = range->firstNode(); node != pastLastNode; node = NodeTraversal::next(*node)) {
         unsigned startOffset = node == startContainer ? range->startOffset() : 0;
         unsigned endOffset = node == endContainer ? static_cast<unsigned>(range->endOffset()) : std::numeric_limits<unsigned>::max();
         MarkerList* list = m_markers.get(node);
index 51a0785..2efc2f0 100644 (file)
@@ -1558,18 +1558,18 @@ static void checkForEmptyStyleChange(Element& element)
 
 enum SiblingCheckType { FinishedParsingChildren, SiblingElementRemoved, Other };
 
-static void checkForSiblingStyleChanges(Element* parent, SiblingCheckType checkType, Element* elementBeforeChange, Element* elementAfterChange)
+static void checkForSiblingStyleChanges(Element& parent, SiblingCheckType checkType, Element* elementBeforeChange, Element* elementAfterChange)
 {
     // :empty selector.
-    checkForEmptyStyleChange(*parent);
+    checkForEmptyStyleChange(parent);
 
-    if (parent->styleChangeType() >= FullStyleChange)
+    if (parent.styleChangeType() >= FullStyleChange)
         return;
 
     // :first-child.  In the parser callback case, we don't have to check anything, since we were right the first time.
     // In the DOM case, we only need to do something if |afterChange| is not 0.
     // |afterChange| is 0 in the parser case, so it works out that we'll skip this block.
-    if (parent->childrenAffectedByFirstChildRules() && elementAfterChange) {
+    if (parent.childrenAffectedByFirstChildRules() && elementAfterChange) {
         // Find our new first child.
         Element* newFirstElement = ElementTraversal::firstChild(parent);
         // Find the first element node following |afterChange|
@@ -1591,7 +1591,7 @@ static void checkForSiblingStyleChanges(Element* parent, SiblingCheckType checkT
 
     // :last-child.  In the parser callback case, we don't have to check anything, since we were right the first time.
     // In the DOM case, we only need to do something if |afterChange| is not 0.
-    if (parent->childrenAffectedByLastChildRules() && elementBeforeChange) {
+    if (parent.childrenAffectedByLastChildRules() && elementBeforeChange) {
         // Find our new last child.
         Element* newLastElement = ElementTraversal::lastChild(parent);
 
@@ -1630,8 +1630,8 @@ static void checkForSiblingStyleChanges(Element* parent, SiblingCheckType checkT
     // |afterChange| is 0 in the parser callback case, so we won't do any work for the forward case if we don't have to.
     // For performance reasons we just mark the parent node as changed, since we don't want to make childrenChanged O(n^2) by crawling all our kids
     // here.  recalcStyle will then force a walk of the children when it sees that this has happened.
-    if (parent->childrenAffectedByBackwardPositionalRules() && elementBeforeChange)
-        parent->setNeedsStyleRecalc();
+    if (parent.childrenAffectedByBackwardPositionalRules() && elementBeforeChange)
+        parent.setNeedsStyleRecalc();
 }
 
 void Element::childrenChanged(const ChildChange& change)
@@ -1641,7 +1641,7 @@ void Element::childrenChanged(const ChildChange& change)
         checkForEmptyStyleChange(*this);
     else {
         SiblingCheckType checkType = change.type == ElementRemoved ? SiblingElementRemoved : Other;
-        checkForSiblingStyleChanges(this, checkType, change.previousSiblingElement, change.nextSiblingElement);
+        checkForSiblingStyleChanges(*this, checkType, change.previousSiblingElement, change.nextSiblingElement);
     }
 
     if (ShadowRoot* shadowRoot = this->shadowRoot())
@@ -1666,7 +1666,7 @@ void Element::finishParsingChildren()
 {
     ContainerNode::finishParsingChildren();
     setIsParsingChildrenFinished();
-    checkForSiblingStyleChanges(this, FinishedParsingChildren, ElementTraversal::lastChild(this), nullptr);
+    checkForSiblingStyleChanges(*this, FinishedParsingChildren, ElementTraversal::lastChild(*this), nullptr);
     if (auto styleResolver = document().styleResolverIfExists())
         styleResolver->popParentElement(this);
 }
@@ -2375,22 +2375,22 @@ void Element::clearAfterPseudoElement()
 // ElementTraversal API
 Element* Element::firstElementChild() const
 {
-    return ElementTraversal::firstChild(this);
+    return ElementTraversal::firstChild(*this);
 }
 
 Element* Element::lastElementChild() const
 {
-    return ElementTraversal::lastChild(this);
+    return ElementTraversal::lastChild(*this);
 }
 
 Element* Element::previousElementSibling() const
 {
-    return ElementTraversal::previousSibling(this);
+    return ElementTraversal::previousSibling(*this);
 }
 
 Element* Element::nextElementSibling() const
 {
-    return ElementTraversal::nextSibling(this);
+    return ElementTraversal::nextSibling(*this);
 }
 
 unsigned Element::childElementCount() const
index 170af86..8898cfc 100644 (file)
@@ -132,7 +132,7 @@ inline ElementChildIteratorAdapter<ElementType>::ElementChildIteratorAdapter(Con
 template <typename ElementType>
 inline ElementChildIterator<ElementType> ElementChildIteratorAdapter<ElementType>::begin()
 {
-    return ElementChildIterator<ElementType>(m_parent, Traversal<ElementType>::firstChild(&m_parent));
+    return ElementChildIterator<ElementType>(m_parent, Traversal<ElementType>::firstChild(m_parent));
 }
 
 template <typename ElementType>
@@ -144,13 +144,13 @@ inline ElementChildIterator<ElementType> ElementChildIteratorAdapter<ElementType
 template <typename ElementType>
 inline ElementType* ElementChildIteratorAdapter<ElementType>::first()
 {
-    return Traversal<ElementType>::firstChild(&m_parent);
+    return Traversal<ElementType>::firstChild(m_parent);
 }
 
 template <typename ElementType>
 inline ElementType* ElementChildIteratorAdapter<ElementType>::last()
 {
-    return Traversal<ElementType>::lastChild(&m_parent);
+    return Traversal<ElementType>::lastChild(m_parent);
 }
 
 template <typename ElementType>
@@ -171,7 +171,7 @@ inline ElementChildConstIteratorAdapter<ElementType>::ElementChildConstIteratorA
 template <typename ElementType>
 inline ElementChildConstIterator<ElementType> ElementChildConstIteratorAdapter<ElementType>::begin() const
 {
-    return ElementChildConstIterator<ElementType>(m_parent, Traversal<ElementType>::firstChild(&m_parent));
+    return ElementChildConstIterator<ElementType>(m_parent, Traversal<ElementType>::firstChild(m_parent));
 }
 
 template <typename ElementType>
@@ -183,13 +183,13 @@ inline ElementChildConstIterator<ElementType> ElementChildConstIteratorAdapter<E
 template <typename ElementType>
 inline const ElementType* ElementChildConstIteratorAdapter<ElementType>::first() const
 {
-    return Traversal<ElementType>::firstChild(&m_parent);
+    return Traversal<ElementType>::firstChild(m_parent);
 }
 
 template <typename ElementType>
 inline const ElementType* ElementChildConstIteratorAdapter<ElementType>::last() const
 {
-    return Traversal<ElementType>::lastChild(&m_parent);
+    return Traversal<ElementType>::lastChild(m_parent);
 }
 
 template <typename ElementType>
index 758e427..866b0b7 100644 (file)
@@ -121,8 +121,8 @@ ALWAYS_INLINE ElementDescendantIterator& ElementDescendantIterator::operator++()
     ASSERT(m_current);
     ASSERT(!m_assertions.domTreeHasMutated());
 
-    Element* firstChild = ElementTraversal::firstChild(m_current);
-    Element* nextSibling = ElementTraversal::nextSibling(m_current);
+    Element* firstChild = ElementTraversal::firstChild(*m_current);
+    Element* nextSibling = ElementTraversal::nextSibling(*m_current);
 
     if (firstChild) {
         if (nextSibling)
@@ -152,7 +152,7 @@ ALWAYS_INLINE ElementDescendantIterator& ElementDescendantIterator::operator--()
     ASSERT(m_current);
     ASSERT(!m_assertions.domTreeHasMutated());
 
-    Element* previousSibling = ElementTraversal::previousSibling(m_current);
+    Element* previousSibling = ElementTraversal::previousSibling(*m_current);
 
     if (!previousSibling) {
         m_current = m_current->parentElement();
@@ -163,7 +163,7 @@ ALWAYS_INLINE ElementDescendantIterator& ElementDescendantIterator::operator--()
     }
 
     Element* deepestSibling = previousSibling;
-    while (Element* lastChild = ElementTraversal::lastChild(deepestSibling))
+    while (Element* lastChild = ElementTraversal::lastChild(*deepestSibling))
         deepestSibling = lastChild;
     ASSERT(deepestSibling);
 
@@ -224,8 +224,8 @@ ALWAYS_INLINE ElementDescendantConstIterator& ElementDescendantConstIterator::op
     ASSERT(m_current);
     ASSERT(!m_assertions.domTreeHasMutated());
 
-    Element* firstChild = ElementTraversal::firstChild(m_current);
-    Element* nextSibling = ElementTraversal::nextSibling(m_current);
+    Element* firstChild = ElementTraversal::firstChild(*m_current);
+    Element* nextSibling = ElementTraversal::nextSibling(*m_current);
 
     if (firstChild) {
         if (nextSibling)
@@ -284,7 +284,7 @@ inline ElementDescendantIteratorAdapter::ElementDescendantIteratorAdapter(Contai
 
 inline ElementDescendantIterator ElementDescendantIteratorAdapter::begin()
 {
-    return ElementDescendantIterator(ElementTraversal::firstChild(&m_root));
+    return ElementDescendantIterator(ElementTraversal::firstChild(m_root));
 }
 
 inline ElementDescendantIterator ElementDescendantIteratorAdapter::end()
@@ -294,7 +294,7 @@ inline ElementDescendantIterator ElementDescendantIteratorAdapter::end()
 
 inline ElementDescendantIterator ElementDescendantIteratorAdapter::last()
 {
-    return ElementDescendantIterator(ElementTraversal::lastWithin(&m_root));
+    return ElementDescendantIterator(ElementTraversal::lastWithin(m_root));
 }
 
 // ElementDescendantConstIteratorAdapter
@@ -306,7 +306,7 @@ inline ElementDescendantConstIteratorAdapter::ElementDescendantConstIteratorAdap
 
 inline ElementDescendantConstIterator ElementDescendantConstIteratorAdapter::begin() const
 {
-    return ElementDescendantConstIterator(ElementTraversal::firstChild(&m_root));
+    return ElementDescendantConstIterator(ElementTraversal::firstChild(m_root));
 }
 
 inline ElementDescendantConstIterator ElementDescendantConstIteratorAdapter::end() const
@@ -316,7 +316,7 @@ inline ElementDescendantConstIterator ElementDescendantConstIteratorAdapter::end
 
 inline ElementDescendantConstIterator ElementDescendantConstIteratorAdapter::last() const
 {
-    return ElementDescendantConstIterator(ElementTraversal::lastWithin(&m_root));
+    return ElementDescendantConstIterator(ElementTraversal::lastWithin(m_root));
 }
 
 // Standalone functions
index 7603ad5..4ca4a60 100644 (file)
@@ -114,7 +114,7 @@ inline ElementIterator<ElementType>& ElementIterator<ElementType>::traverseNext(
 {
     ASSERT(m_current);
     ASSERT(!m_assertions.domTreeHasMutated());
-    m_current = Traversal<ElementType>::next(m_current, m_root);
+    m_current = Traversal<ElementType>::next(*m_current, m_root);
 #if !ASSERT_DISABLED
     // Drop the assertion when the iterator reaches the end.
     if (!m_current)
@@ -128,7 +128,7 @@ inline ElementIterator<ElementType>& ElementIterator<ElementType>::traversePrevi
 {
     ASSERT(m_current);
     ASSERT(!m_assertions.domTreeHasMutated());
-    m_current = Traversal<ElementType>::previous(m_current, m_root);
+    m_current = Traversal<ElementType>::previous(*m_current, m_root);
 #if !ASSERT_DISABLED
     // Drop the assertion when the iterator reaches the end.
     if (!m_current)
@@ -142,7 +142,7 @@ inline ElementIterator<ElementType>& ElementIterator<ElementType>::traverseNextS
 {
     ASSERT(m_current);
     ASSERT(!m_assertions.domTreeHasMutated());
-    m_current = Traversal<ElementType>::nextSibling(m_current);
+    m_current = Traversal<ElementType>::nextSibling(*m_current);
 #if !ASSERT_DISABLED
     // Drop the assertion when the iterator reaches the end.
     if (!m_current)
@@ -156,7 +156,7 @@ inline ElementIterator<ElementType>& ElementIterator<ElementType>::traversePrevi
 {
     ASSERT(m_current);
     ASSERT(!m_assertions.domTreeHasMutated());
-    m_current = Traversal<ElementType>::previousSibling(m_current);
+    m_current = Traversal<ElementType>::previousSibling(*m_current);
 #if !ASSERT_DISABLED
     // Drop the assertion when the iterator reaches the end.
     if (!m_current)
@@ -170,7 +170,7 @@ inline ElementIterator<ElementType>& ElementIterator<ElementType>::traverseNextS
 {
     ASSERT(m_current);
     ASSERT(!m_assertions.domTreeHasMutated());
-    m_current = Traversal<ElementType>::nextSkippingChildren(m_current, m_root);
+    m_current = Traversal<ElementType>::nextSkippingChildren(*m_current, m_root);
 #if !ASSERT_DISABLED
     // Drop the assertion when the iterator reaches the end.
     if (!m_current)
@@ -264,7 +264,7 @@ inline ElementConstIterator<ElementType>& ElementConstIterator<ElementType>::tra
 {
     ASSERT(m_current);
     ASSERT(!m_assertions.domTreeHasMutated());
-    m_current = Traversal<ElementType>::next(m_current, m_root);
+    m_current = Traversal<ElementType>::next(*m_current, m_root);
 #if !ASSERT_DISABLED
     // Drop the assertion when the iterator reaches the end.
     if (!m_current)
@@ -278,7 +278,7 @@ inline ElementConstIterator<ElementType>& ElementConstIterator<ElementType>::tra
 {
     ASSERT(m_current);
     ASSERT(!m_assertions.domTreeHasMutated());
-    m_current = Traversal<ElementType>::previous(m_current, m_root);
+    m_current = Traversal<ElementType>::previous(*m_current, m_root);
 #if !ASSERT_DISABLED
     // Drop the assertion when the iterator reaches the end.
     if (!m_current)
@@ -292,7 +292,7 @@ inline ElementConstIterator<ElementType>& ElementConstIterator<ElementType>::tra
 {
     ASSERT(m_current);
     ASSERT(!m_assertions.domTreeHasMutated());
-    m_current = Traversal<ElementType>::nextSibling(m_current);
+    m_current = Traversal<ElementType>::nextSibling(*m_current);
 #if !ASSERT_DISABLED
     // Drop the assertion when the iterator reaches the end.
     if (!m_current)
@@ -306,7 +306,7 @@ inline ElementConstIterator<ElementType>& ElementConstIterator<ElementType>::tra
 {
     ASSERT(m_current);
     ASSERT(!m_assertions.domTreeHasMutated());
-    m_current = Traversal<ElementType>::previousSibling(m_current);
+    m_current = Traversal<ElementType>::previousSibling(*m_current);
 #if !ASSERT_DISABLED
     // Drop the assertion when the iterator reaches the end.
     if (!m_current)
@@ -320,7 +320,7 @@ inline ElementConstIterator<ElementType>& ElementConstIterator<ElementType>::tra
 {
     ASSERT(m_current);
     ASSERT(!m_assertions.domTreeHasMutated());
-    m_current = Traversal<ElementType>::nextSkippingChildren(m_current, m_root);
+    m_current = Traversal<ElementType>::nextSkippingChildren(*m_current, m_root);
 #if !ASSERT_DISABLED
     // Drop the assertion when the iterator reaches the end.
     if (!m_current)
index c5c9994..1d57681 100644 (file)
@@ -34,88 +34,88 @@ template <typename ElementType>
 class Traversal {
 public:
     // First or last ElementType child of the node.
-    static ElementType* firstChild(const Node*);
-    static ElementType* firstChild(const ContainerNode*);
-    static ElementType* lastChild(const Node*);
-    static ElementType* lastChild(const ContainerNode*);
+    static ElementType* firstChild(const Node&);
+    static ElementType* firstChild(const ContainerNode&);
+    static ElementType* lastChild(const Node&);
+    static ElementType* lastChild(const ContainerNode&);
 
     // First or last ElementType descendant of the node. For Elements firstWithin is always the same as first child.
-    static ElementType* firstWithin(const Node*);
-    static ElementType* firstWithin(const ContainerNode*);
-    static ElementType* lastWithin(const Node*);
-    static ElementType* lastWithin(const ContainerNode*);
+    static ElementType* firstWithin(const Node&);
+    static ElementType* firstWithin(const ContainerNode&);
+    static ElementType* lastWithin(const Node&);
+    static ElementType* lastWithin(const ContainerNode&);
 
     // Pre-order traversal skipping non-ElementType nodes.
-    static ElementType* next(const Node*);
-    static ElementType* next(const Node*, const Node* stayWithin);
-    static ElementType* next(const ContainerNode*);
-    static ElementType* next(const ContainerNode*, const Node* stayWithin);
-    static ElementType* previous(const Node*);
-    static ElementType* previous(const Node*, const Node* stayWithin);
+    static ElementType* next(const Node&);
+    static ElementType* next(const Node&, const Node* stayWithin);
+    static ElementType* next(const ContainerNode&);
+    static ElementType* next(const ContainerNode&, const Node* stayWithin);
+    static ElementType* previous(const Node&);
+    static ElementType* previous(const Node&, const Node* stayWithin);
 
     // Next or previous ElementType sibling if there is one.
-    static ElementType* nextSibling(const Node*);
-    static ElementType* previousSibling(const Node*);
+    static ElementType* nextSibling(const Node&);
+    static ElementType* previousSibling(const Node&);
 
     // Like next, but skips children.
-    static ElementType* nextSkippingChildren(const Node*);
-    static ElementType* nextSkippingChildren(const Node*, const Node* stayWithin);
+    static ElementType* nextSkippingChildren(const Node&);
+    static ElementType* nextSkippingChildren(const Node&, const Node* stayWithin);
 
 private:
-    template <typename CurrentType> static ElementType* firstChildTemplate(CurrentType*);
-    template <typename CurrentType> static ElementType* lastChildTemplate(CurrentType*);
-    template <typename CurrentType> static ElementType* firstWithinTemplate(CurrentType*);
-    template <typename CurrentType> static ElementType* lastWithinTemplate(CurrentType*);
-    template <typename CurrentType> static ElementType* nextTemplate(CurrentType*);
-    template <typename CurrentType> static ElementType* nextTemplate(CurrentType*, const Node* stayWithin);
+    template <typename CurrentType> static ElementType* firstChildTemplate(CurrentType&);
+    template <typename CurrentType> static ElementType* lastChildTemplate(CurrentType&);
+    template <typename CurrentType> static ElementType* firstWithinTemplate(CurrentType&);
+    template <typename CurrentType> static ElementType* lastWithinTemplate(CurrentType&);
+    template <typename CurrentType> static ElementType* nextTemplate(CurrentType&);
+    template <typename CurrentType> static ElementType* nextTemplate(CurrentType&, const Node* stayWithin);
 };
 
 class ElementTraversal : public Traversal<Element> {
 public:
     // FIXME: These should go somewhere else.
     // Pre-order traversal including the pseudo-elements.
-    static Element* previousIncludingPseudo(const Node*, const Node* = 0);
-    static Element* nextIncludingPseudo(const Node*, const Node* = 0);
-    static Element* nextIncludingPseudoSkippingChildren(const Node*, const Node* = 0);
+    static Element* previousIncludingPseudo(const Node&, const Node* = nullptr);
+    static Element* nextIncludingPseudo(const Node&, const Node* = nullptr);
+    static Element* nextIncludingPseudoSkippingChildren(const Node&, const Node* = nullptr);
 
     // Utility function to traverse only the element and pseudo-element siblings of a node.
-    static Element* pseudoAwarePreviousSibling(const Node*);
+    static Element* pseudoAwarePreviousSibling(const Node&);
 };
 
 // Specialized for pure Element to exploit the fact that Elements parent is always either another Element or the root.
 template <>
 template <typename CurrentType>
-inline Element* Traversal<Element>::firstWithinTemplate(CurrentType* current)
+inline Element* Traversal<Element>::firstWithinTemplate(CurrentType& current)
 {
     return firstChildTemplate(current);
 }
 
 template <>
 template <typename CurrentType>
-inline Element* Traversal<Element>::nextTemplate(CurrentType* current)
+inline Element* Traversal<Element>::nextTemplate(CurrentType& current)
 {
     Node* node = NodeTraversal::next(current);
     while (node && !is<Element>(*node))
-        node = NodeTraversal::nextSkippingChildren(node);
+        node = NodeTraversal::nextSkippingChildren(*node);
     return downcast<Element>(node);
 }
 
 template <>
 template <typename CurrentType>
-inline Element* Traversal<Element>::nextTemplate(CurrentType* current, const Node* stayWithin)
+inline Element* Traversal<Element>::nextTemplate(CurrentType& current, const Node* stayWithin)
 {
     Node* node = NodeTraversal::next(current, stayWithin);
     while (node && !is<Element>(*node))
-        node = NodeTraversal::nextSkippingChildren(node, stayWithin);
+        node = NodeTraversal::nextSkippingChildren(*node, stayWithin);
     return downcast<Element>(node);
 }
 
 // Generic versions.
 template <typename ElementType>
 template <typename CurrentType>
-inline ElementType* Traversal<ElementType>::firstChildTemplate(CurrentType* current)
+inline ElementType* Traversal<ElementType>::firstChildTemplate(CurrentType& current)
 {
-    Node* node = current->firstChild();
+    Node* node = current.firstChild();
     while (node && !is<ElementType>(*node))
         node = node->nextSibling();
     return downcast<ElementType>(node);
@@ -123,9 +123,9 @@ inline ElementType* Traversal<ElementType>::firstChildTemplate(CurrentType* curr
 
 template <typename ElementType>
 template <typename CurrentType>
-inline ElementType* Traversal<ElementType>::lastChildTemplate(CurrentType* current)
+inline ElementType* Traversal<ElementType>::lastChildTemplate(CurrentType& current)
 {
-    Node* node = current->lastChild();
+    Node* node = current.lastChild();
     while (node && !is<ElementType>(*node))
         node = node->previousSibling();
     return downcast<ElementType>(node);
@@ -133,155 +133,155 @@ inline ElementType* Traversal<ElementType>::lastChildTemplate(CurrentType* curre
 
 template <typename ElementType>
 template <typename CurrentType>
-inline ElementType* Traversal<ElementType>::firstWithinTemplate(CurrentType* current)
+inline ElementType* Traversal<ElementType>::firstWithinTemplate(CurrentType& current)
 {
-    Node* node = current->firstChild();
+    Node* node = current.firstChild();
     while (node && !is<ElementType>(*node))
-        node = NodeTraversal::next(node, current);
+        node = NodeTraversal::next(*node, &current);
     return downcast<ElementType>(node);
 }
 
 template <typename ElementType>
 template <typename CurrentType>
-inline ElementType* Traversal<ElementType>::lastWithinTemplate(CurrentType* current)
+inline ElementType* Traversal<ElementType>::lastWithinTemplate(CurrentType& current)
 {
     Node* node = NodeTraversal::last(current);
     while (node && !is<ElementType>(*node))
-        node = NodeTraversal::previous(node, current);
+        node = NodeTraversal::previous(*node, &current);
     return downcast<ElementType>(node);
 }
 
 template <typename ElementType>
 template <typename CurrentType>
-inline ElementType* Traversal<ElementType>::nextTemplate(CurrentType* current)
+inline ElementType* Traversal<ElementType>::nextTemplate(CurrentType& current)
 {
     Node* node = NodeTraversal::next(current);
     while (node && !is<ElementType>(*node))
-        node = NodeTraversal::next(node);
+        node = NodeTraversal::next(*node);
     return downcast<ElementType>(node);
 }
 
 template <typename ElementType>
 template <typename CurrentType>
-inline ElementType* Traversal<ElementType>::nextTemplate(CurrentType* current, const Node* stayWithin)
+inline ElementType* Traversal<ElementType>::nextTemplate(CurrentType& current, const Node* stayWithin)
 {
     Node* node = NodeTraversal::next(current, stayWithin);
     while (node && !is<ElementType>(*node))
-        node = NodeTraversal::next(node, stayWithin);
+        node = NodeTraversal::next(*node, stayWithin);
     return downcast<ElementType>(node);
 }
 
 template <typename ElementType>
-inline ElementType* Traversal<ElementType>::previous(const Node* current)
+inline ElementType* Traversal<ElementType>::previous(const Node& current)
 {
     Node* node = NodeTraversal::previous(current);
     while (node && !is<ElementType>(*node))
-        node = NodeTraversal::previous(node);
+        node = NodeTraversal::previous(*node);
     return downcast<ElementType>(node);
 }
 
 template <typename ElementType>
-inline ElementType* Traversal<ElementType>::previous(const Node* current, const Node* stayWithin)
+inline ElementType* Traversal<ElementType>::previous(const Node& current, const Node* stayWithin)
 {
     Node* node = NodeTraversal::previous(current, stayWithin);
     while (node && !is<ElementType>(*node))
-        node = NodeTraversal::previous(node, stayWithin);
+        node = NodeTraversal::previous(*node, stayWithin);
     return downcast<ElementType>(node);
 }
 
 template <typename ElementType>
-inline ElementType* Traversal<ElementType>::nextSibling(const Node* current)
+inline ElementType* Traversal<ElementType>::nextSibling(const Node& current)
 {
-    Node* node = current->nextSibling();
+    Node* node = current.nextSibling();
     while (node && !is<ElementType>(*node))
         node = node->nextSibling();
     return downcast<ElementType>(node);
 }
 
 template <typename ElementType>
-inline ElementType* Traversal<ElementType>::previousSibling(const Node* current)
+inline ElementType* Traversal<ElementType>::previousSibling(const Node& current)
 {
-    Node* node = current->previousSibling();
+    Node* node = current.previousSibling();
     while (node && !is<ElementType>(*node))
         node = node->previousSibling();
     return downcast<ElementType>(node);
 }
 
 template <typename ElementType>
-inline ElementType* Traversal<ElementType>::nextSkippingChildren(const Node* current)
+inline ElementType* Traversal<ElementType>::nextSkippingChildren(const Node& current)
 {
     Node* node = NodeTraversal::nextSkippingChildren(current);
     while (node && !is<ElementType>(*node))
-        node = NodeTraversal::nextSkippingChildren(node);
+        node = NodeTraversal::nextSkippingChildren(*node);
     return downcast<ElementType>(node);
 }
 
 template <typename ElementType>
-inline ElementType* Traversal<ElementType>::nextSkippingChildren(const Node* current, const Node* stayWithin)
+inline ElementType* Traversal<ElementType>::nextSkippingChildren(const Node& current, const Node* stayWithin)
 {
     Node* node = NodeTraversal::nextSkippingChildren(current, stayWithin);
     while (node && !is<ElementType>(*node))
-        node = NodeTraversal::nextSkippingChildren(node, stayWithin);
+        node = NodeTraversal::nextSkippingChildren(*node, stayWithin);
     return downcast<ElementType>(node);
 }
 
 template <typename ElementType>
-inline ElementType* Traversal<ElementType>::firstChild(const ContainerNode* current) { return firstChildTemplate(current); }
+inline ElementType* Traversal<ElementType>::firstChild(const ContainerNode& current) { return firstChildTemplate(current); }
 template <typename ElementType>
-inline ElementType* Traversal<ElementType>::firstChild(const Node* current) { return firstChildTemplate(current); }
+inline ElementType* Traversal<ElementType>::firstChild(const Node& current) { return firstChildTemplate(current); }
 template <typename ElementType>
 
-inline ElementType* Traversal<ElementType>::lastChild(const ContainerNode* current) { return lastChildTemplate(current); }
+inline ElementType* Traversal<ElementType>::lastChild(const ContainerNode& current) { return lastChildTemplate(current); }
 template <typename ElementType>
-inline ElementType* Traversal<ElementType>::lastChild(const Node* current) { return lastChildTemplate(current); }
+inline ElementType* Traversal<ElementType>::lastChild(const Node& current) { return lastChildTemplate(current); }
 
 template <typename ElementType>
-inline ElementType* Traversal<ElementType>::firstWithin(const ContainerNode* current) { return firstWithinTemplate(current); }
+inline ElementType* Traversal<ElementType>::firstWithin(const ContainerNode& current) { return firstWithinTemplate(current); }
 template <typename ElementType>
-inline ElementType* Traversal<ElementType>::firstWithin(const Node* current) { return firstWithinTemplate(current); }
+inline ElementType* Traversal<ElementType>::firstWithin(const Node& current) { return firstWithinTemplate(current); }
 template <typename ElementType>
 
-inline ElementType* Traversal<ElementType>::lastWithin(const ContainerNode* current) { return lastWithinTemplate(current); }
+inline ElementType* Traversal<ElementType>::lastWithin(const ContainerNode& current) { return lastWithinTemplate(current); }
 template <typename ElementType>
-inline ElementType* Traversal<ElementType>::lastWithin(const Node* current) { return lastWithinTemplate(current); }
+inline ElementType* Traversal<ElementType>::lastWithin(const Node& current) { return lastWithinTemplate(current); }
 
 template <typename ElementType>
-inline ElementType* Traversal<ElementType>::next(const ContainerNode* current) { return nextTemplate(current); }
+inline ElementType* Traversal<ElementType>::next(const ContainerNode& current) { return nextTemplate(current); }
 template <typename ElementType>
-inline ElementType* Traversal<ElementType>::next(const Node* current) { return nextTemplate(current); }
+inline ElementType* Traversal<ElementType>::next(const Node& current) { return nextTemplate(current); }
 template <typename ElementType>
-inline ElementType* Traversal<ElementType>::next(const ContainerNode* current, const Node* stayWithin) { return nextTemplate(current, stayWithin); }
+inline ElementType* Traversal<ElementType>::next(const ContainerNode& current, const Node* stayWithin) { return nextTemplate(current, stayWithin); }
 template <typename ElementType>
-inline ElementType* Traversal<ElementType>::next(const Node* current, const Node* stayWithin) { return nextTemplate(current, stayWithin); }
+inline ElementType* Traversal<ElementType>::next(const Node& current, const Node* stayWithin) { return nextTemplate(current, stayWithin); }
 
 // FIXME: These should go somewhere else.
-inline Element* ElementTraversal::previousIncludingPseudo(const Node* current, const Node* stayWithin)
+inline Element* ElementTraversal::previousIncludingPseudo(const Node& current, const Node* stayWithin)
 {
     Node* node = NodeTraversal::previousIncludingPseudo(current, stayWithin);
     while (node && !is<Element>(*node))
-        node = NodeTraversal::previousIncludingPseudo(node, stayWithin);
+        node = NodeTraversal::previousIncludingPseudo(*node, stayWithin);
     return downcast<Element>(node);
 }
 
-inline Element* ElementTraversal::nextIncludingPseudo(const Node* current, const Node* stayWithin)
+inline Element* ElementTraversal::nextIncludingPseudo(const Node& current, const Node* stayWithin)
 {
     Node* node = NodeTraversal::nextIncludingPseudo(current, stayWithin);
     while (node && !is<Element>(*node))
-        node = NodeTraversal::nextIncludingPseudo(node, stayWithin);
+        node = NodeTraversal::nextIncludingPseudo(*node, stayWithin);
     return downcast<Element>(node);
 }
 
-inline Element* ElementTraversal::nextIncludingPseudoSkippingChildren(const Node* current, const Node* stayWithin)
+inline Element* ElementTraversal::nextIncludingPseudoSkippingChildren(const Node& current, const Node* stayWithin)
 {
     Node* node = NodeTraversal::nextIncludingPseudoSkippingChildren(current, stayWithin);
     while (node && !is<Element>(*node))
-        node = NodeTraversal::nextIncludingPseudoSkippingChildren(node, stayWithin);
+        node = NodeTraversal::nextIncludingPseudoSkippingChildren(*node, stayWithin);
     return downcast<Element>(node);
 }
 
-inline Element* ElementTraversal::pseudoAwarePreviousSibling(const Node* current)
+inline Element* ElementTraversal::pseudoAwarePreviousSibling(const Node& current)
 {
-    Node* node = current->pseudoAwarePreviousSibling();
+    Node* node = current.pseudoAwarePreviousSibling();
     while (node && !is<Element>(*node))
         node = node->pseudoAwarePreviousSibling();
     return downcast<Element>(node);
index 5c36384..ec7768b 100644 (file)
@@ -94,7 +94,7 @@ void InlineStyleSheetOwner::finishParsingChildren(Element& element)
 
 void InlineStyleSheetOwner::createSheetFromTextContents(Element& element)
 {
-    createSheet(element, TextNodeTraversal::contentsAsString(&element));
+    createSheet(element, TextNodeTraversal::contentsAsString(element));
 }
 
 void InlineStyleSheetOwner::clearSheet()
index b0a37e0..9cc3abe 100644 (file)
@@ -476,7 +476,7 @@ void Node::normalize()
             break;
 
         if (type != TEXT_NODE) {
-            node = NodeTraversal::nextPostOrder(node.get());
+            node = NodeTraversal::nextPostOrder(*node);
             continue;
         }
 
@@ -485,7 +485,7 @@ void Node::normalize()
         // Remove empty text nodes.
         if (!text->length()) {
             // Care must be taken to get the next node before removing the current node.
-            node = NodeTraversal::nextPostOrder(node.get());
+            node = NodeTraversal::nextPostOrder(*node);
             text->remove(IGNORE_EXCEPTION);
             continue;
         }
@@ -509,7 +509,7 @@ void Node::normalize()
             nextText->remove(IGNORE_EXCEPTION);
         }
 
-        node = NodeTraversal::nextPostOrder(node.get());
+        node = NodeTraversal::nextPostOrder(*node);
     }
 }
 
@@ -1597,7 +1597,7 @@ void Node::showNodePathForThis() const
 
 static void traverseTreeAndMark(const String& baseIndent, const Node* rootNode, const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char* markedLabel2)
 {
-    for (const Node* node = rootNode; node; node = NodeTraversal::next(node)) {
+    for (const Node* node = rootNode; node; node = NodeTraversal::next(*node)) {
         if (node == markedNode1)
             fprintf(stderr, "%s", markedLabel1);
         if (node == markedNode2)
index 8b6a148..58b2b9f 100644 (file)
@@ -56,7 +56,7 @@ bool NodeIterator::NodePointer::moveToNext(Node* root)
         isPointerBeforeNode = false;
         return true;
     }
-    node = NodeTraversal::next(node.get(), root);
+    node = NodeTraversal::next(*node, root);
     return node;
 }
 
@@ -72,7 +72,7 @@ bool NodeIterator::NodePointer::moveToPrevious(Node* root)
         node = nullptr;
         return false;
     }
-    node = NodeTraversal::previous(node.get());
+    node = NodeTraversal::previous(*node);
     return node;
 }
 
@@ -175,22 +175,22 @@ void NodeIterator::updateForNodeRemoval(Node& removedNode, NodePointer& referenc
         return;
 
     if (referenceNode.isPointerBeforeNode) {
-        Node* node = NodeTraversal::next(&removedNode, root());
+        Node* node = NodeTraversal::next(removedNode, root());
         if (node) {
             // Move out from under the node being removed if the new reference
             // node is a descendant of the node being removed.
             while (node && node->isDescendantOf(&removedNode))
-                node = NodeTraversal::next(node, root());
+                node = NodeTraversal::next(*node, root());
             if (node)
                 referenceNode.node = node;
         } else {
-            node = NodeTraversal::previous(&removedNode);
+            node = NodeTraversal::previous(removedNode);
             if (node) {
                 // Move out from under the node being removed if the reference node is
                 // a descendant of the node being removed.
                 if (willRemoveReferenceNodeAncestor) {
                     while (node && node->isDescendantOf(&removedNode))
-                        node = NodeTraversal::previous(node);
+                        node = NodeTraversal::previous(*node);
                 }
                 if (node) {
                     // Removing last node.
@@ -202,24 +202,24 @@ void NodeIterator::updateForNodeRemoval(Node& removedNode, NodePointer& referenc
             }
         }
     } else {
-        Node* node = NodeTraversal::previous(&removedNode);
+        Node* node = NodeTraversal::previous(removedNode);
         if (node) {
             // Move out from under the node being removed if the reference node is
             // a descendant of the node being removed.
             if (willRemoveReferenceNodeAncestor) {
                 while (node && node->isDescendantOf(&removedNode))
-                    node = NodeTraversal::previous(node);
+                    node = NodeTraversal::previous(*node);
             }
             if (node)
                 referenceNode.node = node;
         } else {
             // FIXME: This branch doesn't appear to have any LayoutTests.
-            node = NodeTraversal::next(&removedNode, root());
+            node = NodeTraversal::next(removedNode, root());
             // Move out from under the node being removed if the reference node is
             // a descendant of the node being removed.
             if (willRemoveReferenceNodeAncestor) {
                 while (node && node->isDescendantOf(&removedNode))
-                    node = NodeTraversal::previous(node);
+                    node = NodeTraversal::previous(*node);
             }
             if (node)
                 referenceNode.node = node;
index 85298b0..8301e4a 100644 (file)
@@ -31,81 +31,81 @@ namespace WebCore {
 
 namespace NodeTraversal {
 
-Node* previousIncludingPseudo(const Node* current, const Node* stayWithin)
+Node* previousIncludingPseudo(const Node& current, const Node* stayWithin)
 {
     Node* previous;
-    if (current == stayWithin)
+    if (&current == stayWithin)
         return nullptr;
-    if ((previous = current->pseudoAwarePreviousSibling())) {
+    if ((previous = current.pseudoAwarePreviousSibling())) {
         while (previous->pseudoAwareLastChild())
             previous = previous->pseudoAwareLastChild();
         return previous;
     }
-    return is<PseudoElement>(*current) ? downcast<PseudoElement>(*current).hostElement() : current->parentNode();
+    return is<PseudoElement>(current) ? downcast<PseudoElement>(current).hostElement() : current.parentNode();
 }
 
-Node* nextIncludingPseudo(const Node* current, const Node* stayWithin)
+Node* nextIncludingPseudo(const Node& current, const Node* stayWithin)
 {
     Node* next;
-    if ((next = current->pseudoAwareFirstChild()))
+    if ((next = current.pseudoAwareFirstChild()))
         return next;
-    if (current == stayWithin)
+    if (&current == stayWithin)
         return nullptr;
-    if ((next = current->pseudoAwareNextSibling()))
+    if ((next = current.pseudoAwareNextSibling()))
         return next;
-    current = is<PseudoElement>(*current) ? downcast<PseudoElement>(*current).hostElement() : current->parentNode();
-    for (; current; current = current->parentNode()) {
-        if (current == stayWithin)
+    const Node* ancestor = is<PseudoElement>(current) ? downcast<PseudoElement>(current).hostElement() : current.parentNode();
+    for (; ancestor; ancestor = ancestor->parentNode()) {
+        if (ancestor == stayWithin)
             return nullptr;
-        if ((next = current->pseudoAwareNextSibling()))
+        if ((next = ancestor->pseudoAwareNextSibling()))
             return next;
     }
     return nullptr;
 }
 
-Node* nextIncludingPseudoSkippingChildren(const Node* current, const Node* stayWithin)
+Node* nextIncludingPseudoSkippingChildren(const Node& current, const Node* stayWithin)
 {
     Node* next;
-    if (current == stayWithin)
+    if (&current == stayWithin)
         return nullptr;
-    if ((next = current->pseudoAwareNextSibling()))
+    if ((next = current.pseudoAwareNextSibling()))
         return next;
-    current = is<PseudoElement>(*current) ? downcast<PseudoElement>(*current).hostElement() : current->parentNode();
-    for (; current; current = current->parentNode()) {
-        if (current == stayWithin)
+    const Node* ancestor = is<PseudoElement>(current) ? downcast<PseudoElement>(current).hostElement() : current.parentNode();
+    for (; ancestor; ancestor = ancestor->parentNode()) {
+        if (ancestor == stayWithin)
             return nullptr;
-        if ((next = current->pseudoAwareNextSibling()))
+        if ((next = ancestor->pseudoAwareNextSibling()))
             return next;
     }
     return nullptr;
 }
 
-Node* nextAncestorSibling(const Node* current)
+Node* nextAncestorSibling(const Node& current)
 {
-    ASSERT(!current->nextSibling());
-    for (current = current->parentNode(); current; current = current->parentNode()) {
-        if (current->nextSibling())
-            return current->nextSibling();
+    ASSERT(!current.nextSibling());
+    for (auto* ancestor = current.parentNode(); ancestor; ancestor = ancestor->parentNode()) {
+        if (ancestor->nextSibling())
+            return ancestor->nextSibling();
     }
-    return 0;
+    return nullptr;
 }
 
-Node* nextAncestorSibling(const Node* current, const Node* stayWithin)
+Node* nextAncestorSibling(const Node& current, const Node* stayWithin)
 {
-    ASSERT(!current->nextSibling());
-    ASSERT(current != stayWithin);
-    for (current = current->parentNode(); current; current = current->parentNode()) {
-        if (current == stayWithin)
-            return 0;
-        if (current->nextSibling())
-            return current->nextSibling();
+    ASSERT(!current.nextSibling());
+    ASSERT(&current != stayWithin);
+    for (auto* ancestor = current.parentNode(); ancestor; ancestor = ancestor->parentNode()) {
+        if (ancestor == stayWithin)
+            return nullptr;
+        if (ancestor->nextSibling())
+            return ancestor->nextSibling();
     }
-    return 0;
+    return nullptr;
 }
 
-Node* last(const ContainerNode* current)
+Node* last(const ContainerNode& current)
 {
-    Node* node = current->lastChild();
+    Node* node = current.lastChild();
     if (!node)
         return nullptr;
     while (node->lastChild())
@@ -113,69 +113,70 @@ Node* last(const ContainerNode* current)
     return node;
 }
 
-Node* deepLastChild(Node* node)
+Node* deepLastChild(Node& node)
 {
-    while (node->lastChild())
-        node = node->lastChild();
-    return node;
+    Node* lastChild = &node;
+    while (lastChild->lastChild())
+        lastChild = lastChild->lastChild();
+    return lastChild;
 }
 
-Node* previousSkippingChildren(const Node* current, const Node* stayWithin)
+Node* previousSkippingChildren(const Node& current, const Node* stayWithin)
 {
-    if (current == stayWithin)
-        return 0;
-    if (current->previousSibling())
-        return current->previousSibling();
-    for (current = current->parentNode(); current; current = current->parentNode()) {
-        if (current == stayWithin)
-            return 0;
-        if (current->previousSibling())
-            return current->previousSibling();
+    if (&current == stayWithin)
+        return nullptr;
+    if (current.previousSibling())
+        return current.previousSibling();
+    for (auto* ancestor = current.parentNode(); ancestor; ancestor = ancestor->parentNode()) {
+        if (ancestor == stayWithin)
+            return nullptr;
+        if (ancestor->previousSibling())
+            return ancestor->previousSibling();
     }
-    return 0;
+    return nullptr;
 }
 
-Node* nextPostOrder(const Node* current, const Node* stayWithin)
+Node* nextPostOrder(const Node& current, const Node* stayWithin)
 {
-    if (current == stayWithin)
-        return 0;
-    if (!current->nextSibling())
-        return current->parentNode();
-    Node* next = current->nextSibling();
+    if (&current == stayWithin)
+        return nullptr;
+    if (!current.nextSibling())
+        return current.parentNode();
+    Node* next = current.nextSibling();
     while (next->firstChild())
         next = next->firstChild();
     return next;
 }
 
-static Node* previousAncestorSiblingPostOrder(const Node* current, const Node* stayWithin)
+static Node* previousAncestorSiblingPostOrder(const Node& current, const Node* stayWithin)
 {
-    ASSERT(!current->previousSibling());
-    for (current = current->parentNode(); current; current = current->parentNode()) {
-        if (current == stayWithin)
-            return 0;
-        if (current->previousSibling())
-            return current->previousSibling();
+    ASSERT(!current.previousSibling());
+    for (auto* ancestor = current.parentNode(); ancestor; ancestor = ancestor->parentNode()) {
+        if (ancestor == stayWithin)
+            return nullptr;
+        if (ancestor->previousSibling())
+            return ancestor->previousSibling();
     }
-    return 0;
+    return nullptr;
 }
 
-Node* previousPostOrder(const Node* current, const Node* stayWithin)
+Node* previousPostOrder(const Node& current, const Node* stayWithin)
 {
-    if (current->lastChild())
-        return current->lastChild();
-    if (current == stayWithin)
-        return 0;
-    if (current->previousSibling())
-        return current->previousSibling();
+    if (current.lastChild())
+        return current.lastChild();
+    if (&current == stayWithin)
+        return nullptr;
+    if (current.previousSibling())
+        return current.previousSibling();
     return previousAncestorSiblingPostOrder(current, stayWithin);
 }
 
-Node* previousSkippingChildrenPostOrder(const Node* current, const Node* stayWithin)
+Node* previousSkippingChildrenPostOrder(const Node& current, const Node* stayWithin)
 {
-    if (current == stayWithin)
-        return 0;
-    if (current->previousSibling())
-        return current->previousSibling();
+    if (&current == stayWithin)
+        return nullptr;
+    if (current.previousSibling())
+        return current.previousSibling();
     return previousAncestorSiblingPostOrder(current, stayWithin);
 }
 
index fb12fa8..2c44b8a 100644 (file)
@@ -35,96 +35,96 @@ namespace NodeTraversal {
 // This uses the same order that tags appear in the source file. If the stayWithin
 // argument is non-null, the traversal will stop once the specified node is reached.
 // This can be used to restrict traversal to a particular sub-tree.
-Node* next(const Node*);
-Node* next(const Node*, const Node* stayWithin);
-Node* next(const ContainerNode*);
-Node* next(const ContainerNode*, const Node* stayWithin);
-Node* next(const Text*);
-Node* next(const Text*, const Node* stayWithin);
+Node* next(const Node&);
+Node* next(const Node&, const Node* stayWithin);
+Node* next(const ContainerNode&);
+Node* next(const ContainerNode&, const Node* stayWithin);
+Node* next(const Text&);
+Node* next(const Text&, const Node* stayWithin);
 
 // Like next, but skips children and starts with the next sibling.
-Node* nextSkippingChildren(const Node*);
-Node* nextSkippingChildren(const Node*, const Node* stayWithin);
+Node* nextSkippingChildren(const Node&);
+Node* nextSkippingChildren(const Node&, const Node* stayWithin);
 
 // Does a reverse pre-order traversal to find the node that comes before the current one in document order
-Node* last(const ContainerNode*);
-Node* previous(const Node*, const Node* stayWithin = 0);
+Node* last(const ContainerNode&);
+Node* previous(const Node&, const Node* stayWithin = nullptr);
 
 // Like previous, but skips children and starts with the next sibling.
-Node* previousSkippingChildren(const Node*, const Node* stayWithin = 0);
+Node* previousSkippingChildren(const Node&, const Node* stayWithin = nullptr);
 
 // Like next, but visits parents after their children.
-Node* nextPostOrder(const Node*, const Node* stayWithin = 0);
+Node* nextPostOrder(const Node&, const Node* stayWithin = nullptr);
 
 // Like previous/previousSkippingChildren, but visits parents before their children.
-Node* previousPostOrder(const Node*, const Node* stayWithin = 0);
-Node* previousSkippingChildrenPostOrder(const Node*, const Node* stayWithin = 0);
+Node* previousPostOrder(const Node&, const Node* stayWithin = nullptr);
+Node* previousSkippingChildrenPostOrder(const Node&, const Node* stayWithin = nullptr);
 
 // Pre-order traversal including the pseudo-elements.
-Node* previousIncludingPseudo(const Node*, const Node* = 0);
-Node* nextIncludingPseudo(const Node*, const Node* = 0);
-Node* nextIncludingPseudoSkippingChildren(const Node*, const Node* = 0);
+Node* previousIncludingPseudo(const Node&, const Node* = nullptr);
+Node* nextIncludingPseudo(const Node&, const Node* = nullptr);
+Node* nextIncludingPseudoSkippingChildren(const Node&, const Node* = nullptr);
 
 }
 
 namespace NodeTraversal {
 
-WEBCORE_EXPORT Node* nextAncestorSibling(const Node*);
-WEBCORE_EXPORT Node* nextAncestorSibling(const Node*, const Node* stayWithin);
-WEBCORE_EXPORT Node* deepLastChild(Node*);
+WEBCORE_EXPORT Node* nextAncestorSibling(const Node&);
+WEBCORE_EXPORT Node* nextAncestorSibling(const Node&, const Node* stayWithin);
+WEBCORE_EXPORT Node* deepLastChild(Node&);
 
 template <class NodeType>
-inline Node* traverseNextTemplate(NodeType* current)
+inline Node* traverseNextTemplate(NodeType& current)
 {
-    if (current->firstChild())
-        return current->firstChild();
-    if (current->nextSibling())
-        return current->nextSibling();
+    if (current.firstChild())
+        return current.firstChild();
+    if (current.nextSibling())
+        return current.nextSibling();
     return nextAncestorSibling(current);
 }
-inline Node* next(const Node* current) { return traverseNextTemplate(current); }
-inline Node* next(const ContainerNode* current) { return traverseNextTemplate(current); }
+inline Node* next(const Node& current) { return traverseNextTemplate(current); }
+inline Node* next(const ContainerNode& current) { return traverseNextTemplate(current); }
 
 template <class NodeType>
-inline Node* traverseNextTemplate(NodeType* current, const Node* stayWithin)
+inline Node* traverseNextTemplate(NodeType& current, const Node* stayWithin)
 {
-    if (current->firstChild())
-        return current->firstChild();
-    if (current == stayWithin)
-        return 0;
-    if (current->nextSibling())
-        return current->nextSibling();
+    if (current.firstChild())
+        return current.firstChild();
+    if (&current == stayWithin)
+        return nullptr;
+    if (current.nextSibling())
+        return current.nextSibling();
     return nextAncestorSibling(current, stayWithin);
 }
-inline Node* next(const Node* current, const Node* stayWithin) { return traverseNextTemplate(current, stayWithin); }
-inline Node* next(const ContainerNode* current, const Node* stayWithin) { return traverseNextTemplate(current, stayWithin); }
+inline Node* next(const Node& current, const Node* stayWithin) { return traverseNextTemplate(current, stayWithin); }
+inline Node* next(const ContainerNode& current, const Node* stayWithin) { return traverseNextTemplate(current, stayWithin); }
 
-inline Node* nextSkippingChildren(const Node* current)
+inline Node* nextSkippingChildren(const Node& current)
 {
-    if (current->nextSibling())
-        return current->nextSibling();
+    if (current.nextSibling())
+        return current.nextSibling();
     return nextAncestorSibling(current);
 }
 
-inline Node* nextSkippingChildren(const Node* current, const Node* stayWithin)
+inline Node* nextSkippingChildren(const Node& current, const Node* stayWithin)
 {
-    if (current == stayWithin)
-        return 0;
-    if (current->nextSibling())
-        return current->nextSibling();
+    if (&current == stayWithin)
+        return nullptr;
+    if (current.nextSibling())
+        return current.nextSibling();
     return nextAncestorSibling(current, stayWithin);
 }
 
-inline Node* next(const Text* current) { return nextSkippingChildren(current); }
-inline Node* next(const Text* current, const Node* stayWithin) { return nextSkippingChildren(current, stayWithin); }
+inline Node* next(const Text& current) { return nextSkippingChildren(current); }
+inline Node* next(const Text& current, const Node* stayWithin) { return nextSkippingChildren(current, stayWithin); }
 
-inline Node* previous(const Node* current, const Node* stayWithin)
+inline Node* previous(const Node& current, const Node* stayWithin)
 {
-    if (Node* previous = current->previousSibling())
-        return deepLastChild(previous);
-    if (current->parentNode() == stayWithin)
+    if (Node* previous = current.previousSibling())
+        return deepLastChild(*previous);
+    if (current.parentNode() == stayWithin)
         return nullptr;
-    return current->parentNode();
+    return current.parentNode();
 }
 
 }
index ef63c9d..4ce102d 100644 (file)
@@ -1071,7 +1071,7 @@ String Range::toString(ExceptionCode& ec) const
     StringBuilder builder;
 
     Node* pastLast = pastLastNode();
-    for (Node* n = firstNode(); n != pastLast; n = NodeTraversal::next(n)) {
+    for (Node* n = firstNode(); n != pastLast; n = NodeTraversal::next(*n)) {
         if (n->nodeType() == Node::TEXT_NODE || n->nodeType() == Node::CDATA_SECTION_NODE) {
             const String& data = static_cast<CharacterData*>(n)->data();
             int length = data.length();
@@ -1513,7 +1513,7 @@ void Range::checkDeleteExtract(ExceptionCode& ec)
         return;
         
     Node* pastLast = pastLastNode();
-    for (Node* n = firstNode(); n != pastLast; n = NodeTraversal::next(n)) {
+    for (Node* n = firstNode(); n != pastLast; n = NodeTraversal::next(*n)) {
         if (n->isReadOnlyNode()) {
             ec = NO_MODIFICATION_ALLOWED_ERR;
             return;
@@ -1546,14 +1546,14 @@ bool Range::containedByReadOnly() const
 Node* Range::firstNode() const
 {
     if (!m_start.container())
-        return 0;
+        return nullptr;
     if (m_start.container()->offsetInCharacters())
         return m_start.container();
     if (Node* child = m_start.container()->traverseToChildAt(m_start.offset()))
         return child;
     if (!m_start.offset())
         return m_start.container();
-    return NodeTraversal::nextSkippingChildren(m_start.container());
+    return NodeTraversal::nextSkippingChildren(*m_start.container());
 }
 
 ShadowRoot* Range::shadowRoot() const
@@ -1564,12 +1564,12 @@ ShadowRoot* Range::shadowRoot() const
 Node* Range::pastLastNode() const
 {
     if (!m_start.container() || !m_end.container())
-        return 0;
+        return nullptr;
     if (m_end.container()->offsetInCharacters())
-        return NodeTraversal::nextSkippingChildren(m_end.container());
+        return NodeTraversal::nextSkippingChildren(*m_end.container());
     if (Node* child = m_end.container()->traverseToChildAt(m_end.offset()))
         return child;
-    return NodeTraversal::nextSkippingChildren(m_end.container());
+    return NodeTraversal::nextSkippingChildren(*m_end.container());
 }
 
 IntRect Range::boundingBox() const
@@ -1598,7 +1598,7 @@ void Range::textRects(Vector<IntRect>& rects, bool useSelectionHeight, RangeInFi
     bool someFixed = false;
 
     Node* stopNode = pastLastNode();
-    for (Node* node = firstNode(); node != stopNode; node = NodeTraversal::next(node)) {
+    for (Node* node = firstNode(); node != stopNode; node = NodeTraversal::next(*node)) {
         RenderObject* renderer = node->renderer();
         if (!renderer)
             continue;
@@ -1634,7 +1634,7 @@ void Range::textQuads(Vector<FloatQuad>& quads, bool useSelectionHeight, RangeIn
     bool someFixed = false;
 
     Node* stopNode = pastLastNode();
-    for (Node* node = firstNode(); node != stopNode; node = NodeTraversal::next(node)) {
+    for (Node* node = firstNode(); node != stopNode; node = NodeTraversal::next(*node)) {
         RenderObject* renderer = node->renderer();
         if (!renderer)
             continue;
@@ -1715,7 +1715,7 @@ void Range::collectSelectionRects(Vector<SelectionRect>& rects)
     Node* stopNode = pastLastNode();
     bool hasFlippedWritingMode = startContainer->renderer() && startContainer->renderer()->style().isFlippedBlocksWritingMode();
     bool containsDifferentWritingModes = false;
-    for (Node* node = firstNode(); node && node != stopNode; node = NodeTraversal::next(node)) {
+    for (Node* node = firstNode(); node && node != stopNode; node = NodeTraversal::next(*node)) {
         RenderObject* renderer = node->renderer();
         // Only ask leaf render objects for their line box rects.
         if (renderer && !renderer->firstChildSlow() && renderer->style().userSelect() != SELECT_NONE) {
@@ -2197,7 +2197,7 @@ void Range::getBorderAndTextQuads(Vector<FloatQuad>& quads) const
     Node* stopNode = pastLastNode();
 
     HashSet<Node*> selectedElementsSet;
-    for (Node* node = firstNode(); node != stopNode; node = NodeTraversal::next(node)) {
+    for (Node* node = firstNode(); node != stopNode; node = NodeTraversal::next(*node)) {
         if (node->isElementNode())
             selectedElementsSet.add(node);
     }
@@ -2207,7 +2207,7 @@ void Range::getBorderAndTextQuads(Vector<FloatQuad>& quads) const
     for (Node* parent = lastNode->parentNode(); parent; parent = parent->parentNode())
         selectedElementsSet.remove(parent);
 
-    for (Node* node = firstNode(); node != stopNode; node = NodeTraversal::next(node)) {
+    for (Node* node = firstNode(); node != stopNode; node = NodeTraversal::next(*node)) {
         if (is<Element>(*node) && selectedElementsSet.contains(node) && !selectedElementsSet.contains(node->parentNode())) {
             if (RenderBoxModelObject* renderBoxModelObject = downcast<Element>(*node).renderBoxModelObject()) {
                 Vector<FloatQuad> elementQuads;
index f8dc70a..c731b87 100644 (file)
@@ -377,7 +377,7 @@ bool ScriptElement::isScriptForEventSupported() const
 
 String ScriptElement::scriptContent() const
 {
-    return TextNodeTraversal::contentsAsString(&m_element);
+    return TextNodeTraversal::contentsAsString(m_element);
 }
 
 ScriptElement* toScriptElementIfPossible(Element* element)
index ebfa4ca..e93fdbf 100644 (file)
@@ -139,7 +139,7 @@ RefPtr<Node> ShadowRoot::cloneNodeInternal(Document&, CloningOperation)
 void ShadowRoot::removeAllEventListeners()
 {
     DocumentFragment::removeAllEventListeners();
-    for (Node* node = firstChild(); node; node = NodeTraversal::next(node))
+    for (Node* node = firstChild(); node; node = NodeTraversal::next(*node))
         node->removeAllEventListeners();
 }
 
index a1e0cab..f90f03f 100644 (file)
@@ -111,10 +111,11 @@ String Text::wholeText() const
 {
     const Text* startText = earliestLogicallyAdjacentTextNode(this);
     const Text* endText = latestLogicallyAdjacentTextNode(this);
-    const Node* onePastEndText = TextNodeTraversal::nextSibling(endText);
+    ASSERT(endText);
+    const Node* onePastEndText = TextNodeTraversal::nextSibling(*endText);
 
     StringBuilder result;
-    for (const Text* text = startText; text != onePastEndText; text = TextNodeTraversal::nextSibling(text))
+    for (const Text* text = startText; text != onePastEndText; text = TextNodeTraversal::nextSibling(*text))
         result.append(text->data());
     return result.toString();
 }
index ae23b31..112a284 100644 (file)
 namespace WebCore {
 namespace TextNodeTraversal {
 
-void appendContents(const ContainerNode* root, StringBuilder& result)
+void appendContents(const ContainerNode& root, StringBuilder& result)
 {
-    for (Text* text = TextNodeTraversal::firstWithin(root); text; text = TextNodeTraversal::next(text, root))
+    for (Text* text = TextNodeTraversal::firstWithin(root); text; text = TextNodeTraversal::next(*text, &root))
         result.append(text->data());
 }
 
-String contentsAsString(const ContainerNode* root)
+String contentsAsString(const ContainerNode& root)
 {
     StringBuilder result;
     appendContents(root, result);
     return result.toString();
 }
 
-String contentsAsString(const Node* root)
+String contentsAsString(const Node& root)
 {
-    ASSERT(root);
-    if (is<Text>(*root))
-        return downcast<Text>(*root).data();
-    if (is<ContainerNode>(*root))
+    if (is<Text>(root))
+        return downcast<Text>(root).data();
+    if (is<ContainerNode>(root))
         return contentsAsString(downcast<ContainerNode>(root));
     return String();
 }
index 8bab7b1..397c806 100644 (file)
@@ -37,78 +37,78 @@ namespace WebCore {
 namespace TextNodeTraversal {
 
 // First text child of the node.
-Text* firstChild(const Node*);
-Text* firstChild(const ContainerNode*);
+Text* firstChild(const Node&);
+Text* firstChild(const ContainerNode&);
 
 // First text descendant of the node.
-Text* firstWithin(const Node*);
-Text* firstWithin(const ContainerNode*);
+Text* firstWithin(const Node&);
+Text* firstWithin(const ContainerNode&);
 
 // Pre-order traversal skipping non-text nodes.
-Text* next(const Node*);
-Text* next(const Node*, const Node* stayWithin);
-Text* next(const Text*);
-Text* next(const Text*, const Node* stayWithin);
+Text* next(const Node&);
+Text* next(const Node&, const Node* stayWithin);
+Text* next(const Text&);
+Text* next(const Text&, const Node* stayWithin);
 
 // Next text sibling.
-Text* nextSibling(const Node*);
+Text* nextSibling(const Node&);
 
 // Concatenated text contents of a subtree.
-String contentsAsString(const Node*);
-String contentsAsString(const ContainerNode*);
-void appendContents(const ContainerNode*, StringBuilder& result);
+String contentsAsString(const Node&);
+String contentsAsString(const ContainerNode&);
+void appendContents(const ContainerNode&, StringBuilder& result);
 
 }
 
 namespace TextNodeTraversal {
 
 template <class NodeType>
-inline Text* firstTextChildTemplate(NodeType* current)
+inline Text* firstTextChildTemplate(NodeType& current)
 {
-    Node* node = current->firstChild();
+    Node* node = current.firstChild();
     while (node && !is<Text>(*node))
         node = node->nextSibling();
     return downcast<Text>(node);
 }
-inline Text* firstChild(const Node* current) { return firstTextChildTemplate(current); }
-inline Text* firstChild(const ContainerNode* current) { return firstTextChildTemplate(current); }
+inline Text* firstChild(const Node& current) { return firstTextChildTemplate(current); }
+inline Text* firstChild(const ContainerNode& current) { return firstTextChildTemplate(current); }
 
 template <class NodeType>
-inline Text* firstTextWithinTemplate(NodeType* current)
+inline Text* firstTextWithinTemplate(NodeType& current)
 {
-    Node* node = current->firstChild();
+    Node* node = current.firstChild();
     while (node && !is<Text>(*node))
-        node = NodeTraversal::next(node, current);
+        node = NodeTraversal::next(*node, &current);
     return downcast<Text>(node);
 }
-inline Text* firstWithin(const Node* current) { return firstTextWithinTemplate(current); }
-inline Text* firstWithin(const ContainerNode* current) { return firstTextWithinTemplate(current); }
+inline Text* firstWithin(const Node& current) { return firstTextWithinTemplate(current); }
+inline Text* firstWithin(const ContainerNode& current) { return firstTextWithinTemplate(current); }
 
 template <class NodeType>
-inline Text* traverseNextTextTemplate(NodeType* current)
+inline Text* traverseNextTextTemplate(NodeType& current)
 {
     Node* node = NodeTraversal::next(current);
     while (node && !is<Text>(*node))
-        node = NodeTraversal::next(node);
+        node = NodeTraversal::next(*node);
     return downcast<Text>(node);
 }
-inline Text* next(const Node* current) { return traverseNextTextTemplate(current); }
-inline Text* next(const Text* current) { return traverseNextTextTemplate(current); }
+inline Text* next(const Node& current) { return traverseNextTextTemplate(current); }
+inline Text* next(const Text& current) { return traverseNextTextTemplate(current); }
 
 template <class NodeType>
-inline Text* traverseNextTextTemplate(NodeType* current, const Node* stayWithin)
+inline Text* traverseNextTextTemplate(NodeType& current, const Node* stayWithin)
 {
     Node* node = NodeTraversal::next(current, stayWithin);
     while (node && !is<Text>(*node))
-        node = NodeTraversal::next(node, stayWithin);
+        node = NodeTraversal::next(*node, stayWithin);
     return downcast<Text>(node);
 }
-inline Text* next(const Node* current, const Node* stayWithin) { return traverseNextTextTemplate(current, stayWithin); }
-inline Text* next(const Text* current, const Node* stayWithin) { return traverseNextTextTemplate(current, stayWithin); }
+inline Text* next(const Node& current, const Node* stayWithin) { return traverseNextTextTemplate(current, stayWithin); }
+inline Text* next(const Text& current, const Node* stayWithin) { return traverseNextTextTemplate(current, stayWithin); }
 
-inline Text* nextSibling(const Node* current)
+inline Text* nextSibling(const Node& current)
 {
-    Node* node = current->nextSibling();
+    Node* node = current.nextSibling();
     while (node && !is<Text>(*node))
         node = node->nextSibling();
     return downcast<Text>(node);
index 0f17527..4ff0c6f 100644 (file)
@@ -49,7 +49,7 @@ void TreeScopeAdopter::moveTreeToNewScope(Node* root) const
         oldDocument.incDOMTreeVersion();
     }
 
-    for (Node* node = root; node; node = NodeTraversal::next(node, root)) {
+    for (Node* node = root; node; node = NodeTraversal::next(*node, root)) {
         updateTreeScope(node);
 
         if (willMoveToNewDocument)
@@ -82,7 +82,7 @@ void TreeScopeAdopter::moveTreeToNewScope(Node* root) const
 
 void TreeScopeAdopter::moveShadowTreeToNewDocument(ShadowRoot* shadowRoot, Document* oldDocument, Document* newDocument) const
 {
-    for (Node* node = shadowRoot; node; node = NodeTraversal::next(node, shadowRoot)) {
+    for (Node* node = shadowRoot; node; node = NodeTraversal::next(*node, shadowRoot)) {
         moveNodeToNewDocument(node, oldDocument, newDocument);
         if (ShadowRoot* shadow = node->shadowRoot())
             moveShadowTreeToNewDocument(shadow, oldDocument, newDocument);
@@ -91,7 +91,7 @@ void TreeScopeAdopter::moveShadowTreeToNewDocument(ShadowRoot* shadowRoot, Docum
 
 #ifndef NDEBUG
 static bool didMoveToNewDocumentWasCalled = false;
-static Document* oldDocumentDidMoveToNewDocumentWasCalledWith = 0;
+static Document* oldDocumentDidMoveToNewDocumentWasCalledWith = nullptr;
 
 void TreeScopeAdopter::ensureDidMoveToNewDocumentWasCalled(Document* oldDocument)
 {
index 1758ab2..4cb2ebb 100644 (file)
@@ -257,23 +257,23 @@ Children:
         node = firstChild;
         short acceptNodeResult = acceptNode(state, node.get());
         if (state && state->hadException())
-            return 0;
+            return nullptr;
         if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
             return setCurrent(node.release());
         if (acceptNodeResult == NodeFilter::FILTER_REJECT)
             break;
     }
-    while (Node* nextSibling = NodeTraversal::nextSkippingChildren(node.get(), root())) {
+    while (Node* nextSibling = NodeTraversal::nextSkippingChildren(*node, root())) {
         node = nextSibling;
         short acceptNodeResult = acceptNode(state, node.get());
         if (state && state->hadException())
-            return 0;
+            return nullptr;
         if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
             return setCurrent(node.release());
         if (acceptNodeResult == NodeFilter::FILTER_SKIP)
             goto Children;
     }
-    return 0;
+    return nullptr;
 }
 
 } // namespace WebCore
index 94ee3c0..0e2251e 100644 (file)
@@ -133,7 +133,7 @@ inline TypedElementDescendantIteratorAdapter<ElementType>::TypedElementDescendan
 template <typename ElementType>
 inline TypedElementDescendantIterator<ElementType> TypedElementDescendantIteratorAdapter<ElementType>::begin()
 {
-    return TypedElementDescendantIterator<ElementType>(m_root, Traversal<ElementType>::firstWithin(&m_root));
+    return TypedElementDescendantIterator<ElementType>(m_root, Traversal<ElementType>::firstWithin(m_root));
 }
 
 template <typename ElementType>
@@ -155,20 +155,20 @@ inline TypedElementDescendantIterator<ElementType> TypedElementDescendantIterato
     ASSERT(descendant.isDescendantOf(&m_root));
     if (is<ElementType>(descendant))
         return TypedElementDescendantIterator<ElementType>(m_root, downcast<ElementType>(&descendant));
-    ElementType* next = Traversal<ElementType>::next(&descendant, &m_root);
+    ElementType* next = Traversal<ElementType>::next(descendant, &m_root);
     return TypedElementDescendantIterator<ElementType>(m_root, next);
 }
 
 template <typename ElementType>
 inline ElementType* TypedElementDescendantIteratorAdapter<ElementType>::first()
 {
-    return Traversal<ElementType>::firstWithin(&m_root);
+    return Traversal<ElementType>::firstWithin(m_root);
 }
 
 template <typename ElementType>
 inline ElementType* TypedElementDescendantIteratorAdapter<ElementType>::last()
 {
-    return Traversal<ElementType>::lastWithin(&m_root);
+    return Traversal<ElementType>::lastWithin(m_root);
 }
 
 // TypedElementDescendantConstIteratorAdapter
@@ -182,7 +182,7 @@ inline TypedElementDescendantConstIteratorAdapter<ElementType>::TypedElementDesc
 template <typename ElementType>
 inline TypedElementDescendantConstIterator<ElementType> TypedElementDescendantConstIteratorAdapter<ElementType>::begin() const
 {
-    return TypedElementDescendantConstIterator<ElementType>(m_root, Traversal<ElementType>::firstWithin(&m_root));
+    return TypedElementDescendantConstIterator<ElementType>(m_root, Traversal<ElementType>::firstWithin(m_root));
 }
 
 template <typename ElementType>
@@ -204,20 +204,20 @@ inline TypedElementDescendantConstIterator<ElementType> TypedElementDescendantCo
     ASSERT(descendant.isDescendantOf(&m_root));
     if (is<ElementType>(descendant))
         return TypedElementDescendantConstIterator<ElementType>(m_root, downcast<ElementType>(&descendant));
-    const ElementType* next = Traversal<ElementType>::next(&descendant, &m_root);
+    const ElementType* next = Traversal<ElementType>::next(descendant, &m_root);
     return TypedElementDescendantConstIterator<ElementType>(m_root, next);
 }
 
 template <typename ElementType>
 inline const ElementType* TypedElementDescendantConstIteratorAdapter<ElementType>::first() const
 {
-    return Traversal<ElementType>::firstWithin(&m_root);
+    return Traversal<ElementType>::firstWithin(m_root);
 }
 
 template <typename ElementType>
 inline const ElementType* TypedElementDescendantConstIteratorAdapter<ElementType>::last() const
 {
-    return Traversal<ElementType>::lastWithin(&m_root);
+    return Traversal<ElementType>::lastWithin(m_root);
 }
 
 // Standalone functions
index 5ccf92d..ad3d954 100644 (file)
@@ -359,26 +359,26 @@ void ApplyStyleCommand::applyRelativeFontStyleChange(EditingStyle* style)
     // an ancestor of the start node), we gather nodes up to the next sibling of the end node
     Node *beyondEnd;
     if (start.deprecatedNode()->isDescendantOf(end.deprecatedNode()))
-        beyondEnd = NodeTraversal::nextSkippingChildren(end.deprecatedNode());
+        beyondEnd = NodeTraversal::nextSkippingChildren(*end.deprecatedNode());
     else
-        beyondEnd = NodeTraversal::next(end.deprecatedNode());
+        beyondEnd = NodeTraversal::next(*end.deprecatedNode());
     
     start = start.upstream(); // Move upstream to ensure we do not add redundant spans.
     Node* startNode = start.deprecatedNode();
     if (startNode->isTextNode() && start.deprecatedEditingOffset() >= caretMaxOffset(startNode)) // Move out of text node if range does not include its characters.
-        startNode = NodeTraversal::next(startNode);
+        startNode = NodeTraversal::next(*startNode);
 
     // Store away font size before making any changes to the document.
     // This ensures that changes to one node won't effect another.
     HashMap<Node*, float> startingFontSizes;
-    for (Node *node = startNode; node != beyondEnd; node = NodeTraversal::next(node))
+    for (Node *node = startNode; node != beyondEnd; node = NodeTraversal::next(*node))
         startingFontSizes.set(node, computedFontSize(node));
 
     // These spans were added by us. If empty after font size changes, they can be removed.
     Vector<RefPtr<HTMLElement>> unstyledSpans;
     
     Node* lastStyledNode = 0;
-    for (Node* node = startNode; node != beyondEnd; node = NodeTraversal::next(node)) {
+    for (Node* node = startNode; node != beyondEnd; node = NodeTraversal::next(*node)) {
         RefPtr<HTMLElement> element;
         if (is<HTMLElement>(*node)) {
             // Only work on fully selected nodes.
@@ -683,19 +683,19 @@ void ApplyStyleCommand::fixRangeAndApplyInlineStyle(EditingStyle* style, const P
     Node* startNode = start.deprecatedNode();
 
     if (start.deprecatedEditingOffset() >= caretMaxOffset(start.deprecatedNode())) {
-        startNode = NodeTraversal::next(startNode);
+        startNode = NodeTraversal::next(*startNode);
         if (!startNode || comparePositions(end, firstPositionInOrBeforeNode(startNode)) < 0)
             return;
     }
 
     Node* pastEndNode = end.deprecatedNode();
     if (end.deprecatedEditingOffset() >= caretMaxOffset(end.deprecatedNode()))
-        pastEndNode = NodeTraversal::nextSkippingChildren(end.deprecatedNode());
+        pastEndNode = NodeTraversal::nextSkippingChildren(*end.deprecatedNode());
 
     // FIXME: Callers should perform this operation on a Range that includes the br
     // if they want style applied to the empty line.
     if (start == end && start.deprecatedNode()->hasTagName(brTag))
-        pastEndNode = NodeTraversal::next(start.deprecatedNode());
+        pastEndNode = NodeTraversal::next(*start.deprecatedNode());
 
     // Start from the highest fully selected ancestor so that we can modify the fully selected node.
     // e.g. When applying font-size: large on <font color="blue">hello</font>, we need to include the font element in our run
@@ -710,14 +710,14 @@ void ApplyStyleCommand::fixRangeAndApplyInlineStyle(EditingStyle* style, const P
     applyInlineStyleToNodeRange(style, startNode, pastEndNode);
 }
 
-static bool containsNonEditableRegion(Node* node)
+static bool containsNonEditableRegion(Node& node)
 {
-    if (!node->hasEditableStyle())
+    if (!node.hasEditableStyle())
         return true;
 
     Node* sibling = NodeTraversal::nextSkippingChildren(node);
-    for (Node* descendent = node->firstChild(); descendent && descendent != sibling; descendent = NodeTraversal::next(descendent)) {
-        if (!descendent->hasEditableStyle())
+    for (Node* descendant = node.firstChild(); descendant && descendant != sibling; descendant = NodeTraversal::next(*descendant)) {
+        if (!descendant->hasEditableStyle())
             return true;
     }
 
@@ -756,7 +756,7 @@ void ApplyStyleCommand::applyInlineStyleToNodeRange(EditingStyle* style, PassRef
     Vector<InlineRunToApplyStyle> runs;
     RefPtr<Node> node = startNode;
     for (RefPtr<Node> next; node && node != pastEndNode; node = next) {
-        next = NodeTraversal::next(node.get());
+        next = NodeTraversal::next(*node);
 
         if (!node->renderer() || !node->hasEditableStyle())
             continue;
@@ -773,7 +773,7 @@ void ApplyStyleCommand::applyInlineStyleToNodeRange(EditingStyle* style, PassRef
             if (MutableStyleProperties* otherStyle = style->style())
                 inlineStyle->mergeAndOverrideOnConflict(*otherStyle);
             setNodeAttribute(&element, styleAttr, inlineStyle->asText());
-            next = NodeTraversal::nextSkippingChildren(node.get());
+            next = NodeTraversal::nextSkippingChildren(*node);
             continue;
         }
         
@@ -781,10 +781,10 @@ void ApplyStyleCommand::applyInlineStyleToNodeRange(EditingStyle* style, PassRef
             continue;
         
         if (node->hasChildNodes()) {
-            if (node->contains(pastEndNode.get()) || containsNonEditableRegion(node.get()) || !node->parentNode()->hasEditableStyle())
+            if (node->contains(pastEndNode.get()) || containsNonEditableRegion(*node) || !node->parentNode()->hasEditableStyle())
                 continue;
             if (editingIgnoresContent(node.get())) {
-                next = NodeTraversal::nextSkippingChildren(node.get());
+                next = NodeTraversal::nextSkippingChildren(*node);
                 continue;
             }
         }
@@ -792,15 +792,13 @@ void ApplyStyleCommand::applyInlineStyleToNodeRange(EditingStyle* style, PassRef
         Node* runStart = node.get();
         Node* runEnd = node.get();
         Node* sibling = node->nextSibling();
-        while (sibling && sibling != pastEndNode && !sibling->contains(pastEndNode.get())
-               && (!isBlock(sibling) || sibling->hasTagName(brTag))
-               && !containsNonEditableRegion(sibling)) {
+        while (sibling && sibling != pastEndNode && !sibling->contains(pastEndNode.get()) && (!isBlock(sibling) || sibling->hasTagName(brTag)) && !containsNonEditableRegion(*sibling)) {
             runEnd = sibling;
             sibling = runEnd->nextSibling();
         }
-        next = NodeTraversal::nextSkippingChildren(runEnd);
+        next = NodeTraversal::nextSkippingChildren(*runEnd);
 
-        Node* pastEndNode = NodeTraversal::nextSkippingChildren(runEnd);
+        Node* pastEndNode = NodeTraversal::nextSkippingChildren(*runEnd);
         if (!shouldApplyInlineStyleToRun(style, runStart, pastEndNode))
             continue;
 
@@ -837,7 +835,7 @@ bool ApplyStyleCommand::shouldApplyInlineStyleToRun(EditingStyle* style, Node* r
 {
     ASSERT(style && runStart);
 
-    for (Node* node = runStart; node && node != pastEndNode; node = NodeTraversal::next(node)) {
+    for (Node* node = runStart; node && node != pastEndNode; node = NodeTraversal::next(*node)) {
         if (node->hasChildNodes())
             continue;
         // We don't consider m_isInlineElementToRemoveFunction here because we never apply style when m_isInlineElementToRemoveFunction is specified
@@ -856,9 +854,9 @@ void ApplyStyleCommand::removeConflictingInlineStyleFromRun(EditingStyle* style,
     for (RefPtr<Node> node = next; node && node->inDocument() && node != pastEndNode; node = next) {
         if (editingIgnoresContent(node.get())) {
             ASSERT(!node->contains(pastEndNode.get()));
-            next = NodeTraversal::nextSkippingChildren(node.get());
+            next = NodeTraversal::nextSkippingChildren(*node);
         } else
-            next = NodeTraversal::next(node.get());
+            next = NodeTraversal::next(*node);
 
         if (!is<HTMLElement>(*node))
             continue;
@@ -1119,30 +1117,30 @@ void ApplyStyleCommand::removeInlineStyle(EditingStyle* style, const Position &s
         RefPtr<Node> next;
         if (editingIgnoresContent(node.get())) {
             ASSERT(node == end.deprecatedNode() || !node->contains(end.deprecatedNode()));
-            next = NodeTraversal::nextSkippingChildren(node.get());
+            next = NodeTraversal::nextSkippingChildren(*node);
         } else
-            next = NodeTraversal::next(node.get());
+            next = NodeTraversal::next(*node);
 
         if (is<HTMLElement>(*node) && nodeFullySelected(node.get(), start, end)) {
-            RefPtr<HTMLElement> elem = downcast<HTMLElement>(node.get());
-            RefPtr<Node> prev = NodeTraversal::previousPostOrder(elem.get());
-            RefPtr<Node> next = NodeTraversal::next(elem.get());
+            Ref<HTMLElement> elem = downcast<HTMLElement>(*node);
+            RefPtr<Node> prev = NodeTraversal::previousPostOrder(elem);
+            RefPtr<Node> next = NodeTraversal::next(elem);
             RefPtr<EditingStyle> styleToPushDown;
             RefPtr<Node> childNode;
-            if (isStyledInlineElementToRemove(elem.get())) {
+            if (isStyledInlineElementToRemove(elem.ptr())) {
                 styleToPushDown = EditingStyle::create();
                 childNode = elem->firstChild();
             }
 
-            removeInlineStyleFromElement(style, elem.get(), RemoveIfNeeded, styleToPushDown.get());
+            removeInlineStyleFromElement(style, elem.ptr(), RemoveIfNeeded, styleToPushDown.get());
             if (!elem->inDocument()) {
-                if (s.deprecatedNode() == elem) {
+                if (s.deprecatedNode() == elem.ptr()) {
                     // Since elem must have been fully selected, and it is at the start
                     // of the selection, it is clear we can set the new s offset to 0.
                     ASSERT(s.anchorType() == Position::PositionIsBeforeAnchor || s.offsetInContainerNode() <= 0);
                     s = firstPositionInOrBeforeNode(next.get());
                 }
-                if (e.deprecatedNode() == elem) {
+                if (e.deprecatedNode() == elem.ptr()) {
                     // Since elem must have been fully selected, and it is at the end
                     // of the selection, it is clear we can set the new e offset to
                     // the max range offset of prev.
@@ -1525,7 +1523,7 @@ void ApplyStyleCommand::joinChildTextNodes(Node* node, const Position& start, co
     Position newEnd = end;
 
     Vector<RefPtr<Text>> textNodes;
-    for (Text* textNode = TextNodeTraversal::firstChild(node); textNode; textNode = TextNodeTraversal::nextSibling(textNode))
+    for (Text* textNode = TextNodeTraversal::firstChild(*node); textNode; textNode = TextNodeTraversal::nextSibling(*textNode))
         textNodes.append(textNode);
 
     for (size_t i = 0; i < textNodes.size(); ++i) {
index f6fb4aa..515f1a0 100644 (file)
@@ -109,13 +109,13 @@ void BreakBlockquoteCommand::doApply()
     if (is<Text>(*startNode)) {
         Text& textNode = downcast<Text>(*startNode);
         if ((unsigned)pos.deprecatedEditingOffset() >= textNode.length()) {
-            startNode = NodeTraversal::next(startNode);
+            startNode = NodeTraversal::next(*startNode);
             ASSERT(startNode);
         } else if (pos.deprecatedEditingOffset() > 0)
             splitTextNode(&textNode, pos.deprecatedEditingOffset());
     } else if (pos.deprecatedEditingOffset() > 0) {
         Node* childAtOffset = startNode->traverseToChildAt(pos.deprecatedEditingOffset());
-        startNode = childAtOffset ? childAtOffset : NodeTraversal::next(startNode);
+        startNode = childAtOffset ? childAtOffset : NodeTraversal::next(*startNode);
         ASSERT(startNode);
     }
     
index 6e033b9..9dc1308 100644 (file)
@@ -859,7 +859,7 @@ void CompositeEditCommand::deleteInsignificantText(const Position& start, const
         return;
 
     Vector<RefPtr<Text>> nodes;
-    for (Node* node = start.deprecatedNode(); node; node = NodeTraversal::next(node)) {
+    for (Node* node = start.deprecatedNode(); node; node = NodeTraversal::next(*node)) {
         if (is<Text>(*node))
             nodes.append(downcast<Text>(node));
         if (node == end.deprecatedNode())
@@ -1071,7 +1071,7 @@ void CompositeEditCommand::cloneParagraphUnderNewElement(const Position& start,
         }
 
         RefPtr<Node> startNode = start.deprecatedNode();
-        for (RefPtr<Node> node = NodeTraversal::nextSkippingChildren(startNode.get(), outerNode.get()); node; node = NodeTraversal::nextSkippingChildren(node.get(), outerNode.get())) {
+        for (RefPtr<Node> node = NodeTraversal::nextSkippingChildren(*startNode, outerNode.get()); node; node = NodeTraversal::nextSkippingChildren(*node, outerNode.get())) {
             // Move lastNode up in the tree as much as node was moved up in the
             // tree by NodeTraversal::nextSkippingChildren, so that the relative depth between
             // node and the original start node is maintained in the clone.
@@ -1350,8 +1350,8 @@ bool CompositeEditCommand::breakOutOfEmptyListItem()
     if (!newBlock)
         newBlock = createDefaultParagraphElement(document());
 
-    RefPtr<Node> previousListNode = emptyListItem->isElementNode() ? ElementTraversal::previousSibling(emptyListItem.get()): emptyListItem->previousSibling();
-    RefPtr<Node> nextListNode = emptyListItem->isElementNode() ? ElementTraversal::nextSibling(emptyListItem.get()): emptyListItem->nextSibling();
+    RefPtr<Node> previousListNode = emptyListItem->isElementNode() ? ElementTraversal::previousSibling(*emptyListItem): emptyListItem->previousSibling();
+    RefPtr<Node> nextListNode = emptyListItem->isElementNode() ? ElementTraversal::nextSibling(*emptyListItem): emptyListItem->nextSibling();
     if (isListItem(nextListNode.get()) || isListElement(nextListNode.get())) {
         // If emptyListItem follows another list item or nested list, split the list node.
         if (isListItem(previousListNode.get()) || isListElement(previousListNode.get()))
index 5bbc312..2bbc6ed 100644 (file)
@@ -344,7 +344,7 @@ static Position firstEditablePositionInNode(Node* node)
     ASSERT(node);
     Node* next = node;
     while (next && !next->hasEditableStyle())
-        next = NodeTraversal::next(next, node);
+        next = NodeTraversal::next(*next, node);
     return next ? firstPositionInOrBeforeNode(next) : Position();
 }
 
@@ -436,9 +436,9 @@ void DeleteSelectionCommand::makeStylingElementsDirectChildrenOfEditableRootToPr
     RefPtr<Range> range = m_selectionToDelete.toNormalizedRange();
     RefPtr<Node> node = range->firstNode();
     while (node && node != range->pastLastNode()) {
-        RefPtr<Node> nextNode = NodeTraversal::next(node.get());
+        RefPtr<Node> nextNode = NodeTraversal::next(*node);
         if ((is<HTMLStyleElement>(*node) && !downcast<HTMLStyleElement>(*node).hasAttribute(scopedAttr)) || is<HTMLLinkElement>(*node)) {
-            nextNode = NodeTraversal::nextSkippingChildren(node.get());
+            nextNode = NodeTraversal::nextSkippingChildren(*node);
             RefPtr<ContainerNode> rootEditableElement = node->rootEditableElement();
             if (rootEditableElement) {
                 removeNode(node);
@@ -462,7 +462,7 @@ void DeleteSelectionCommand::handleGeneralDelete()
     // Never remove the start block unless it's a table, in which case we won't merge content in.
     if (startNode == m_startBlock && !startOffset && canHaveChildrenForEditing(startNode) && !is<HTMLTableElement>(*startNode)) {
         startOffset = 0;
-        startNode = NodeTraversal::next(startNode);
+        startNode = NodeTraversal::next(*startNode);
         if (!startNode)
             return;
     }
@@ -474,7 +474,7 @@ void DeleteSelectionCommand::handleGeneralDelete()
     }
 
     if (startOffset >= lastOffsetForEditing(startNode)) {
-        startNode = NodeTraversal::nextSkippingChildren(startNode);
+        startNode = NodeTraversal::nextSkippingChildren(*startNode);
         startOffset = 0;
     }
 
@@ -508,7 +508,7 @@ void DeleteSelectionCommand::handleGeneralDelete()
                 // in a text node that needs to be trimmed
                 Text& text = downcast<Text>(*node);
                 deleteTextFromNode(&text, startOffset, text.length() - startOffset);
-                node = NodeTraversal::next(node.get());
+                node = NodeTraversal::next(*node);
             } else {
                 node = startNode->traverseToChildAt(startOffset);
             }
@@ -521,9 +521,9 @@ void DeleteSelectionCommand::handleGeneralDelete()
         while (node && node != m_downstreamEnd.deprecatedNode()) {
             if (comparePositions(firstPositionInOrBeforeNode(node.get()), m_downstreamEnd) >= 0) {
                 // NodeTraversal::nextSkippingChildren just blew past the end position, so stop deleting
-                node = 0;
+                node = nullptr;
             } else if (!m_downstreamEnd.deprecatedNode()->isDescendantOf(node.get())) {
-                RefPtr<Node> nextNode = NodeTraversal::nextSkippingChildren(node.get());
+                RefPtr<Node> nextNode = NodeTraversal::nextSkippingChildren(*node);
                 // if we just removed a node from the end container, update end position so the
                 // check above will work
                 updatePositionForNodeRemoval(m_downstreamEnd, *node);
@@ -533,9 +533,9 @@ void DeleteSelectionCommand::handleGeneralDelete()
                 Node* n = node->lastDescendant();
                 if (m_downstreamEnd.deprecatedNode() == n && m_downstreamEnd.deprecatedEditingOffset() >= caretMaxOffset(n)) {
                     removeNode(node.get());
-                    node = 0;
+                    node = nullptr;
                 } else
-                    node = NodeTraversal::next(node.get());
+                    node = NodeTraversal::next(*node);
             }
         }
         
index 5f72426..8f56532 100644 (file)
@@ -120,7 +120,7 @@ void SimpleEditCommand::doReapply()
 #ifndef NDEBUG
 void SimpleEditCommand::addNodeAndDescendants(Node* startNode, HashSet<Node*>& nodes)
 {
-    for (Node* node = startNode; node; node = NodeTraversal::next(node, startNode))
+    for (Node* node = startNode; node; node = NodeTraversal::next(*node, startNode))
         nodes.add(node);
 }
 #endif
index ef1c44f..8a7120b 100644 (file)
@@ -674,7 +674,7 @@ TriState EditingStyle::triStateOfStyle(const VisibleSelection& selection) const
 
     TriState state = FalseTriState;
     bool nodeIsStart = true;
-    for (Node* node = selection.start().deprecatedNode(); node; node = NodeTraversal::next(node)) {
+    for (Node* node = selection.start().deprecatedNode(); node; node = NodeTraversal::next(*node)) {
         if (node->renderer() && node->hasEditableStyle()) {
             ComputedStyleExtractor computedStyle(node);
             TriState nodeState = triStateOfStyle(computedStyle, node->isTextNode() ? EditingStyle::DoNotIgnoreTextOnlyProperties : EditingStyle::IgnoreTextOnlyProperties);
@@ -1306,7 +1306,7 @@ WritingDirection EditingStyle::textDirectionForSelection(const VisibleSelection&
         end = selection.end().upstream();
 
         Node* pastLast = Range::create(*end.document(), position.parentAnchoredEquivalent(), end.parentAnchoredEquivalent())->pastLastNode();
-        for (Node* n = node; n && n != pastLast; n = NodeTraversal::next(n)) {
+        for (Node* n = node; n && n != pastLast; n = NodeTraversal::next(*n)) {
             if (!n->isStyledElement())
                 continue;
 
index faf770d..4a55ff9 100644 (file)
@@ -1324,12 +1324,12 @@ void Editor::simplifyMarkup(Node* startNode, Node* endNode)
         // check if start node is before endNode
         Node* node = startNode;
         while (node && node != endNode)
-            node = NodeTraversal::next(node);
+            node = NodeTraversal::next(*node);
         if (!node)
             return;
     }
     
-    applyCommand(SimplifyMarkupCommand::create(document(), startNode, (endNode) ? NodeTraversal::next(endNode) : 0));
+    applyCommand(SimplifyMarkupCommand::create(document(), startNode, endNode ? NodeTraversal::next(*endNode) : nullptr));
 }
 
 void Editor::copyURL(const URL& url, const String& title)
index a7c7c71..b238f87 100644 (file)
@@ -70,8 +70,8 @@ bool IndentOutdentCommand::tryIndentingAsListItem(const Position& start, const P
         return false;
     
     // FIXME: previousElementSibling does not ignore non-rendered content like <span></span>.  Should we?
-    RefPtr<Element> previousList = ElementTraversal::previousSibling(selectedListItem.get());
-    RefPtr<Element> nextList = ElementTraversal::nextSibling(selectedListItem.get());
+    RefPtr<Element> previousList = ElementTraversal::previousSibling(*selectedListItem);
+    RefPtr<Element> nextList = ElementTraversal::nextSibling(*selectedListItem);
 
     RefPtr<Element> newList = document().createElement(listNode->tagQName(), false);
     insertNodeBefore(newList, selectedListItem);
index 61626c0..6cd1c5c 100644 (file)
@@ -73,7 +73,7 @@ RefPtr<HTMLElement> InsertListCommand::mergeWithNeighboringLists(PassRefPtr<HTML
 
     if (!list)
         return nullptr;
-    Element* sibling = ElementTraversal::nextSibling(list.get());
+    Element* sibling = ElementTraversal::nextSibling(*list);
     if (!is<HTMLElement>(sibling))
         return list;
 
index 82ec534..212829c 100644 (file)
@@ -378,7 +378,7 @@ void InsertParagraphSeparatorCommand::doApply()
         else {
             Node* splitTo = insertionPosition.containerNode();
             if (splitTo->isTextNode() && insertionPosition.offsetInContainerNode() >= caretMaxOffset(splitTo))
-                splitTo = NodeTraversal::next(splitTo, startBlock.get());
+                splitTo = NodeTraversal::next(*splitTo, startBlock.get());
             ASSERT(splitTo);
             splitTreeToNode(splitTo, startBlock.get());
 
index 95a4c46..fb3880c 100644 (file)
@@ -279,9 +279,10 @@ void ReplacementFragment::removeUnrenderedNodes(Node* holder)
 {
     Vector<RefPtr<Node>> unrendered;
 
-    for (Node* node = holder->firstChild(); node; node = NodeTraversal::next(node, holder))
+    for (Node* node = holder->firstChild(); node; node = NodeTraversal::next(*node, holder)) {
         if (!isNodeRendered(node) && !isTableStructureNode(node))
             unrendered.append(node);
+    }
 
     size_t n = unrendered.size();
     for (size_t i = 0; i < n; ++i)
@@ -320,9 +321,9 @@ void ReplacementFragment::removeInterchangeNodes(Node* container)
     
     node = container->firstChild();
     while (node) {
-        RefPtr<Node> next = NodeTraversal::next(node);
+        RefPtr<Node> next = NodeTraversal::next(*node);
         if (isInterchangeConvertedSpaceSpan(node)) {
-            next = NodeTraversal::nextSkippingChildren(node);
+            next = NodeTraversal::nextSkippingChildren(*node);
             removeNodePreservingChildren(node);
         }
         node = next.get();
@@ -343,9 +344,9 @@ inline void ReplaceSelectionCommand::InsertedNodes::respondToNodeInsertion(Node*
 inline void ReplaceSelectionCommand::InsertedNodes::willRemoveNodePreservingChildren(Node* node)
 {
     if (m_firstNodeInserted == node)
-        m_firstNodeInserted = NodeTraversal::next(node);
+        m_firstNodeInserted = NodeTraversal::next(*node);
     if (m_lastNodeInserted == node)
-        m_lastNodeInserted = node->lastChild() ? node->lastChild() : NodeTraversal::nextSkippingChildren(node);
+        m_lastNodeInserted = node->lastChild() ? node->lastChild() : NodeTraversal::nextSkippingChildren(*node);
 }
 
 inline void ReplaceSelectionCommand::InsertedNodes::willRemoveNode(Node* node)
@@ -354,9 +355,9 @@ inline void ReplaceSelectionCommand::InsertedNodes::willRemoveNode(Node* node)
         m_firstNodeInserted = 0;
         m_lastNodeInserted = 0;
     } else if (m_firstNodeInserted == node)
-        m_firstNodeInserted = NodeTraversal::nextSkippingChildren(m_firstNodeInserted.get());
+        m_firstNodeInserted = NodeTraversal::nextSkippingChildren(*m_firstNodeInserted);
     else if (m_lastNodeInserted == node)
-        m_lastNodeInserted = NodeTraversal::previousSkippingChildren(m_lastNodeInserted.get());
+        m_lastNodeInserted = NodeTraversal::previousSkippingChildren(*m_lastNodeInserted);
 }
 
 inline void ReplaceSelectionCommand::InsertedNodes::didReplaceNode(Node* node, Node* newNode)
@@ -479,7 +480,7 @@ void ReplaceSelectionCommand::removeRedundantStylesAndKeepStyleSpanInline(Insert
     for (RefPtr<Node> node = insertedNodes.firstNodeInserted(); node && node != pastEndNode; node = next) {
         // FIXME: <rdar://problem/5371536> Style rules that match pasted content can change it's appearance
 
-        next = NodeTraversal::next(node.get());
+        next = NodeTraversal::next(*node);
         if (!is<StyledElement>(*node))
             continue;
 
@@ -624,7 +625,7 @@ void ReplaceSelectionCommand::makeInsertedContentRoundTrippableWithHTMLTreeBuild
     RefPtr<Node> pastEndNode = insertedNodes.pastLastLeaf();
     RefPtr<Node> next;
     for (RefPtr<Node> node = insertedNodes.firstNodeInserted(); node && node != pastEndNode; node = next) {
-        next = NodeTraversal::next(node.get());
+        next = NodeTraversal::next(*node);
 
         if (!is<HTMLElement>(*node))
             continue;
@@ -776,7 +777,7 @@ void ReplaceSelectionCommand::handleStyleSpans(InsertedNodes& insertedNodes)
     // The style span that contains the source document's default style should be at
     // the top of the fragment, but Mail sometimes adds a wrapper (for Paste As Quotation),
     // so search for the top level style span instead of assuming it's at the top.
-    for (Node* node = insertedNodes.firstNodeInserted(); node; node = NodeTraversal::next(node)) {
+    for (Node* node = insertedNodes.firstNodeInserted(); node; node = NodeTraversal::next(*node)) {
         if (isLegacyAppleStyleSpan(node)) {
             wrappingStyleSpan = downcast<HTMLElement>(node);
             break;
index 5636d4b..d87c3ff 100644 (file)
@@ -68,7 +68,14 @@ private:
 
         Node* firstNodeInserted() const { return m_firstNodeInserted.get(); }
         Node* lastLeafInserted() const { return m_lastNodeInserted->lastDescendant(); }
-        Node* pastLastLeaf() const { return m_lastNodeInserted ? NodeTraversal::next(lastLeafInserted()) : 0; }
+        Node* pastLastLeaf() const
+        {
+            if (m_lastNodeInserted) {
+                ASSERT(lastLeafInserted());
+                return NodeTraversal::next(*lastLeafInserted());
+            }
+            return nullptr;
+        }
 
     private:
         RefPtr<Node> m_firstNodeInserted;
index 5ab9c1a..9ea5cea 100644 (file)
@@ -52,7 +52,7 @@ void SimplifyMarkupCommand::doApply()
     // without affecting the style. The goal is to produce leaner markup even when starting
     // from a verbose fragment.
     // We look at inline elements as well as non top level divs that don't have attributes. 
-    for (Node* node = m_firstNode.get(); node && node != m_nodeAfterLast; node = NodeTraversal::next(node)) {
+    for (Node* node = m_firstNode.get(); node && node != m_nodeAfterLast; node = NodeTraversal::next(*node)) {
         if (node->firstChild() || (node->isTextNode() && node->nextSibling()))
             continue;
         
index c9ee26f..3465c71 100644 (file)
@@ -449,7 +449,7 @@ void TextIterator::advance()
         if (!next) {
             next = m_node->nextSibling();
             if (!next) {
-                bool pastEnd = NodeTraversal::next(m_node) == m_pastEndNode;
+                bool pastEnd = NodeTraversal::next(*m_node) == m_pastEndNode;
                 Node* parentNode = m_node->parentOrShadowHostNode();
                 while (!next && parentNode) {
                     if ((pastEnd && parentNode == m_endContainer) || m_endContainer->isDescendantOf(parentNode))
@@ -861,7 +861,7 @@ static bool shouldEmitNewlineAfterNode(Node& node)
     // Check if this is the very last renderer in the document.
     // If so, then we should not emit a newline.
     Node* subsequentNode = &node;
-    while ((subsequentNode = NodeTraversal::nextSkippingChildren(subsequentNode))) {
+    while ((subsequentNode = NodeTraversal::nextSkippingChildren(*subsequentNode))) {
         if (subsequentNode->renderer())
             return true;
     }
index e5984d9..375c329 100644 (file)
@@ -1124,18 +1124,18 @@ VisiblePosition startOfParagraph(const VisiblePosition& c, EditingBoundaryCrossi
             break;
         if (boundaryCrossingRule == CanSkipOverEditingBoundary) {
             while (n && n->hasEditableStyle() != startNode->hasEditableStyle())
-                n = NodeTraversal::previousPostOrder(n, startBlock);
+                n = NodeTraversal::previousPostOrder(*n, startBlock);
             if (!n || !n->isDescendantOf(highestRoot))
                 break;
         }
         RenderObject* r = n->renderer();
         if (!r) {
-            n = NodeTraversal::previousPostOrder(n, startBlock);
+            n = NodeTraversal::previousPostOrder(*n, startBlock);
             continue;
         }
         const RenderStyle& style = r->style();
         if (style.visibility() != VISIBLE) {
-            n = NodeTraversal::previousPostOrder(n, startBlock);
+            n = NodeTraversal::previousPostOrder(*n, startBlock);
             continue;
         }
         
@@ -1158,13 +1158,13 @@ VisiblePosition startOfParagraph(const VisiblePosition& c, EditingBoundaryCrossi
             }
             node = n;
             offset = 0;
-            n = NodeTraversal::previousPostOrder(n, startBlock);
+            n = NodeTraversal::previousPostOrder(*n, startBlock);
         } else if (editingIgnoresContent(n) || isRenderedTable(n)) {
             node = n;
             type = Position::PositionIsBeforeAnchor;
-            n = n->previousSibling() ? n->previousSibling() : NodeTraversal::previousPostOrder(n, startBlock);
+            n = n->previousSibling() ? n->previousSibling() : NodeTraversal::previousPostOrder(*n, startBlock);
         } else
-            n = NodeTraversal::previousPostOrder(n, startBlock);
+            n = NodeTraversal::previousPostOrder(*n, startBlock);
     }
 
     if (type == Position::PositionIsOffsetInAnchor) {
@@ -1204,19 +1204,19 @@ VisiblePosition endOfParagraph(const VisiblePosition& c, EditingBoundaryCrossing
             break;
         if (boundaryCrossingRule == CanSkipOverEditingBoundary) {
             while (n && n->hasEditableStyle() != startNode->hasEditableStyle())
-                n = NodeTraversal::next(n, stayInsideBlock);
+                n = NodeTraversal::next(*n, stayInsideBlock);
             if (!n || !n->isDescendantOf(highestRoot))
                 break;
         }
 
         RenderObject* r = n->renderer();
         if (!r) {
-            n = NodeTraversal::next(n, stayInsideBlock);
+            n = NodeTraversal::next(*n, stayInsideBlock);
             continue;
         }
         const RenderStyle& style = r->style();
         if (style.visibility() != VISIBLE) {
-            n = NodeTraversal::next(n, stayInsideBlock);
+            n = NodeTraversal::next(*n, stayInsideBlock);
             continue;
         }
         
@@ -1239,13 +1239,13 @@ VisiblePosition endOfParagraph(const VisiblePosition& c, EditingBoundaryCrossing
             }
             node = n;
             offset = r->caretMaxOffset();
-            n = NodeTraversal::next(n, stayInsideBlock);
+            n = NodeTraversal::next(*n, stayInsideBlock);
         } else if (editingIgnoresContent(n) || isRenderedTable(n)) {
             node = n;
             type = Position::PositionIsAfterAnchor;
-            n = NodeTraversal::nextSkippingChildren(n, stayInsideBlock);
+            n = NodeTraversal::nextSkippingChildren(*n, stayInsideBlock);
         } else
-            n = NodeTraversal::next(n, stayInsideBlock);
+            n = NodeTraversal::next(*n, stayInsideBlock);
     }
 
     if (type == Position::PositionIsOffsetInAnchor)
index 01fe906..ea444a3 100644 (file)
@@ -1805,7 +1805,7 @@ void HTMLConverter::_processHeadElement(Element& element)
 {
     // FIXME: Should gather data from other sources e.g. Word, but for that we would need to be able to get comments from DOM
     
-    for (HTMLMetaElement* child = Traversal<HTMLMetaElement>::firstChild(&element); child; child = Traversal<HTMLMetaElement>::nextSibling(child)) {
+    for (HTMLMetaElement* child = Traversal<HTMLMetaElement>::firstChild(element); child; child = Traversal<HTMLMetaElement>::nextSibling(*child)) {
         NSString *name = child->name();
         NSString *content = child->content();
         if (name && content)
index 67d42e6..87c9de9 100644 (file)
@@ -604,12 +604,12 @@ static bool hasARenderedDescendant(Node* node, Node* excludedNode)
 {
     for (Node* n = node->firstChild(); n;) {
         if (n == excludedNode) {
-            n = NodeTraversal::nextSkippingChildren(n, node);
+            n = NodeTraversal::nextSkippingChildren(*n, node);
             continue;
         }
         if (n->renderer())
             return true;
-        n = NodeTraversal::next(n, node);
+        n = NodeTraversal::next(*n, node);
     }
     return false;
 }
index f1ee299..b11706b 100644 (file)
@@ -230,7 +230,7 @@ const Font* Editor::fontForSelection(bool& hasMultipleFonts) const
         Node* pastEnd = range->pastLastNode();
         // In the loop below, n should eventually match pastEnd and not become nil, but we've seen at least one
         // unreproducible case where this didn't happen, so check for null also.
-        for (Node* node = startNode; node && node != pastEnd; node = NodeTraversal::next(node)) {
+        for (Node* node = startNode; node && node != pastEnd; node = NodeTraversal::next(*node)) {
             auto renderer = node->renderer();
             if (!renderer)
                 continue;
index d3ecf3a..3382744 100644 (file)
@@ -130,7 +130,7 @@ const Font* Editor::fontForSelection(bool& hasMultipleFonts) const
         Node* pastEnd = range->pastLastNode();
         // In the loop below, n should eventually match pastEnd and not become nil, but we've seen at least one
         // unreproducible case where this didn't happen, so check for null also.
-        for (Node* node = startNode; node && node != pastEnd; node = NodeTraversal::next(node)) {
+        for (Node* node = startNode; node && node != pastEnd; node = NodeTraversal::next(*node)) {
             auto renderer = node->renderer();
             if (!renderer)
                 continue;
index bbe2a62..7b439d0 100644 (file)
@@ -367,7 +367,7 @@ Node* StyledMarkupAccumulator::traverseNodesForSerialization(Node* startNode, No
     const bool shouldEmit = traversalMode == EmitString;
     Vector<Node*> ancestorsToClose;
     Node* next;
-    Node* lastClosed = 0;
+    Node* lastClosed = nullptr;
     for (Node* n = startNode; n != pastEnd; n = next) {
         // According to <rdar://problem/5730668>, it is possible for n to blow
         // past pastEnd and become null here. This shouldn't be possible.
@@ -377,7 +377,7 @@ Node* StyledMarkupAccumulator::traverseNodesForSerialization(Node* startNode, No
         if (!n)
             break;
         
-        next = NodeTraversal::next(n);
+        next = NodeTraversal::next(*n);
         bool openedTag = false;
 
         if (isBlock(n) && canHaveChildrenForEditing(n) && next == pastEnd)
@@ -385,7 +385,7 @@ Node* StyledMarkupAccumulator::traverseNodesForSerialization(Node* startNode, No
             continue;
 
         if (!n->renderer() && !enclosingElementWithTag(firstPositionInOrBeforeNode(n), selectTag)) {
-            next = NodeTraversal::nextSkippingChildren(n);
+            next = NodeTraversal::nextSkippingChildren(*n);
             // Don't skip over pastEnd.
             if (pastEnd && pastEnd->isDescendantOf(n))
                 next = pastEnd;
index 3f74d38..3b4b62f 100644 (file)
@@ -235,7 +235,7 @@ static inline bool isMatchingElement(const HTMLCollection& collection, Element&
 
 static inline Element* previousElement(ContainerNode& base, Element& element, bool onlyIncludeDirectChildren)
 {
-    return onlyIncludeDirectChildren ? ElementTraversal::previousSibling(&element) : ElementTraversal::previous(&element, &base);
+    return onlyIncludeDirectChildren ? ElementTraversal::previousSibling(element) : ElementTraversal::previous(element, &base);
 }
 
 ALWAYS_INLINE Element* HTMLCollection::iterateForPreviousElement(Element* element) const
@@ -251,9 +251,9 @@ ALWAYS_INLINE Element* HTMLCollection::iterateForPreviousElement(Element* elemen
 
 static inline Element* firstMatchingElement(const HTMLCollection& collection, ContainerNode& root)
 {
-    Element* element = ElementTraversal::firstWithin(&root);
+    Element* element = ElementTraversal::firstWithin(root);
     while (element && !isMatchingElement(collection, *element))
-        element = ElementTraversal::next(element, &root);
+        element = ElementTraversal::next(*element, &root);
     return element;
 }
 
@@ -261,7 +261,7 @@ static inline Element* nextMatchingElement(const HTMLCollection& collection, Ele
 {
     Element* next = &element;
     do {
-        next = ElementTraversal::next(next, &root);
+        next = ElementTraversal::next(*next, &root);
     } while (next && !isMatchingElement(collection, *next));
     return next;
 }
@@ -296,9 +296,9 @@ static inline bool nameShouldBeVisibleInDocumentAll(Element& element)
 
 static inline Element* firstMatchingChildElement(const HTMLCollection& nodeList, ContainerNode& root)
 {
-    Element* element = ElementTraversal::firstWithin(&root);
+    Element* element = ElementTraversal::firstWithin(root);
     while (element && !isMatchingElement(nodeList, *element))
-        element = ElementTraversal::nextSibling(element);
+        element = ElementTraversal::nextSibling(*element);
     return element;
 }
 
@@ -306,7 +306,7 @@ static inline Element* nextMatchingSiblingElement(const HTMLCollection& nodeList
 {
     Element* next = &element;
     do {
-        next = ElementTraversal::nextSibling(next);
+        next = ElementTraversal::nextSibling(*next);
     } while (next && !isMatchingElement(nodeList, *next));
     return next;
 }
@@ -359,7 +359,7 @@ Element* HTMLCollection::collectionLast() const
 {
     // FIXME: This should be optimized similarly to the forward case.
     auto& root = rootNode();
-    Element* last = m_shouldOnlyIncludeDirectChildren ? ElementTraversal::lastChild(&root) : ElementTraversal::lastWithin(&root);
+    Element* last = m_shouldOnlyIncludeDirectChildren ? ElementTraversal::lastChild(root) : ElementTraversal::lastWithin(root);
     return iterateForPreviousElement(last);
 }
 
@@ -373,12 +373,12 @@ void HTMLCollection::collectionTraverseBackward(Element*& current, unsigned coun
     // FIXME: This should be optimized similarly to the forward case.
     if (m_shouldOnlyIncludeDirectChildren) {
         for (; count && current; --count)
-            current = iterateForPreviousElement(ElementTraversal::previousSibling(current));
+            current = iterateForPreviousElement(ElementTraversal::previousSibling(*current));
         return;
     }
     auto& root = rootNode();
     for (; count && current; --count)
-        current = iterateForPreviousElement(ElementTraversal::previous(current, &root));
+        current = iterateForPreviousElement(ElementTraversal::previous(*current, &root));
 }
 
 void HTMLCollection::invalidateCache(Document& document) const
index 4d4820d..a1f72ed 100644 (file)
@@ -827,13 +827,13 @@ static void setHasDirAutoFlagRecursively(Node* firstNode, bool flag, Node* lastN
         if (elementAffectsDirectionality(*node)) {
             if (node == lastNode)
                 return;
-            node = NodeTraversal::nextSkippingChildren(node, firstNode);
+            node = NodeTraversal::nextSkippingChildren(*node, firstNode);
             continue;
         }
         node->setSelfOrAncestorHasDirAutoAttribute(flag);
         if (node == lastNode)
             return;
-        node = NodeTraversal::next(node, firstNode);
+        node = NodeTraversal::next(*node, firstNode);
     }
 }
 
@@ -876,7 +876,7 @@ TextDirection HTMLElement::directionality(Node** strongDirectionalityTextNode) c
         // Skip bdi, script, style and text form controls.
         if (equalIgnoringCase(node->nodeName(), "bdi") || node->hasTagName(scriptTag) || node->hasTagName(styleTag) 
             || (is<Element>(*node) && downcast<Element>(*node).isTextFormControl())) {
-            node = NodeTraversal::nextSkippingChildren(node, this);
+            node = NodeTraversal::nextSkippingChildren(*node, this);
             continue;
         }
 
@@ -884,7 +884,7 @@ TextDirection HTMLElement::directionality(Node** strongDirectionalityTextNode) c
         if (is<Element>(*node)) {
             AtomicString dirAttributeValue = downcast<Element>(*node).fastGetAttribute(dirAttr);
             if (isLTROrRTLIgnoringCase(dirAttributeValue) || equalIgnoringCase(dirAttributeValue, "auto")) {
-                node = NodeTraversal::nextSkippingChildren(node, this);
+                node = NodeTraversal::nextSkippingChildren(*node, this);
                 continue;
             }
         }
@@ -898,7 +898,7 @@ TextDirection HTMLElement::directionality(Node** strongDirectionalityTextNode) c
                 return (textDirection == U_LEFT_TO_RIGHT) ? LTR : RTL;
             }
         }
-        node = NodeTraversal::next(node, this);
+        node = NodeTraversal::next(*node, this);
     }
     if (strongDirectionalityTextNode)
         *strongDirectionalityTextNode = nullptr;
@@ -950,7 +950,7 @@ void HTMLElement::adjustDirectionalityIfNeededAfterChildrenChanged(Element* befo
 
     Node* oldMarkedNode = nullptr;
     if (beforeChange)
-        oldMarkedNode = changeType == ElementInserted ? ElementTraversal::nextSibling(beforeChange) : beforeChange->nextSibling();
+        oldMarkedNode = changeType == ElementInserted ? ElementTraversal::nextSibling(*beforeChange) : beforeChange->nextSibling();
 
     while (oldMarkedNode && elementAffectsDirectionality(*oldMarkedNode))
         oldMarkedNode = oldMarkedNode->nextSibling();
index ddf166a..9441720 100644 (file)
@@ -61,14 +61,14 @@ static void updateFromControlElementsAncestorDisabledStateUnder(HTMLElement& sta
     if (is<HTMLFormControlElement>(startNode))
         control = &downcast<HTMLFormControlElement>(startNode);
     else
-        control = Traversal<HTMLFormControlElement>::firstWithin(&startNode);
+        control = Traversal<HTMLFormControlElement>::firstWithin(startNode);
     while (control) {
         control->setAncestorDisabled(isDisabled);
         // Don't call setAncestorDisabled(false) on form contorls inside disabled fieldsets.
         if (is<HTMLFieldSetElement>(*control) && control->fastHasAttribute(disabledAttr))
-            control = Traversal<HTMLFormControlElement>::nextSkippingChildren(control, &startNode);
+            control = Traversal<HTMLFormControlElement>::nextSkippingChildren(*control, &startNode);
         else
-            control = Traversal<HTMLFormControlElement>::next(control, &startNode);
+            control = Traversal<HTMLFormControlElement>::next(*control, &startNode);
     }
 }
 
@@ -92,7 +92,7 @@ void HTMLFieldSetElement::disabledStateChanged()
 
     bool thisFieldsetIsDisabled = fastHasAttribute(disabledAttr);
     bool hasSeenFirstLegendElement = false;
-    for (HTMLElement* control = Traversal<HTMLElement>::firstChild(this); control; control = Traversal<HTMLElement>::nextSibling(control)) {
+    for (HTMLElement* control = Traversal<HTMLElement>::firstChild(*this); control; control = Traversal<HTMLElement>::nextSibling(*control)) {
         if (!hasSeenFirstLegendElement && is<HTMLLegendElement>(*control)) {
             hasSeenFirstLegendElement = true;
             updateFromControlElementsAncestorDisabledStateUnder(*control, false /* isDisabled */);
@@ -108,13 +108,13 @@ void HTMLFieldSetElement::childrenChanged(const ChildChange& change)
     if (!fastHasAttribute(disabledAttr))
         return;
 
-    HTMLLegendElement* legend = Traversal<HTMLLegendElement>::firstChild(this);
+    HTMLLegendElement* legend = Traversal<HTMLLegendElement>::firstChild(*this);
     if (!legend)
         return;
 
     // We only care about the first legend element (in which form contorls are not disabled by this element) changing here.
     updateFromControlElementsAncestorDisabledStateUnder(*legend, false /* isDisabled */);
-    while ((legend = Traversal<HTMLLegendElement>::nextSibling(legend)))
+    while ((legend = Traversal<HTMLLegendElement>::nextSibling(*legend)))
         updateFromControlElementsAncestorDisabledStateUnder(*legend, true);
 }
 
index fdb9286..69c059e 100644 (file)
@@ -342,9 +342,9 @@ String HTMLOptionElement::collectOptionInnerText() const
             text.append(node->nodeValue());
         // Text nodes inside script elements are not part of the option text.
         if (is<Element>(*node) && toScriptElementIfPossible(downcast<Element>(node)))
-            node = NodeTraversal::nextSkippingChildren(node, this);
+            node = NodeTraversal::nextSkippingChildren(*node, this);
         else
-            node = NodeTraversal::next(node, this);
+            node = NodeTraversal::next(*node, this);
     }
     return text.toString();
 }
index 4d0290a..d1ec967 100644 (file)
@@ -785,9 +785,9 @@ void HTMLSelectElement::recalcListItems(bool updateSelectedStates) const
 
     HTMLOptionElement* foundSelected = 0;
     HTMLOptionElement* firstOption = 0;
-    for (Element* currentElement = ElementTraversal::firstWithin(this); currentElement; ) {
+    for (Element* currentElement = ElementTraversal::firstWithin(*this); currentElement; ) {
         if (!is<HTMLElement>(*currentElement)) {
-            currentElement = ElementTraversal::nextSkippingChildren(currentElement, this);
+            currentElement = ElementTraversal::nextSkippingChildren(*currentElement, this);
             continue;
         }
         HTMLElement& current = downcast<HTMLElement>(*currentElement);
@@ -797,7 +797,7 @@ void HTMLSelectElement::recalcListItems(bool updateSelectedStates) const
         // (http://www.w3.org/TR/html401/interact/forms.html#h-17.6)
         if (is<HTMLOptGroupElement>(current)) {
             m_listItems.append(&current);
-            if (Element* nextElement = ElementTraversal::firstWithin(&current)) {
+            if (Element* nextElement = ElementTraversal::firstWithin(current)) {
                 currentElement = nextElement;
                 continue;
             }
@@ -830,7 +830,7 @@ void HTMLSelectElement::recalcListItems(bool updateSelectedStates) const
         // with the case where odd tags like a <div> have been added but we
         // handle this because such tags have already been removed from the
         // <select>'s subtree at this point.
-        currentElement = ElementTraversal::nextSkippingChildren(currentElement, this);
+        currentElement = ElementTraversal::nextSkippingChildren(*currentElement, this);
     }
 
     if (!foundSelected && m_size <= 1 && firstOption && !firstOption->selected())
index ad388a7..dc09073 100644 (file)
@@ -195,10 +195,10 @@ RefPtr<HTMLElement> HTMLTableElement::insertRow(int index, ExceptionCode& ec)
     RefPtr<HTMLTableRowElement> lastRow = 0;
     RefPtr<HTMLTableRowElement> row = 0;
     if (index == -1)
-        lastRow = HTMLTableRowsCollection::lastRow(this);
+        lastRow = HTMLTableRowsCollection::lastRow(*this);
     else {
         for (int i = 0; i <= index; ++i) {
-            row = HTMLTableRowsCollection::rowAfter(this, lastRow.get());
+            row = HTMLTableRowsCollection::rowAfter(*this, lastRow.get());
             if (!row) {
                 if (i != index) {
                     ec = INDEX_SIZE_ERR;
@@ -233,10 +233,10 @@ void HTMLTableElement::deleteRow(int index, ExceptionCode& ec)
 {
     HTMLTableRowElement* row = 0;
     if (index == -1)
-        row = HTMLTableRowsCollection::lastRow(this);
+        row = HTMLTableRowsCollection::lastRow(*this);
     else {
         for (int i = 0; i <= index; ++i) {
-            row = HTMLTableRowsCollection::rowAfter(this, row);
+            row = HTMLTableRowsCollection::rowAfter(*this, row);
             if (!row)
                 break;
         }
index fe0d651..bfa5f6d 100644 (file)
@@ -38,7 +38,7 @@ namespace WebCore {
 
 using namespace HTMLNames;
 
-static inline void assertRowIsInTable(HTMLTableElement* table, HTMLTableRowElement* row)
+static inline void assertRowIsInTable(HTMLTableElement& table, HTMLTableRowElement* row)
 {
 #if !ASSERT_DISABLED
     UNUSED_PARAM(table);
@@ -46,11 +46,11 @@ static inline void assertRowIsInTable(HTMLTableElement* table, HTMLTableRowEleme
 #else
     if (!row)
         return;
-    if (row->parentNode() == table)
+    if (row->parentNode() == &table)
         return;
     ASSERT(row->parentNode());
     ASSERT(row->parentNode()->hasTagName(theadTag) || row->parentNode()->hasTagName(tbodyTag) || row->parentNode()->hasTagName(tfootTag));
-    ASSERT(row->parentNode()->parentNode() == table);
+    ASSERT(row->parentNode()->parentNode() == &table);
 #endif
 }
 
@@ -61,14 +61,14 @@ static inline bool isInSection(HTMLTableRowElement& row, const HTMLQualifiedName
     return downcast<HTMLElement>(*row.parentNode()).hasTagName(sectionTag);
 }
 
-HTMLTableRowElement* HTMLTableRowsCollection::rowAfter(HTMLTableElement* table, HTMLTableRowElement* previous)
+HTMLTableRowElement* HTMLTableRowsCollection::rowAfter(HTMLTableElement& table, HTMLTableRowElement* previous)
 {
     // The HTMLCollection caching mechanism, along with the code in this class, will guarantee that the previous row
     // is an immediate child of either the table, or a table section that is itself an immediate child of the table.
     assertRowIsInTable(table, previous);
 
     // Start by looking for the next row in this section. Continue only if there is none.
-    if (previous && previous->parentNode() != table) {
+    if (previous && previous->parentNode() != &table) {
         auto childRows = childrenOfType<HTMLTableRowElement>(*previous->parentNode());
         auto row = childRows.beginAt(*previous);
         if (++row != childRows.end())
@@ -81,8 +81,8 @@ HTMLTableRowElement* HTMLTableRowsCollection::rowAfter(HTMLTableElement* table,
     if (!previous)
         child = ElementTraversal::firstChild(table);
     else if (isInSection(*previous, theadTag))
-        child = ElementTraversal::nextSibling(previous->parentNode());
-    for (; child; child = ElementTraversal::nextSibling(child)) {
+        child = ElementTraversal::nextSibling(*previous->parentNode());
+    for (; child; child = ElementTraversal::nextSibling(*child)) {
         if (child->hasTagName(theadTag)) {
             if (auto row = childrenOfType<HTMLTableRowElement>(*child).first())
                 return row;
@@ -92,11 +92,11 @@ HTMLTableRowElement* HTMLTableRowsCollection::rowAfter(HTMLTableElement* table,
     // If still looking at top level and bodies, find the next row in top level or the first in the next body section.
     if (!previous || isInSection(*previous, theadTag))
         child = ElementTraversal::firstChild(table);
-    else if (previous->parentNode() == table)
-        child = ElementTraversal::nextSibling(previous);
+    else if (previous->parentNode() == &table)
+        child = ElementTraversal::nextSibling(*previous);
     else if (isInSection(*previous, tbodyTag))
-        child = ElementTraversal::nextSibling(previous->parentNode());
-    for (; child; child = ElementTraversal::nextSibling(child)) {
+        child = ElementTraversal::nextSibling(*previous->parentNode());
+    for (; child; child = ElementTraversal::nextSibling(*child)) {
         if (is<HTMLTableRowElement>(*child))
             return downcast<HTMLTableRowElement>(child);
         if (child->hasTagName(tbodyTag)) {
@@ -109,8 +109,8 @@ HTMLTableRowElement* HTMLTableRowsCollection::rowAfter(HTMLTableElement* table,
     if (!previous || !isInSection(*previous, tfootTag))
         child = ElementTraversal::firstChild(table);
     else
-        child = ElementTraversal::nextSibling(previous->parentNode());
-    for (; child; child = ElementTraversal::nextSibling(child)) {
+        child = ElementTraversal::nextSibling(*previous->parentNode());
+    for (; child; child = ElementTraversal::nextSibling(*child)) {
         if (child->hasTagName(tfootTag)) {
             if (auto row = childrenOfType<HTMLTableRowElement>(*child).first())
                 return row;
@@ -120,16 +120,16 @@ HTMLTableRowElement* HTMLTableRowsCollection::rowAfter(HTMLTableElement* table,
     return nullptr;
 }
 
-HTMLTableRowElement* HTMLTableRowsCollection::lastRow(HTMLTableElement* table)
+HTMLTableRowElement* HTMLTableRowsCollection::lastRow(HTMLTableElement& table)
 {
-    for (auto* child = ElementTraversal::lastChild(table); child; child = ElementTraversal::previousSibling(child)) {
+    for (auto* child = ElementTraversal::lastChild(table); child; child = ElementTraversal::previousSibling(*child)) {
         if (child->hasTagName(tfootTag)) {
             if (auto* row = childrenOfType<HTMLTableRowElement>(*child).last())
                 return row;
         }
     }
 
-    for (auto* child = ElementTraversal::lastChild(table); child; child = ElementTraversal::previousSibling(child)) {
+    for (auto* child = ElementTraversal::lastChild(table); child; child = ElementTraversal::previousSibling(*child)) {
         if (is<HTMLTableRowElement>(*child))
             return downcast<HTMLTableRowElement>(child);
         if (child->hasTagName(tbodyTag)) {
@@ -138,7 +138,7 @@ HTMLTableRowElement* HTMLTableRowsCollection::lastRow(HTMLTableElement* table)
         }
     }
 
-    for (auto* child = ElementTraversal::lastChild(table); child; child = ElementTraversal::previousSibling(child)) {
+    for (auto* child = ElementTraversal::lastChild(table); child; child = ElementTraversal::previousSibling(*child)) {
         if (child->hasTagName(theadTag)) {
             if (auto* row = childrenOfType<HTMLTableRowElement>(*child).last())
                 return row;
@@ -161,7 +161,7 @@ Ref<HTMLTableRowsCollection> HTMLTableRowsCollection::create(HTMLTableElement& t
 
 Element* HTMLTableRowsCollection::customElementAfter(Element* previous) const
 {
-    return rowAfter(const_cast<HTMLTableElement*>(&tableElement()), downcast<HTMLTableRowElement>(previous));
+    return rowAfter(const_cast<HTMLTableElement&>(tableElement()), downcast<HTMLTableRowElement>(previous));
 }
 
 }
index f17a30b..9eb5fa6 100644 (file)
@@ -43,8 +43,8 @@ public:
     HTMLTableElement& tableElement() { return downcast<HTMLTableElement>(ownerNode()); }
     const HTMLTableElement& tableElement() const { return downcast<HTMLTableElement>(ownerNode()); }
 
-    static HTMLTableRowElement* rowAfter(HTMLTableElement*, HTMLTableRowElement*);
-    static HTMLTableRowElement* lastRow(HTMLTableElement*);
+    static HTMLTableRowElement* rowAfter(HTMLTableElement&, HTMLTableRowElement*);
+    static HTMLTableRowElement* lastRow(HTMLTableElement&);
 
 private:
     explicit HTMLTableRowsCollection(HTMLTableElement&);
index 224ead3..17d4a32 100644 (file)
@@ -399,7 +399,7 @@ void HTMLTextAreaElement::setValueCommon(const String& newValue)
 
 String HTMLTextAreaElement::defaultValue() const
 {
-    return TextNodeTraversal::contentsAsString(this);
+    return TextNodeTraversal::contentsAsString(*this);
 }
 
 void HTMLTextAreaElement::setDefaultValue(const String& defaultValue)
@@ -408,7 +408,7 @@ void HTMLTextAreaElement::setDefaultValue(const String& defaultValue)
 
     // To preserve comments, remove only the text nodes, then add a single text node.
     Vector<RefPtr<Text>> textNodes;
-    for (Text* textNode = TextNodeTraversal::firstChild(this); textNode; textNode = TextNodeTraversal::nextSibling(textNode))
+    for (Text* textNode = TextNodeTraversal::firstChild(*this); textNode; textNode = TextNodeTraversal::nextSibling(*textNode))
         textNodes.append(textNode);
 
     size_t size = textNodes.size();
index cf05023..5239482 100644 (file)
@@ -431,7 +431,7 @@ static inline void setContainerAndOffsetForRange(Node* node, int offset, Node*&
 PassRefPtr<Range> HTMLTextFormControlElement::selection() const
 {
     if (!renderer() || !isTextFormControl() || !hasCachedSelection())
-        return 0;
+        return nullptr;
 
     int start = m_cachedSelectionStart;
     int end = m_cachedSelectionEnd;
@@ -439,15 +439,15 @@ PassRefPtr<Range> HTMLTextFormControlElement::selection() const
     ASSERT(start <= end);
     TextControlInnerTextElement* innerText = innerTextElement();
     if (!innerText)
-        return 0;
+        return nullptr;
 
     if (!innerText->firstChild())
         return Range::create(document(), innerText, 0, innerText, 0);
 
     int offset = 0;
-    Node* startNode = 0;
-    Node* endNode = 0;
-    for (Node* node = innerText->firstChild(); node; node = NodeTraversal::next(node, innerText)) {
+    Node* startNode = nullptr;
+    Node* endNode = nullptr;
+    for (Node* node = innerText->firstChild(); node; node = NodeTraversal::next(*node, innerText)) {
         ASSERT(!node->firstChild());
         ASSERT(node->isTextNode() || node->hasTagName(brTag));
         int length = node->isTextNode() ? lastOffsetInNode(node) : 1;
@@ -464,7 +464,7 @@ PassRefPtr<Range> HTMLTextFormControlElement::selection() const
     }
 
     if (!startNode || !endNode)
-        return 0;
+        return nullptr;
 
     return Range::create(document(), startNode, start, endNode, end);
 }
@@ -532,7 +532,7 @@ static void stripTrailingNewline(StringBuilder& result)
 static String innerTextValueFrom(TextControlInnerTextElement& innerText)
 {
     StringBuilder result;
-    for (Node* node = innerText.firstChild(); node; node = NodeTraversal::next(node, &innerText)) {
+    for (Node* node = innerText.firstChild(); node; node = NodeTraversal::next(*node, &innerText)) {
         if (is<HTMLBRElement>(*node))
             result.append(newlineCharacter);
         else if (is<Text>(*node))
@@ -574,7 +574,7 @@ static Position positionForIndex(TextControlInnerTextElement* innerText, unsigne
 {
     unsigned remainingCharactersToMoveForward = index;
     Node* lastBrOrText = innerText;
-    for (Node* node = innerText; node; node = NodeTraversal::next(node, innerText)) {
+    for (Node* node = innerText; node; node = NodeTraversal::next(*node, innerText)) {
         if (node->hasTagName(brTag)) {
             if (!remainingCharactersToMoveForward)
                 return positionBeforeNode(node);
@@ -607,7 +607,7 @@ unsigned HTMLTextFormControlElement::indexForPosition(const Position& passedPosi
     ASSERT(startNode);
     ASSERT(innerText->contains(startNode));
 
-    for (Node* node = startNode; node; node = NodeTraversal::previous(node, innerText)) {
+    for (Node* node = startNode; node; node = NodeTraversal::previous(*node, innerText)) {
         if (is<Text>(*node)) {
             unsigned length = downcast<Text>(*node).length();
             if (node == passedPosition.containerNode())
@@ -685,7 +685,7 @@ String HTMLTextFormControlElement::valueWithHardLineBreaks() const
     getNextSoftBreak(line, breakNode, breakOffset);
 
     StringBuilder result;
-    for (Node* node = innerText->firstChild(); node; node = NodeTraversal::next(node, innerText)) {
+    for (Node* node = innerText->firstChild(); node; node = NodeTraversal::next(*node, innerText)) {
         if (is<HTMLBRElement>(*node))
             result.append(newlineCharacter);
         else if (is<Text>(*node)) {
index 66ce895..7d58d97 100644 (file)
@@ -78,7 +78,7 @@ void HTMLTitleElement::childrenChanged(const ChildChange& change)
 
 String HTMLTitleElement::text() const
 {
-    return TextNodeTraversal::contentsAsString(this);
+    return TextNodeTraversal::contentsAsString(*this);
 }
 
 StringWithDirection HTMLTitleElement::textWithDirection()
index eead134..8f276e7 100644 (file)
@@ -79,7 +79,7 @@ void RadioInputType::handleKeydownEvent(KeyboardEvent* event)
     // We can only stay within the form's children if the form hasn't been demoted to a leaf because
     // of malformed HTML.
     Node* node = &element();
-    while ((node = (forward ? NodeTraversal::next(node) : NodeTraversal::previous(node)))) {
+    while ((node = (forward ? NodeTraversal::next(*node) : NodeTraversal::previous(*node)))) {
         // Once we encounter a form element, we know we're through.
         if (is<HTMLFormElement>(*node))
             break;
index bfe3f4f..dffe4b2 100644 (file)
@@ -93,7 +93,7 @@ bool TextFieldInputType::isEmptyValue() const
     TextControlInnerTextElement* innerText = innerTextElement();
     ASSERT(innerText);
 
-    for (Text* text = TextNodeTraversal::firstWithin(innerText); text; text = TextNodeTraversal::next(text, innerText)) {
+    for (Text* text = TextNodeTraversal::firstWithin(*innerText); text; text = TextNodeTraversal::next(*text, innerText)) {
         if (text->length())
             return false;
     }
index a66015b..cc5349a 100644 (file)
@@ -614,7 +614,7 @@ void VTTCue::determineTextDirection()
     // pre-order, depth-first traversal, excluding WebVTT Ruby Text Objects and
     // their descendants.
     StringBuilder paragraphBuilder;
-    for (Node* node = m_webVTTNodeTree->firstChild(); node; node = NodeTraversal::next(node, m_webVTTNodeTree.get())) {
+    for (Node* node = m_webVTTNodeTree->firstChild(); node; node = NodeTraversal::next(*node, m_webVTTNodeTree.get())) {
         // FIXME: The code does not match the comment above. This does not actually exclude Ruby Text Object descendant.
         if (!node->isTextNode() || node->localName() == rtTag)
             continue;
@@ -755,7 +755,7 @@ void VTTCue::markFutureAndPastNodes(ContainerNode* root, const MediaTime& previo
     if (currentTimestamp > movieTime)
         isPastNode = false;
     
-    for (Node* child = root->firstChild(); child; child = NodeTraversal::next(child, root)) {
+    for (Node* child = root->firstChild(); child; child = NodeTraversal::next(*child, root)) {
         if (child->nodeName() == timestampTag) {
             MediaTime currentTimestamp;
             bool check = WebVTTParser::collectTimeStamp(child->nodeValue(), currentTimestamp);
index 0e6028a..600a9bb 100644 (file)
@@ -75,7 +75,7 @@ void InspectorNodeFinder::performSearch(Node* parentNode)
 void InspectorNodeFinder::searchUsingDOMTreeTraversal(Node* parentNode)
 {
     // Manual plain text search.
-    for (auto* node = parentNode; node; node = NodeTraversal::next(node, parentNode)) {
+    for (auto* node = parentNode; node; node = NodeTraversal::next(*node, parentNode)) {
         switch (node->nodeType()) {
         case Node::TEXT_NODE:
         case Node::COMMENT_NODE:
index 3653824..77c07fe 100644 (file)
@@ -756,9 +756,8 @@ static void updateFocusCandidateIfNeeded(FocusDirection direction, const FocusCa
         closest = candidate;
 }
 
-void FocusController::findFocusCandidateInContainer(Node* container, const LayoutRect& startingRect, FocusDirection direction, KeyboardEvent* event, FocusCandidate& closest)
+void FocusController::findFocusCandidateInContainer(Node& container, const LayoutRect& startingRect, FocusDirection direction, KeyboardEvent* event, FocusCandidate& closest)
 {
-    ASSERT(container);
     Node* focusedNode = (focusedFrame() && focusedFrame()->document()) ? focusedFrame()->document()->focusedElement() : 0;
 
     Element* element = ElementTraversal::firstWithin(container);
@@ -769,8 +768,8 @@ void FocusController::findFocusCandidateInContainer(Node* container, const Layou
 
     unsigned candidateCount = 0;
     for (; element; element = (element->isFrameOwnerElement() || canScrollInDirection(element, direction))
-        ? ElementTraversal::nextSkippingChildren(element, container)
-        : ElementTraversal::next(element, container)) {
+        ? ElementTraversal::nextSkippingChildren(*element, &container)
+        : ElementTraversal::next(*element, &container)) {
         if (element == focusedNode)
             continue;
 
@@ -785,7 +784,7 @@ void FocusController::findFocusCandidateInContainer(Node* container, const Layou
             continue;
 
         candidateCount++;
-        candidate.enclosingScrollableBox = container;
+        candidate.enclosingScrollableBox = &container;
         updateFocusCandidateIfNeeded(direction, current, candidate, closest);
     }
 
@@ -809,7 +808,7 @@ bool FocusController::advanceFocusDirectionallyInContainer(Node* container, cons
 
     // Find the closest node within current container in the direction of the navigation.
     FocusCandidate focusCandidate;
-    findFocusCandidateInContainer(container, newStartingRect, direction, event, focusCandidate);
+    findFocusCandidateInContainer(*container, newStartingRect, direction, event, focusCandidate);
 
     if (focusCandidate.isNull()) {
         // Nothing to focus, scroll if possible.
index 2fb1fa5..f80dff4 100644 (file)
@@ -118,7 +118,7 @@ private:
     Element* findElementWithExactTabIndex(Node* start, int tabIndex, KeyboardEvent*, FocusDirection);
 
     bool advanceFocusDirectionallyInContainer(Node* container, const LayoutRect& startingRect, FocusDirection, KeyboardEvent*);
-    void findFocusCandidateInContainer(Node* container, const LayoutRect& startingRect, FocusDirection, KeyboardEvent*, FocusCandidate& closest);
+    void findFocusCandidateInContainer(Node& container, const LayoutRect& startingRect, FocusDirection, KeyboardEvent*, FocusCandidate& closest);
 
     void focusRepaintTimerFired();
 
index 57d7ea5..8edafbf 100644 (file)
@@ -348,7 +348,7 @@ String Frame::searchForLabelsAboveCell(const JSC::Yarr::RegularExpression& regEx
     if (aboveCell) {
         // search within the above cell we found for a match
         size_t lengthSearched = 0;    
-        for (Text* textNode = TextNodeTraversal::firstWithin(aboveCell); textNode; textNode = TextNodeTraversal::next(textNode, aboveCell)) {
+        for (Text* textNode = TextNodeTraversal::firstWithin(*aboveCell); textNode; textNode = TextNodeTraversal::next(*textNode, aboveCell)) {
             if (!textNode->renderer() || textNode->renderer()->style().visibility() != VISIBLE)
                 continue;
             // For each text chunk, run the regexp
@@ -369,8 +369,10 @@ String Frame::searchForLabelsAboveCell(const JSC::Yarr::RegularExpression& regEx
     return String();
 }
 
+// FIXME: This should take an Element&.
 String Frame::searchForLabelsBeforeElement(const Vector<String>& labels, Element* element, size_t* resultDistance, bool* resultIsInCellAbove)
 {
+    ASSERT(element);
     JSC::Yarr::RegularExpression regExp = createRegExpForLabels(labels);
     // We stop searching after we've seen this many chars
     const unsigned int charsSearchedThreshold = 500;
@@ -389,7 +391,7 @@ String Frame::searchForLabelsBeforeElement(const Vector<String>& labels, Element
     // walk backwards in the node tree, until another element, or form, or end of tree
     int unsigned lengthSearched = 0;
     Node* n;
-    for (n = NodeTraversal::previous(element); n && lengthSearched < charsSearchedThreshold; n = NodeTraversal::previous(n)) {
+    for (n = NodeTraversal::previous(*element); n && lengthSearched < charsSearchedThreshold; n = NodeTraversal::previous(*n)) {
         // We hit another form element or the start of the form - bail out
         if (is<HTMLFormElement>(*n) || is<HTMLFormControlElement>(*n))
             break;
index fcef7ea..90a3f6a 100644 (file)
@@ -768,7 +768,7 @@ NSArray *Frame::interpretationsForCurrentRoot() const
     unsigned combinationsSoFar = 1;
 
     Node* pastLastNode = rangeOfRootContents->pastLastNode();
-    for (Node* node = rangeOfRootContents->firstNode(); node != pastLastNode; node = NodeTraversal::next(node)) {
+    for (Node* node = rangeOfRootContents->firstNode(); node != pastLastNode; node = NodeTraversal::next(*node)) {
         for (auto* marker : document()->markers().markersFor(node, DocumentMarker::MarkerTypes(DocumentMarker::DictationPhraseWithAlternatives))) {
             // First, add text that precede the marker.
             if (precedingTextStartPosition != createLegacyEditingPosition(node, marker->startOffset())) {
index b46cda9..fb1cfa5 100644 (file)
@@ -58,9 +58,10 @@ static CounterMaps& counterMaps()
 // including pseudo elements as defined in CSS 2.1.
 static RenderElement* previousInPreOrder(const RenderElement& renderer)
 {
-    Element* previous = ElementTraversal::previousIncludingPseudo(renderer.element());
+    ASSERT(renderer.element());
+    Element* previous = ElementTraversal::previousIncludingPseudo(*renderer.element());
     while (previous && !previous->renderer())
-        previous = ElementTraversal::previousIncludingPseudo(previous);
+        previous = ElementTraversal::previousIncludingPseudo(*previous);
     return previous ? previous->renderer() : 0;
 }
 
@@ -75,9 +76,10 @@ static inline Element* parentOrPseudoHostElement(const RenderElement& renderer)
 // including pseudo elements as defined in CSS 2.1.
 static RenderElement* previousSiblingOrParent(const RenderElement& renderer)
 {
-    Element* previous = ElementTraversal::pseudoAwarePreviousSibling(renderer.element());
+    ASSERT(renderer.element());
+    Element* previous = ElementTraversal::pseudoAwarePreviousSibling(*renderer.element());
     while (previous && !previous->renderer())
-        previous = ElementTraversal::pseudoAwarePreviousSibling(previous);
+        previous = ElementTraversal::pseudoAwarePreviousSibling(*previous);
     if (previous)
         return previous->renderer();
     previous = parentOrPseudoHostElement(renderer);
@@ -93,11 +95,12 @@ static inline bool areRenderersElementsSiblings(const RenderElement& first, cons
 // including pseudo elements as defined in CSS 2.1.
 static RenderElement* nextInPreOrder(const RenderElement& renderer, const Element* stayWithin, bool skipDescendants = false)
 {
-    Element* self = renderer.element();
+    ASSERT(renderer.element());
+    Element& self = *renderer.element();
     Element* next = skipDescendants ? ElementTraversal::nextIncludingPseudoSkippingChildren(self, stayWithin) : ElementTraversal::nextIncludingPseudo(self, stayWithin);
     while (next && !next->renderer())
-        next = skipDescendants ? ElementTraversal::nextIncludingPseudoSkippingChildren(next, stayWithin) : ElementTraversal::nextIncludingPseudo(next, stayWithin);
-    return next ? next->renderer() : 0;
+        next = skipDescendants ? ElementTraversal::nextIncludingPseudoSkippingChildren(*next, stayWithin) : ElementTraversal::nextIncludingPseudo(*next, stayWithin);
+    return next ? next->renderer() : nullptr;
 }
 
 static bool planCounter(RenderElement& renderer, const AtomicString& identifier, bool& isReset, int& value)
index d2e7d40..8d8faba 100644 (file)
@@ -126,18 +126,18 @@ static Element* enclosingList(const RenderListItem& listItem)
 // Returns the next list item with respect to the DOM order.
 static RenderListItem* nextListItem(const Element& listNode, const Element& element)
 {
-    for (const Element* next = ElementTraversal::nextIncludingPseudo(&element, &listNode); next; ) {
+    for (const Element* next = ElementTraversal::nextIncludingPseudo(element, &listNode); next; ) {
         auto* renderer = next->renderer();
         if (!renderer || isHTMLListElement(*next)) {
             // We've found a nested, independent list or an unrendered Element : nothing to do here.
-            next = ElementTraversal::nextIncludingPseudoSkippingChildren(next, &listNode);
+            next = ElementTraversal::nextIncludingPseudoSkippingChildren(*next, &listNode);
             continue;
         }
 
         if (is<RenderListItem>(*renderer))
             return downcast<RenderListItem>(renderer);
 
-        next = ElementTraversal::nextIncludingPseudo(next, &listNode);
+        next = ElementTraversal::nextIncludingPseudo(*next, &listNode);
     }
 
     return nullptr;
@@ -156,7 +156,7 @@ static inline RenderListItem* nextListItem(const Element& listNode)
 // Returns the previous list item with respect to the DOM order.
 static RenderListItem* previousListItem(const Element* listNode, const RenderListItem& item)
 {
-    for (const Element* current = ElementTraversal::previousIncludingPseudo(&item.element(), listNode); current; current = ElementTraversal::previousIncludingPseudo(current, listNode)) {
+    for (const Element* current = ElementTraversal::previousIncludingPseudo(item.element(), listNode); current; current = ElementTraversal::previousIncludingPseudo(*current, listNode)) {
         RenderElement* renderer = current->renderer();
         if (!is<RenderListItem>(renderer))
             continue;
@@ -169,7 +169,7 @@ static RenderListItem* previousListItem(const Element* listNode, const RenderLis
         // be a list item itself. We need to examine it, so we do this to counteract
         // the previousIncludingPseudo() that will be done by the loop.
         if (otherList)
-            current = ElementTraversal::nextIncludingPseudo(otherList);
+            current = ElementTraversal::nextIncludingPseudo(*otherList);
     }
     return nullptr;
 }
index 439700a..73d3987 100644 (file)
@@ -614,12 +614,11 @@ static bool boxIntersectsRegion(LayoutUnit logicalTopForBox, LayoutUnit logicalB
 }
 
 // Retrieve the next node to be visited while computing the ranges inside a region.
-static Node* nextNodeInsideContentElement(const Node* currNode, const Element* contentElement)
+static Node* nextNodeInsideContentElement(const Node& currNode, const Element* contentElement)
 {
-    ASSERT(currNode);
     ASSERT(contentElement && contentElement->isNamedFlowContentNode());
 
-    if (currNode->renderer() && currNode->renderer()->isSVGRoot())
+    if (currNode.renderer() && currNode.renderer()->isSVGRoot())
         return NodeTraversal::nextSkippingChildren(currNode, contentElement);
 
     return NodeTraversal::next(currNode, contentElement);
@@ -660,7 +659,7 @@ void RenderNamedFlowThread::getRanges(Vector<RefPtr<Range>>& rangeObjects, const
         bool skipOverOutsideNodes = false;
         Node* lastEndNode = nullptr;
 
-        for (Node* node = contentElement; node; node = nextNodeInsideContentElement(node, contentElement)) {
+        for (Node* node = contentElement; node; node = nextNodeInsideContentElement(*node, contentElement)) {
             RenderObject* renderer = node->renderer();
             if (!renderer)
                 continue;
index 891c0c2..4a35a01 100644 (file)
@@ -890,9 +890,10 @@ void RenderView::splitSelectionBetweenSubtrees(const RenderObject* start, int st
     if (start && end) {
         Node* startNode = start->node();
         Node* endNode = end->node();
-        Node* stopNode = NodeTraversal::nextSkippingChildren(endNode);
+        ASSERT(endNode);
+        Node* stopNode = NodeTraversal::nextSkippingChildren(*endNode);
 
-        for (Node* node = startNode; node != stopNode; node = NodeTraversal::next(node)) {
+        for (Node* node = startNode; node != stopNode; node = NodeTraversal::next(*node)) {
             RenderObject* renderer = node->renderer();
             if (!renderer)
                 continue;
index 0332fde..b1f2264 100644 (file)
@@ -207,7 +207,7 @@ void NodeSet::traversalSort() const
     Vector<RefPtr<Node>> sortedNodes;
     sortedNodes.reserveInitialCapacity(nodeCount);
 
-    for (Node* node = findRootNode(m_nodes.first().get()); node; node = NodeTraversal::next(node)) {
+    for (Node* node = findRootNode(m_nodes.first().get()); node; node = NodeTraversal::next(*node)) {
         if (nodes.contains(node))
             sortedNodes.append(node);
 
index c4cfd5a..5a1c029 100644 (file)
@@ -260,7 +260,7 @@ void Step::nodesInAxis(Node& context, NodeSet& nodes) const
         case DescendantAxis:
             if (context.isAttributeNode()) // In XPath model, attribute nodes do not have children.
                 return;
-            for (Node* node = context.firstChild(); node; node = NodeTraversal::next(node, &context)) {
+            for (Node* node = context.firstChild(); node; node = NodeTraversal::next(*node, &context)) {
                 if (nodeMatches(*node, DescendantAxis, m_nodeTest))
                     nodes.append(node);
             }
@@ -310,7 +310,7 @@ void Step::nodesInAxis(Node& context, NodeSet& nodes) const
         case FollowingAxis:
             if (context.isAttributeNode()) {
                 Node* node = static_cast<Attr&>(context).ownerElement();
-                while ((node = NodeTraversal::next(node))) {
+                while ((node = NodeTraversal::next(*node))) {
                     if (nodeMatches(*node, FollowingAxis, m_nodeTest))
                         nodes.append(node);
                 }
@@ -319,7 +319,7 @@ void Step::nodesInAxis(Node& context, NodeSet& nodes) const
                     for (Node* node = parent->nextSibling(); node; node = node->nextSibling()) {
                         if (nodeMatches(*node, FollowingAxis, m_nodeTest))
                             nodes.append(node);
-                        for (Node* child = node->firstChild(); child; child = NodeTraversal::next(child, node)) {
+                        for (Node* child = node->firstChild(); child; child = NodeTraversal::next(*child, node)) {
                             if (nodeMatches(*child, FollowingAxis, m_nodeTest))
                                 nodes.append(child);
                         }
@@ -334,7 +334,7 @@ void Step::nodesInAxis(Node& context, NodeSet& nodes) const
             else
                 node = &context;
             while (ContainerNode* parent = node->parentNode()) {
-                for (node = NodeTraversal::previous(node); node != parent; node = NodeTraversal::previous(node)) {
+                for (node = NodeTraversal::previous(*node); node != parent; node = NodeTraversal::previous(*node)) {
                     if (nodeMatches(*node, PrecedingAxis, m_nodeTest))
                         nodes.append(node);
                 }
@@ -381,7 +381,7 @@ void Step::nodesInAxis(Node& context, NodeSet& nodes) const
                 nodes.append(&context);
             if (context.isAttributeNode()) // In XPath model, attribute nodes do not have children.
                 return;
-            for (Node* node = context.firstChild(); node; node = NodeTraversal::next(node, &context)) {
+            for (Node* node = context.firstChild(); node; node = NodeTraversal::next(*node, &context)) {
                 if (nodeMatches(*node, DescendantOrSelfAxis, m_nodeTest))
                     nodes.append(node);
             }
index 60b4a68..daaf9f2 100644 (file)
@@ -51,7 +51,7 @@ String stringValue(Node* node)
             return node->nodeValue();
         default:
             if (isRootDomNode(node) || node->isElementNode())
-                return TextNodeTraversal::contentsAsString(node);
+                return TextNodeTraversal::contentsAsString(*node);
     }
     return String();
 }
index 39de71e..b7ca663 100644 (file)
@@ -1,3 +1,13 @@
+2015-01-26  Chris Dumez  <cdumez@apple.com>
+
+        First argument to DOM traversal functions should be a reference
+        https://bugs.webkit.org/show_bug.cgi?id=140895
+
+        Reviewed by Antti Koivisto.
+
+        First argument to DOM traversal functions should be a reference instead
+        of a pointer as it is dereferenced without null-check.
+
 2015-01-26  Myles C. Maxfield  <mmaxfield@apple.com>
 
         [iOS] [SVG -> OTF Converter] Flip the switch off on iOS
index 917b854..6311436 100644 (file)
@@ -1763,7 +1763,7 @@ static WebFrameLoadType toWebFrameLoadType(FrameLoadType frameLoadType)
     DOMRange *previousDOMRange = nil;
     id previousMetadata = nil;
     
-    for (Node* node = root; node; node = NodeTraversal::next(node)) {
+    for (Node* node = root; node; node = NodeTraversal::next(*node)) {
         auto markers = document->markers().markersFor(node);
         for (auto marker : markers) {
 
index c4506e8..b698872 100644 (file)
@@ -424,8 +424,10 @@ static RegularExpression* regExpForLabels(NSArray *labels)
     return result;
 }
 
+// FIXME: This should take an Element&.
 static NSString* searchForLabelsBeforeElement(Frame* frame, NSArray* labels, Element* element, size_t* resultDistance, bool* resultIsInCellAbove)
 {
+    ASSERT(element);
     RegularExpression* regExp = regExpForLabels(labels);
     // We stop searching after we've seen this many chars
     const unsigned int charsSearchedThreshold = 500;
@@ -444,9 +446,7 @@ static NSString* searchForLabelsBeforeElement(Frame* frame, NSArray* labels, Ele
     // walk backwards in the node tree, until another element, or form, or end of tree
     unsigned lengthSearched = 0;
     Node* n;
-    for (n = NodeTraversal::previous(element);
-        n && lengthSearched < charsSearchedThreshold;
-        n = NodeTraversal::previous(n)) {
+    for (n = NodeTraversal::previous(*element); n && lengthSearched < charsSearchedThreshold; n = NodeTraversal::previous(*n)) {
         if (is<HTMLFormElement>(*n) || is<HTMLFormControlElement>(*n)) {
             // We hit another form element or the start of the form - bail out
             break;
index 426de66..d29ba1c 100644 (file)
@@ -1,3 +1,13 @@
+2015-01-26  Chris Dumez  <cdumez@apple.com>
+
+        First argument to DOM traversal functions should be a reference
+        https://bugs.webkit.org/show_bug.cgi?id=140895
+
+        Reviewed by Antti Koivisto.
+
+        First argument to DOM traversal functions should be a reference instead
+        of a pointer as it is dereferenced without null-check.
+
 2015-01-26  Beth Dakin  <bdakin@apple.com>
 
         Blacklist iBooks for WebKit's default immediate actions
index fc4ec02..b05460a 100644 (file)
@@ -613,7 +613,7 @@ bool WebFrame::containsAnyFormElements() const
     if (!document)
         return false;
 
-    for (Node* node = document->documentElement(); node; node = NodeTraversal::next(node)) {
+    for (Node* node = document->documentElement(); node; node = NodeTraversal::next(*node)) {
         if (!is<Element>(*node))
             continue;
         if (is<HTMLFormElement>(*node))
@@ -631,7 +631,7 @@ bool WebFrame::containsAnyFormControls() const
     if (!document)
         return false;
 
-    for (Node* node = document->documentElement(); node; node = NodeTraversal::next(node)) {
+    for (Node* node = document->documentElement(); node; node = NodeTraversal::next(*node)) {
         if (!is<Element>(*node))
             continue;
         if (is<HTMLInputElement>(*node) || is<HTMLSelectElement>(*node) || is<HTMLTextAreaElement>(*node))