Move parts of core/dom to C++11

Source/core/dom/ContainerNode.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2013 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 187 matching lines @@
         return newChild;
     }
     ASSERT(newChild);
 
     // NotFoundError: Raised if refChild is not a child of this node
     if (refChild->parentNode() != this) {
         exceptionState.throwDOMException(NotFoundError, "The node before which the new node is to be inserted is not a child of this node.");
         return nullptr;
     }
 
-    // nothing to do
+    // Nothing to do.
     if (refChild->previousSibling() == newChild || refChild == newChild)
         return newChild;
 
     RefPtrWillBeRawPtr<Node> next = refChild;
 
     NodeVector targets;
     collectChildrenAndRemoveFromOldParent(*newChild, targets, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
     if (targets.isEmpty())
         return newChild;
 
     // We need this extra check because collectChildrenAndRemoveFromOldParent() can fire mutation events.
     if (!checkAcceptChildGuaranteedNodeTypes(*newChild, exceptionState)) {
         if (exceptionState.hadException())
             return nullptr;
         return newChild;
     }
 
     InspectorInstrumentation::willInsertDOMNode(this);
 
     ChildListMutationScope mutation(*this);
-    for (NodeVector::const_iterator it = targets.begin(); it != targets.end(); ++it) {
-        ASSERT(*it);
-        Node& child = **it;
+    for (const auto& targetNode : targets) {
+        ASSERT(targetNode);
+        Node& child = *targetNode;
 
         // Due to arbitrary code running in response to a DOM mutation event it's
         // possible that "next" is no longer a child of "this".
         // It's also possible that "child" has been inserted elsewhere.
         // In either of those cases, we'll just stop.
         if (next->parentNode() != this)
             break;
         if (child.parentNode())
             break;
 
@@ skipping 76 matching lines @@
 PassRefPtrWillBeRawPtr<Node> ContainerNode::replaceChild(PassRefPtrWillBeRawPtr<Node> newChild, PassRefPtrWillBeRawPtr<Node> oldChild, ExceptionState& exceptionState)
 {
 #if !ENABLE(OILPAN)
     // Check that this node is not "floating".
     // If it is, it can be deleted as a side effect of sending mutation events.
     ASSERT(refCount() || parentOrShadowHostNode());
 #endif
 
     RefPtrWillBeRawPtr<Node> protect(this);
 
-    if (oldChild == newChild) // nothing to do
+    if (oldChild == newChild) // Nothing to do.
         return oldChild;
 
     if (!oldChild) {
         exceptionState.throwDOMException(NotFoundError, "The node to be replaced is null.");
         return nullptr;
     }
 
     RefPtrWillBeRawPtr<Node> child = oldChild;
 
-    // Make sure replacing the old child with the new is ok
+    // Make sure replacing the old child with the new is OK.
     if (!checkAcceptChild(newChild.get(), child.get(), exceptionState)) {
         if (exceptionState.hadException())
             return nullptr;
         return child;
     }
 
     // NotFoundError: Raised if oldChild is not a child of this node.
     if (child->parentNode() != this) {
         exceptionState.throwDOMException(NotFoundError, "The node to be replaced is not a child of this node.");
         return nullptr;
     }
 
     ChildListMutationScope mutation(*this);
 
     RefPtrWillBeRawPtr<Node> next = child->nextSibling();
 
-    // Remove the node we're replacing
+    // Remove the node we're replacing.
     removeChild(child, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
     if (next && (next->previousSibling() == newChild || next == newChild)) // nothing to do
         return child;
 
     // Does this one more time because removeChild() fires a MutationEvent.
     if (!checkAcceptChild(newChild.get(), child.get(), exceptionState)) {
         if (exceptionState.hadException())
             return nullptr;
         return child;
     }
 
     NodeVector targets;
     collectChildrenAndRemoveFromOldParent(*newChild, targets, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
     // Does this yet another check because collectChildrenAndRemoveFromOldParent() fires a MutationEvent.
     if (!checkAcceptChild(newChild.get(), child.get(), exceptionState)) {
         if (exceptionState.hadException())
             return nullptr;
         return child;
     }
 
     InspectorInstrumentation::willInsertDOMNode(this);
 
-    // Add the new child(ren)
-    for (NodeVector::const_iterator it = targets.begin(); it != targets.end(); ++it) {
-        ASSERT(*it);
-        Node& child = **it;
+    // Add the new child(ren).
+    for (const auto& targetNode : targets) {
+        ASSERT(targetNode);
+        Node& child = *targetNode;
 
         // Due to arbitrary code running in response to a DOM mutation event it's
         // possible that "next" is no longer a child of "this".
         // It's also possible that "child" has been inserted elsewhere.
         // In either of those cases, we'll just stop.
         if (next && next->parentNode() != this)
             break;
         if (child.parentNode())
             break;
 
@@ skipping 24 matching lines @@
     document().nodeWillBeRemoved(child); // e.g. mutation event listener can create a new range.
     ChildFrameDisconnector(child).disconnect();
 }
 
 void ContainerNode::willRemoveChildren()
 {
     NodeVector children;
     getChildNodes(*this, children);
 
     ChildListMutationScope mutation(*this);
-    for (NodeVector::const_iterator it = children.begin(); it != children.end(); ++it) {
-        ASSERT(*it);
-        Node& child = **it;
+    for (const auto& node : children) {
+        ASSERT(node);
+        Node& child = *node;
         mutation.willRemoveChild(child);
         child.notifyMutationObserversNodeWillDetach();
         dispatchChildRemovalEvents(child);
     }
 
     ChildFrameDisconnector(*this).disconnect(ChildFrameDisconnector::DescendantsOnly);
 }
 
 #if !ENABLE(OILPAN)
 void ContainerNode::removeDetachedChildrenInContainer(ContainerNode& container)
 {
     // List of nodes to be deleted.
-    Node* head = 0;
-    Node* tail = 0;
+    Node* head = nullptr;
+    Node* tail = nullptr;
 
     addChildNodesToDeletionQueue(head, tail, container);
 
     Node* n;
     Node* next;
-    while ((n = head) != 0) {
+    while (head) {
+        n = head;
         ASSERT_WITH_SECURITY_IMPLICATION(n->m_deletionHasBegun);
 
         next = n->nextSibling();
-        n->setNextSibling(0);
+        n->setNextSibling(nullptr);
 
         head = next;
-        if (next == 0)
-            tail = 0;
+        if (!next)
+            tail = nullptr;
 
         if (n->hasChildren())
             addChildNodesToDeletionQueue(head, tail, toContainerNode(*n));
 
         delete n;
     }
 }
 
 void ContainerNode::addChildNodesToDeletionQueue(Node*& head, Node*& tail, ContainerNode& container)
 {
     // We have to tell all children that their parent has died.
-    Node* next = 0;
+    Node* next = nullptr;
     for (Node* n = container.firstChild(); n; n = next) {
         ASSERT_WITH_SECURITY_IMPLICATION(!n->m_deletionHasBegun);
 
         next = n->nextSibling();
-        n->setNextSibling(0);
-        n->setParentOrShadowHostNode(0);
+        n->setNextSibling(nullptr);
+        n->setParentOrShadowHostNode(nullptr);
         container.setFirstChild(next);
         if (next)
-            next->setPreviousSibling(0);
+            next->setPreviousSibling(nullptr);
 
         if (!n->refCount()) {
 #if ENABLE(SECURITY_ASSERT)
             n->m_deletionHasBegun = true;
 #endif
             // Add the node to the list of nodes to be deleted.
             // Reuse the nextSibling pointer for this purpose.
             if (tail)
                 tail->setNextSibling(n);
             else
                 head = n;
 
             tail = n;
         } else {
             RefPtrWillBeRawPtr<Node> protect(n); // removedFromDocument may remove all references to this node.
             container.document().adoptIfNeeded(*n);
             if (n->inDocument())
                 container.notifyNodeRemoved(*n);
         }
     }
 
-    container.setLastChild(0);
+    container.setLastChild(nullptr);
 }
 #endif
 
 void ContainerNode::disconnectDescendantFrames()
 {
     ChildFrameDisconnector(*this).disconnect();
 }
 
 void ContainerNode::trace(Visitor* visitor)
 {
@@ skipping 64 matching lines @@
 
     if (nextChild)
         nextChild->setPreviousSibling(previousChild);
     if (previousChild)
         previousChild->setNextSibling(nextChild);
     if (m_firstChild == &oldChild)
         m_firstChild = nextChild;
     if (m_lastChild == &oldChild)
         m_lastChild = previousChild;
 
-    oldChild.setPreviousSibling(0);
-    oldChild.setNextSibling(0);
-    oldChild.setParentOrShadowHostNode(0);
+    oldChild.setPreviousSibling(nullptr);
+    oldChild.setNextSibling(nullptr);
+    oldChild.setParentOrShadowHostNode(nullptr);
 
     document().adoptIfNeeded(oldChild);
 }
 
 void ContainerNode::parserRemoveChild(Node& oldChild)
 {
     ASSERT(oldChild.parentNode() == this);
     ASSERT(!oldChild.isDocumentFragment());
 
     Node* prev = oldChild.previousSibling();
     Node* next = oldChild.nextSibling();
 
     oldChild.updateAncestorConnectedSubframeCountForRemoval();
 
     ChildListMutationScope(*this).willRemoveChild(oldChild);
     oldChild.notifyMutationObserversNodeWillDetach();
 
     removeBetween(prev, next, oldChild);
 
     notifyNodeRemoved(oldChild);
     childrenChanged(ChildrenChange::forRemoval(oldChild, prev, next, ChildrenChangeSourceParser));
 }
 
-// this differs from other remove functions because it forcibly removes all the children,
+// This differs from other remove functions because it forcibly removes all the children,
 // regardless of read-only status or event exceptions, e.g.
 void ContainerNode::removeChildren()
 {
     if (!m_firstChild)
         return;
 
     // The container node can be removed from event handlers.
     RefPtrWillBeRawPtr<ContainerNode> protect(this);
 
     // Do any prep work needed before actually starting to detach
@@ skipping 79 matching lines @@
 
     // We need this extra check because collectChildrenAndRemoveFromOldParent() can fire mutation events.
     if (!checkAcceptChildGuaranteedNodeTypes(*newChild, exceptionState)) {
         if (exceptionState.hadException())
             return nullptr;
         return newChild;
     }
 
     InspectorInstrumentation::willInsertDOMNode(this);
 
-    // Now actually add the child(ren)
+    // Now actually add the child(ren).
     ChildListMutationScope mutation(*this);
-    for (NodeVector::const_iterator it = targets.begin(); it != targets.end(); ++it) {
-        ASSERT(*it);
-        Node& child = **it;
+    for (const auto& targetNode : targets) {
+        ASSERT(targetNode);
+        Node& child = *targetNode;
 
         // If the child has a parent again, just stop what we're doing, because
         // that means someone is doing something with DOM mutation -- can't re-parent
         // a child that already has a parent.
         if (child.parentNode())
             break;
 
         {
             EventDispatchForbiddenScope assertNoEventDispatch;
             ScriptForbiddenScope forbidScript;
@@ skipping 42 matching lines @@
     InspectorInstrumentation::didInsertDOMNode(&root);
 
     RefPtrWillBeRawPtr<Node> protect(this);
     RefPtrWillBeRawPtr<Node> protectNode(root);
 
     NodeVector postInsertionNotificationTargets;
     notifyNodeInsertedInternal(root, postInsertionNotificationTargets);
 
     childrenChanged(ChildrenChange::forInsertion(root, source));
 
-    for (size_t i = 0; i < postInsertionNotificationTargets.size(); ++i) {
-        Node* targetNode = postInsertionNotificationTargets[i].get();
+    for (const auto& targetNode : postInsertionNotificationTargets) {
         if (targetNode->inDocument())
             targetNode->didNotifySubtreeInsertionsToDocument();
     }
 }
 
 void ContainerNode::notifyNodeInsertedInternal(Node& root, NodeVector& postInsertionNotificationTargets)
 {
     EventDispatchForbiddenScope assertNoEventDispatch;
     ScriptForbiddenScope forbidScript;
 
@@ skipping 60 matching lines @@
     TrackExceptionState exceptionState;
     for (Node* n = firstChild(); n && !exceptionState.hadException(); n = n->nextSibling())
         clone->appendChild(n->cloneNode(true), exceptionState);
 }
 
 
 bool ContainerNode::getUpperLeftCorner(FloatPoint& point) const
 {
     if (!renderer())
         return false;
-    // What is this code really trying to do?
+
+    // FIXME: What is this code really trying to do?
     RenderObject* o = renderer();
-
     if (!o->isInline() || o->isReplaced()) {
         point = o->localToAbsolute(FloatPoint(), UseTransforms);
         return true;
     }
 
-    // find the next text/image child, to get a position
+    // Find the next text/image child, to get a position.
     while (o) {
         RenderObject* p = o;
         if (RenderObject* oFirstChild = o->slowFirstChild()) {
             o = oFirstChild;
         } else if (o->nextSibling()) {
             o = o->nextSibling();
         } else {
-            RenderObject* next = 0;
+            RenderObject* next = nullptr;
             while (!next && o->parent()) {
                 o = o->parent();
                 next = o->nextSibling();
             }
             o = next;
 
             if (!o)
                 break;
         }
         ASSERT(o);
 
         if (!o->isInline() || o->isReplaced()) {
             point = o->localToAbsolute(FloatPoint(), UseTransforms);
             return true;
         }
 
         if (p->node() && p->node() == this && o->isText() && !o->isBR() && !toRenderText(o)->firstTextBox()) {
-            // do nothing - skip unrendered whitespace that is a child or next sibling of the anchor
+            // Do nothing - skip unrendered whitespace that is a child or next sibling of the anchor.
         } else if ((o->isText() && !o->isBR()) || o->isReplaced()) {
             point = FloatPoint();
             if (o->isText() && toRenderText(o)->firstTextBox()) {
                 point.move(toRenderText(o)->linesBoundingBox().x(), toRenderText(o)->firstTextBox()->root().lineTop().toFloat());
             } else if (o->isBox()) {
                 RenderBox* box = toRenderBox(o);
                 point.moveBy(box->location());
             }
             point = o->container()->localToAbsolute(point, UseTransforms);
             return true;
@@ skipping 14 matching lines @@
     if (!renderer())
         return false;
 
     RenderObject* o = renderer();
     if (!o->isInline() || o->isReplaced()) {
         RenderBox* box = toRenderBox(o);
         point = o->localToAbsolute(LayoutPoint(box->size()), UseTransforms);
         return true;
     }
 
-    // find the last text/image child, to get a position
+    // Find the last text/image child, to get a position.
     while (o) {
         if (RenderObject* oLastChild = o->slowLastChild()) {
             o = oLastChild;
         } else if (o->previousSibling()) {
             o = o->previousSibling();
         } else {
-            RenderObject* prev = 0;
-        while (!prev) {
-            o = o->parent();
-            if (!o)
-                return false;
-            prev = o->previousSibling();
-        }
-        o = prev;
+            RenderObject* prev = nullptr;
+            while (!prev) {
+                o = o->parent();
+                if (!o)
+                    return false;
+                prev = o->previousSibling();
+            }
+            o = prev;
         }
         ASSERT(o);
         if (o->isText() || o->isReplaced()) {
             point = FloatPoint();
             if (o->isText()) {
                 RenderText* text = toRenderText(o);
                 IntRect linesBox = text->linesBoundingBox();
                 if (!linesBox.maxX() && !linesBox.maxY())
                     continue;
                 point.moveBy(linesBox.maxXMaxYCorner());
@@ skipping 193 matching lines @@
         return;
     }
 
     ASSERT(!EventDispatchForbiddenScope::isEventDispatchForbidden());
 
     InspectorInstrumentation::willRemoveDOMNode(&child);
 
     RefPtrWillBeRawPtr<Node> c(child);
     RefPtrWillBeRawPtr<Document> document(child.document());
 
-    // dispatch pre-removal mutation events
+    // Dispatch pre-removal mutation events.
     if (c->parentNode() && document->hasListenerType(Document::DOMNODEREMOVED_LISTENER)) {
         NodeChildRemovalTracker scope(child);
         c->dispatchScopedEvent(MutationEvent::create(EventTypeNames::DOMNodeRemoved, true, c->parentNode()));
     }
 
-    // dispatch the DOMNodeRemovedFromDocument event to all descendants
+    // Dispatch the DOMNodeRemovedFromDocument event to all descendants.
     if (c->inDocument() && document->hasListenerType(Document::DOMNODEREMOVEDFROMDOCUMENT_LISTENER)) {
         NodeChildRemovalTracker scope(child);
         for (; c; c = NodeTraversal::next(*c, &child))
             c->dispatchScopedEvent(MutationEvent::create(EventTypeNames::DOMNodeRemovedFromDocument, false));
     }
 }
 
 void ContainerNode::updateTreeAfterInsertion(Node& child)
 {
 #if !ENABLE(OILPAN)
@@ skipping 31 matching lines @@
     ASSERT(!needsStyleRecalc());
 
     if (change < Force && hasRareData() && childNeedsStyleRecalc())
         checkForChildrenAdjacentRuleChanges();
 
     // This loop is deliberately backwards because we use insertBefore in the rendering tree, and want to avoid
     // a potentially n^2 loop to find the insertion point while resolving style. Having us start from the last
     // child and work our way back means in the common case, we'll find the insertion point in O(1) time.
     // See crbug.com/288225
     StyleResolver& styleResolver = document().ensureStyleResolver();
-    Text* lastTextNode = 0;
+    Text* lastTextNode = nullptr;
     for (Node* child = lastChild(); child; child = child->previousSibling()) {
         if (child->isTextNode()) {
             toText(child)->recalcTextStyle(change, lastTextNode);
             lastTextNode = toText(child);
         } else if (child->isElementNode()) {
             Element* element = toElement(child);
             if (element->shouldCallRecalcStyle(change))
                 element->recalcStyle(change, lastTextNode);
             else if (element->supportsStyleSharing())
                 styleResolver.addToStyleSharingList(*element);
             if (element->renderer())
-                lastTextNode = 0;
+                lastTextNode = nullptr;
         }
     }
 }
 
 void ContainerNode::checkForChildrenAdjacentRuleChanges()
 {
     bool hasDirectAdjacentRules = childrenAffectedByDirectAdjacentRules();
     bool hasIndirectAdjacentRules = childrenAffectedByIndirectAdjacentRules();
 
     if (!hasDirectAdjacentRules && !hasIndirectAdjacentRules)
@@ skipping 40 matching lines @@
         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 (childrenAffectedByFirstChildRules() && nodeAfterChange) {
         ASSERT(changeType != FinishedParsingChildren);
         // Find our new first child element.
         Element* firstChildElement = ElementTraversal::firstChild(*this);
-        RenderStyle* firstChildElementStyle = firstChildElement ? firstChildElement->renderStyle() : 0;
+        RenderStyle* firstChildElementStyle = firstChildElement ? firstChildElement->renderStyle() : nullptr;
 
         // Find the first element after the change.
         Element* elementAfterChange = nodeAfterChange->isElementNode() ? toElement(nodeAfterChange) : ElementTraversal::nextSibling(*nodeAfterChange);
-        RenderStyle* elementAfterChangeStyle = elementAfterChange ? elementAfterChange->renderStyle() : 0;
+        RenderStyle* elementAfterChangeStyle = elementAfterChange ? elementAfterChange->renderStyle() : nullptr;
 
         // This is the element insertion as first child element case.
         if (firstChildElement != elementAfterChange && elementAfterChangeStyle && elementAfterChangeStyle->firstChildState()) {
             ASSERT(changeType == SiblingElementInserted);
             elementAfterChange->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::SiblingSelector));
         }
 
         // This is the first child element removal case.
         if (changeType == SiblingElementRemoved && firstChildElement == elementAfterChange && firstChildElement && (!firstChildElementStyle || !firstChildElementStyle->firstChildState()))
             firstChildElement->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::SiblingSelector));
     }
 
     // :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 (childrenAffectedByLastChildRules() && nodeBeforeChange) {
         // Find our new last child element.
         Element* lastChildElement = ElementTraversal::lastChild(*this);
-        RenderStyle* lastChildElementStyle = lastChildElement ? lastChildElement->renderStyle() : 0;
+        RenderStyle* lastChildElementStyle = lastChildElement ? lastChildElement->renderStyle() : nullptr;
 
         // Find the last element before the change.
         Element* elementBeforeChange = nodeBeforeChange->isElementNode() ? toElement(nodeBeforeChange) : ElementTraversal::previousSibling(*nodeBeforeChange);
-        RenderStyle* elementBeforeChangeStyle = elementBeforeChange ? elementBeforeChange->renderStyle() : 0;
+        RenderStyle* elementBeforeChangeStyle = elementBeforeChange ? elementBeforeChange->renderStyle() : nullptr;
 
         // This is the element insertion as last child element case.
         if (lastChildElement != elementBeforeChange && elementBeforeChangeStyle && elementBeforeChangeStyle->lastChildState()) {
             ASSERT(SiblingElementInserted);
             elementBeforeChange->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::SiblingSelector));
         }
 
         // This is the last child element removal case. The parser callback case is similar to node removal as well in that we need to change the last child
         // to match now.
         if ((changeType == SiblingElementRemoved || changeType == FinishedParsingChildren) && lastChildElement == elementBeforeChange && lastChildElement && (!lastChildElementStyle || !lastChildElementStyle->lastChildState()))
@@ skipping 74 matching lines @@
     return ensureCachedCollection<RadioNodeList>(type, name);
 }
 
 Element* ContainerNode::getElementById(const AtomicString& id) const
 {
     if (isInTreeScope()) {
         // Fast path if we are in a tree scope: call getElementById() on tree scope
         // and check if the matching element is in our subtree.
         Element* element = treeScope().getElementById(id);
         if (!element)
-            return 0;
+            return nullptr;
         if (element->isDescendantOf(this))
             return element;
     }
 
     // Fall back to traversing our subtree. In case of duplicate ids, the first element found will be returned.
     for (Element& element : ElementTraversal::descendantsOf(*this)) {
         if (element.getIdAttribute() == id)
             return &element;
     }
-    return 0;
+    return nullptr;
 }
 
 NodeListsNodeData& ContainerNode::ensureNodeLists()
 {
     return ensureRareData().ensureNodeLists();
 }
 
 #if ENABLE(ASSERT)
 bool childAttachedAllowedWhenAttachingChildren(ContainerNode* node)
 {
     if (node->isShadowRoot())
         return true;
 
     if (node->isInsertionPoint())
         return true;
 
     if (node->isElementNode() && toElement(node)->shadow())
         return true;
 
     return false;
 }
 #endif
 
 } // namespace blink