Various cleanup of ContainerNode.cpp

third_party/WebKit/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 45 matching lines @@
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static void dispatchChildInsertionEvents(Node&);
 static void dispatchChildRemovalEvents(Node&);
 
 // This dispatches various events; DOM mutation events, blur events, IFRAME
 // unload events, etc.
-static void collectChildrenAndRemoveFromOldParent(Node& node, NodeVector& nodes, ExceptionState& exceptionState)
+static inline void collectChildrenAndRemoveFromOldParent(Node& node, NodeVector& nodes, ExceptionState& exceptionState)
 {
     if (node.isDocumentFragment()) {
         DocumentFragment& fragment = toDocumentFragment(node);
         getChildNodes(fragment, nodes);
         fragment.removeChildren();
         return;
     }
     nodes.append(&node);
     if (ContainerNode* oldParent = node.parentNode())
         oldParent->removeChild(&node, exceptionState);
@@ skipping 74 matching lines @@
         exceptionState.throwDOMException(HierarchyRequestError, "The new child element contains the parent.");
         return false;
     }
     if (!isChildTypeAllowed(newChild)) {
         exceptionState.throwDOMException(HierarchyRequestError, "Nodes of type '" + newChild.nodeName() + "' may not be inserted inside nodes of type '" + nodeName() + "'.");
         return false;
     }
     return true;
 }
 
-void ContainerNode::collectChildrenAndRemoveFromOldParentWithCheck(const Node* next, const Node* oldChild, Node& newChild, NodeVector& newChildren, ExceptionState& exceptionState) const
+bool ContainerNode::collectChildrenAndRemoveFromOldParentWithCheck(const Node* next, const Node* oldChild, Node& newChild, NodeVector& newChildren, ExceptionState& exceptionState) const
 {
     collectChildrenAndRemoveFromOldParent(newChild, newChildren, exceptionState);
-    if (exceptionState.hadException())
-        return;
-    if (newChildren.isEmpty())
-        return;
+    if (exceptionState.hadException() || newChildren.isEmpty())
+        return false;
 
     // We need this extra check because collectChildrenAndRemoveFromOldParent()
     // can fire various events.
     for (const auto& child : newChildren) {
         if (child->parentNode()) {
             // A new child was added to another parent before adding to this
             // node.  Firefox and Edge don't throw in this case.
-            newChildren.clear();
-            return;
+            return false;
         }
         if (!checkAcceptChildGuaranteedNodeTypes(*child, oldChild, exceptionState))
-            return;
+            return false;
     }
     if (next && next->parentNode() != this) {
         exceptionState.throwDOMException(NotFoundError, "The node before which the new node is to be inserted is not a child of this node.");
-        return;
+        return false;
     }
+    return true;
 }
 
 template <typename Functor>
 void ContainerNode::insertNodeVector(const NodeVector& targets, Node* next, const Functor& mutator)
 {
     InspectorInstrumentation::willInsertDOMNode(this);
     NodeVector postInsertionNotificationTargets;
     {
         EventDispatchForbiddenScope assertNoEventDispatch;
         ScriptForbiddenScope forbidScript;
@@ skipping 38 matching lines @@
     inline void operator()(ContainerNode& container, Node& child, Node*) const
     {
         container.treeScope().adoptIfNeeded(child);
         container.appendChildCommon(child);
     }
 };
 
 Node* ContainerNode::insertBefore(Node* newChild, Node* refChild, ExceptionState& exceptionState)
 {
     // insertBefore(node, 0) is equivalent to appendChild(node)
-    if (!refChild) {
+    if (!refChild)
         return appendChild(newChild, exceptionState);
-    }
 
     // Make sure adding the new child is OK.
-    if (!checkAcceptChild(newChild, 0, exceptionState)) {
-        if (exceptionState.hadException())
-            return nullptr;
+    if (!checkAcceptChild(newChild, 0, exceptionState))
         return newChild;
-    }
     DCHECK(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.
     if (refChild->previousSibling() == newChild || refChild == newChild)
         return newChild;
 
-    Node* next = refChild;
-
     NodeVector targets;
-    collectChildrenAndRemoveFromOldParentWithCheck(next, nullptr, *newChild, targets, exceptionState);
-    if (exceptionState.hadException())
-        return nullptr;
-    if (targets.isEmpty())
+    if (!collectChildrenAndRemoveFromOldParentWithCheck(refChild, nullptr, *newChild, targets, exceptionState))
         return newChild;
 
     ChildListMutationScope mutation(*this);
-    insertNodeVector(targets, next, AdoptAndInsertBefore());
+    insertNodeVector(targets, refChild, AdoptAndInsertBefore());
     return newChild;
 }
 
 void ContainerNode::insertBeforeCommon(Node& nextChild, Node& newChild)
 {
-    EventDispatchForbiddenScope assertNoEventDispatch;
-    ScriptForbiddenScope forbidScript;
-
+#if DCHECK_IS_ON()
+    DCHECK(EventDispatchForbiddenScope::isEventDispatchForbidden());
+#endif
+    DCHECK(ScriptForbiddenScope::isScriptForbidden());
     DCHECK(!newChild.parentNode()); // Use insertBefore if you need to handle reparenting (and want DOM mutation events).
     DCHECK(!newChild.nextSibling());
     DCHECK(!newChild.previousSibling());
     DCHECK(!newChild.isShadowRoot());
 
     Node* prev = nextChild.previousSibling();
     DCHECK_NE(m_lastChild, prev);
     nextChild.setPreviousSibling(&newChild);
     if (prev) {
         DCHECK_NE(firstChild(), nextChild);
         DCHECK_EQ(prev->nextSibling(), nextChild);
         prev->setNextSibling(&newChild);
     } else {
         DCHECK(firstChild() == nextChild);
         m_firstChild = &newChild;
     }
     newChild.setParentOrShadowHostNode(this);
     newChild.setPreviousSibling(prev);
     newChild.setNextSibling(&nextChild);
 }
 
 void ContainerNode::appendChildCommon(Node& child)
 {
+#if DCHECK_IS_ON()
+    DCHECK(EventDispatchForbiddenScope::isEventDispatchForbidden());
+#endif
+    DCHECK(ScriptForbiddenScope::isScriptForbidden());
+
     child.setParentOrShadowHostNode(this);
-
     if (m_lastChild) {
         child.setPreviousSibling(m_lastChild);
         m_lastChild->setNextSibling(&child);
     } else {
         setFirstChild(&child);
     }
-
     setLastChild(&child);
 }
 
 bool ContainerNode::checkParserAcceptChild(const Node& newChild) const
 {
     if (!isDocumentNode())
         return true;
     // TODO(esprehn): Are there other conditions where the parser can create
     // invalid trees?
     return toDocument(*this).canAcceptChild(newChild, nullptr, IGNORE_EXCEPTION);
@@ skipping 21 matching lines @@
     if (nextChild.parentNode() != this)
         return;
 
     if (document() != newChild->document())
         document().adoptNode(newChild, ASSERT_NO_EXCEPTION);
 
     {
         EventDispatchForbiddenScope assertNoEventDispatch;
         ScriptForbiddenScope forbidScript;
 
-        treeScope().adoptIfNeeded(*newChild);
-        insertBeforeCommon(nextChild, *newChild);
+        AdoptAndInsertBefore()(*this, *newChild, &nextChild);
         DCHECK_EQ(newChild->connectedSubframeCount(), 0u);
         ChildListMutationScope(*this).childAdded(*newChild);
     }
 
     notifyNodeInserted(*newChild, ChildrenChangeSourceParser);
 }
 
 Node* ContainerNode::replaceChild(Node* newChild, Node* oldChild, ExceptionState& exceptionState)
 {
     if (oldChild == newChild) // Nothing to do.
         return oldChild;
 
     if (!oldChild) {
         exceptionState.throwDOMException(NotFoundError, "The node to be replaced is null.");
         return nullptr;
     }
 
-    Node* child = oldChild;
-
     // Make sure replacing the old child with the new is OK.
-    if (!checkAcceptChild(newChild, child, exceptionState)) {
-        if (exceptionState.hadException())
-            return nullptr;
-        return child;
-    }
+    if (!checkAcceptChild(newChild, oldChild, exceptionState))
+        return oldChild;
 
     // NotFoundError: Raised if oldChild is not a child of this node.
-    if (child->parentNode() != this) {
+    if (oldChild->parentNode() != this) {
         exceptionState.throwDOMException(NotFoundError, "The node to be replaced is not a child of this node.");
         return nullptr;
     }
 
     ChildListMutationScope mutation(*this);
-
-    Node* next = child->nextSibling();
+    Node* next = oldChild->nextSibling();
 
     // Remove the node we're replacing.
-    removeChild(child, exceptionState);
+    removeChild(oldChild, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
     if (next && (next->previousSibling() == newChild || next == newChild)) // nothing to do
-        return child;
+        return oldChild;
 
     // Does this one more time because removeChild() fires a MutationEvent.
-    if (!checkAcceptChild(newChild, child, exceptionState)) {
-        if (exceptionState.hadException())
-            return nullptr;
-        return child;
-    }
+    if (!checkAcceptChild(newChild, oldChild, exceptionState))
+        return oldChild;
 
     NodeVector targets;
-    collectChildrenAndRemoveFromOldParentWithCheck(next, child, *newChild, targets, exceptionState);
-    if (exceptionState.hadException())
-        return nullptr;
-    if (targets.isEmpty())
-        return child;
+    if (!collectChildrenAndRemoveFromOldParentWithCheck(next, oldChild, *newChild, targets, exceptionState))
+        return oldChild;
 
     if (next)
         insertNodeVector(targets, next, AdoptAndInsertBefore());
     else
         insertNodeVector(targets, nullptr, AdoptAndAppendChild());
-    return child;
+    return oldChild;
 }
 
 void ContainerNode::willRemoveChild(Node& child)
 {
     DCHECK_EQ(child.parentNode(), this);
     ChildListMutationScope(*this).willRemoveChild(child);
     child.notifyMutationObserversNodeWillDetach();
     dispatchChildRemovalEvents(child);
     ChildFrameDisconnector(child).disconnect();
     if (document() != child.document()) {
@@ skipping 180 matching lines @@
         ChildrenChange change = {AllChildrenRemoved, nullptr, nullptr, nullptr, ChildrenChangeSourceAPI};
         childrenChanged(change);
     }
 
     if (action == DispatchSubtreeModifiedEvent)
         dispatchSubtreeModifiedEvent();
 }
 
 Node* ContainerNode::appendChild(Node* newChild, ExceptionState& exceptionState)
 {
-
     // Make sure adding the new child is ok
-    if (!checkAcceptChild(newChild, 0, exceptionState)) {
-        if (exceptionState.hadException())
-            return nullptr;
+    if (!checkAcceptChild(newChild, 0, exceptionState))
         return newChild;
-    }
     DCHECK(newChild);
 
     if (newChild == m_lastChild) // nothing to do
         return newChild;
 
     NodeVector targets;
-    collectChildrenAndRemoveFromOldParentWithCheck(nullptr, nullptr, *newChild, targets, exceptionState);
-    if (exceptionState.hadException())
-        return nullptr;
-    if (targets.isEmpty())
+    if (!collectChildrenAndRemoveFromOldParentWithCheck(nullptr, nullptr, *newChild, targets, exceptionState))
         return newChild;
 
     ChildListMutationScope mutation(*this);
     insertNodeVector(targets, nullptr, AdoptAndAppendChild());
     return newChild;
 }
 
 void ContainerNode::parserAppendChild(Node* newChild)
 {
     DCHECK(newChild);
     DCHECK(!newChild->isDocumentFragment());
     DCHECK(!isHTMLTemplateElement(this));
 
     if (!checkParserAcceptChild(*newChild))
         return;
 
     // FIXME: parserRemoveChild can run script which could then insert the
     // newChild back into the page. Loop until the child is actually removed.
     // See: fast/parser/execute-script-during-adoption-agency-removal.html
     while (ContainerNode* parent = newChild->parentNode())
         parent->parserRemoveChild(*newChild);
 
     if (document() != newChild->document())
         document().adoptNode(newChild, ASSERT_NO_EXCEPTION);
 
     {
         EventDispatchForbiddenScope assertNoEventDispatch;
         ScriptForbiddenScope forbidScript;
 
-        treeScope().adoptIfNeeded(*newChild);
-        appendChildCommon(*newChild);
+        AdoptAndAppendChild()(*this, *newChild, nullptr);
         DCHECK_EQ(newChild->connectedSubframeCount(), 0u);
         ChildListMutationScope(*this).childAdded(*newChild);
     }
 
     notifyNodeInserted(*newChild, ChildrenChangeSourceParser);
 }
 
 DISABLE_CFI_PERF
 void ContainerNode::notifyNodeInserted(Node& root, ChildrenChangeSource source)
 {
@@ skipping 412 matching lines @@
 }
 
 HTMLCollection* ContainerNode::children()
 {
     return ensureCachedCollection<HTMLCollection>(NodeChildren);
 }
 
 unsigned ContainerNode::countChildren() const
 {
     unsigned count = 0;
-    Node* n;
-    for (n = firstChild(); n; n = n->nextSibling())
+    for (Node* node = firstChild(); node; node = node->nextSibling())
         count++;
     return count;
 }
 
 Element* ContainerNode::querySelector(const AtomicString& selectors, ExceptionState& exceptionState)
 {
     if (selectors.isEmpty()) {
         exceptionState.throwDOMException(SyntaxError, "The provided selector is empty.");
         return nullptr;
     }
@@ skipping 267 matching lines @@
         return true;
 
     if (node->isElementNode() && toElement(node)->shadow())
         return true;
 
     return false;
 }
 #endif
 
 } // namespace blink