Implement DOM: prepend, append, before, after & replaceWith

Source/core/dom/Node.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, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 364 matching lines @@
     LayoutObject* layoutObject = m_data.m_rareData->layoutObject();
     if (isElementNode())
         delete static_cast<ElementRareData*>(m_data.m_rareData);
     else
         delete static_cast<NodeRareData*>(m_data.m_rareData);
     m_data.m_layoutObject = layoutObject;
     clearFlag(HasRareDataFlag);
 }
 #endif
 
+PassRefPtrWillBeRawPtr<Node> Node::mutationMethodMacro(const HeapVector<NodeOrString>& nodes)
+{
+    RefPtrWillBeRawPtr<Node> node;
+    if (nodes.size() == 1) {

[philipj_slow, 2015/06/09 12:48:32]

If the bindings guarantees that nodes.size()!=0 here, please ASSERT it, as
otherwise one wonders if an empty DocumentFragment is the right thing for when
there are no arguments. Also make sure to test the zero-argument case.

[Paritosh Kumar, 2015/06/12 15:55:37]

Updated as per new specs.

+        if (nodes[0].isNode())
+            node = nodes[0].getAsNode();
+        else
+            node = Text::create(document(), nodes[0].getAsString());
+    } else {
+        node = DocumentFragment::create(document());
+        for (const NodeOrString& nodeOrString : nodes) {
+            if (nodeOrString.isNode())
+                node->appendChild(nodeOrString.getAsNode(), ASSERT_NO_EXCEPTION);
+            else
+                node->appendChild(Text::create(document(), nodeOrString.getAsString()), ASSERT_NO_EXCEPTION);
+        }
+    }
+    return node.release();
+}
+
 Node* Node::toNode()
 {
     return this;
 }
 
 short Node::tabIndex() const
 {
     return 0;
 }
 
@@ skipping 99 matching lines @@
 
 PassRefPtrWillBeRawPtr<Node> Node::appendChild(PassRefPtrWillBeRawPtr<Node> newChild, ExceptionState& exceptionState)
 {
     if (isContainerNode())
         return toContainerNode(this)->appendChild(newChild, exceptionState);
 
     exceptionState.throwDOMException(HierarchyRequestError, "This node type does not support this method.");
     return nullptr;
 }
 
+void Node::prepend(const HeapVector<NodeOrString>& nodes, ExceptionState& exceptionState)
+{
+    RefPtrWillBeRawPtr<Node> nodeToPrepend = mutationMethodMacro(nodes);
+    this->insertBefore(nodeToPrepend, this->firstChild(), exceptionState);
+}
+
+void Node::append(const HeapVector<NodeOrString>& nodes, ExceptionState& exceptionState)
+{
+    RefPtrWillBeRawPtr<Node> nodeToAppend = mutationMethodMacro(nodes);
+    this->appendChild(nodeToAppend, exceptionState);
+}
+
+void Node::before(const HeapVector<NodeOrString>& nodes, ExceptionState& exceptionState)
+{
+    Node* parent = parentNode();
+    if (!parent)
+        return;
+    RefPtrWillBeRawPtr<Node> nodeToInsert = mutationMethodMacro(nodes);
+    parent->insertBefore(nodeToInsert, this, exceptionState);
+}
+
+void Node::after(const HeapVector<NodeOrString>& nodes, ExceptionState& exceptionState)
+{
+    Node* parent = parentNode();
+    if (!parent)
+        return;
+    RefPtrWillBeRawPtr<Node> nodeToInsert = mutationMethodMacro(nodes);
+    parent->insertBefore(nodeToInsert, this->nextSibling(), exceptionState);
+}
+
+void Node::replaceWith(const HeapVector<NodeOrString>& nodes, ExceptionState& exceptionState)
+{
+    Node* parent = parentNode();
+    if (!parent)
+        return;
+    RefPtrWillBeRawPtr<Node> nodeToReplaceWith = mutationMethodMacro(nodes);
+    parent->replaceChild(nodeToReplaceWith, this, exceptionState);
+}
+
 void Node::remove(ExceptionState& exceptionState)
 {
     if (ContainerNode* parent = parentNode())
         parent->removeChild(this, exceptionState);
 }
 
 void Node::normalize()
 {
     updateDistribution();
 
@@ skipping 1988 matching lines @@
 
 void showNodePath(const blink::Node* node)
 {
     if (node)
         node->showNodePathForThis();
     else
         fprintf(stderr, "Cannot showNodePath for (nil)\n");
 }
 
 #endif