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 483 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;
 }
 
+static bool isNodeInNodes(const Node& node, const HeapVector<NodeOrString>& nodes)
+{
+    for (const NodeOrString& nodeOrString : nodes) {
+        if (nodeOrString.isNode() && nodeOrString.getAsNode() == &node)
+            return true;
+    }
+    return false;
+}
+
+static Node* findViablePreviousSibling(const Node& node, const HeapVector<NodeOrString>& nodes)
+{
+    for (Node* sibling = node.previousSibling(); sibling; sibling = sibling->previousSibling()) {
+        if (!isNodeInNodes(*sibling, nodes))
+            return sibling;
+    }
+    return nullptr;
+}
+
+static Node* findViableNextSibling(const Node& node, const HeapVector<NodeOrString>& nodes)
+{
+    for (Node* sibling = node.nextSibling(); sibling; sibling = sibling->nextSibling()) {
+        if (!isNodeInNodes(*sibling, nodes))
+            return sibling;
+    }
+    return nullptr;
+}
+
+static PassRefPtrWillBeRawPtr<Node> nodeOrStringToNode(const NodeOrString& nodeOrString, Document& document)
+{
+    if (nodeOrString.isNode())
+        return nodeOrString.getAsNode();
+    return Text::create(document, nodeOrString.getAsString());
+}
+
+static PassRefPtrWillBeRawPtr<Node> convertNodesIntoNode(const HeapVector<NodeOrString>& nodes, Document& document)
+{
+    if (nodes.size() == 1)
+        return nodeOrStringToNode(nodes[0], document);
+
+    RefPtrWillBeRawPtr<Node> fragment = DocumentFragment::create(document);
+    for (const NodeOrString& nodeOrString : nodes)
+        fragment->appendChild(nodeOrStringToNode(nodeOrString, document), ASSERT_NO_EXCEPTION);
+    return fragment.release();
+}
+
+void Node::prepend(const HeapVector<NodeOrString>& nodes, ExceptionState& exceptionState)
+{
+    insertBefore(convertNodesIntoNode(nodes, document()), firstChild(), exceptionState);
+}
+
+void Node::append(const HeapVector<NodeOrString>& nodes, ExceptionState& exceptionState)
+{
+    appendChild(convertNodesIntoNode(nodes, document()), exceptionState);
+}
+
+void Node::before(const HeapVector<NodeOrString>& nodes, ExceptionState& exceptionState)
+{
+    Node* parent = parentNode();
+    if (!parent)
+        return;
+    Node* viablePreviousSibling = findViablePreviousSibling(*this, nodes);
+    parent->insertBefore(convertNodesIntoNode(nodes, document()), viablePreviousSibling ? viablePreviousSibling->nextSibling() : parent->firstChild(), exceptionState);
+}
+
+void Node::after(const HeapVector<NodeOrString>& nodes, ExceptionState& exceptionState)
+{
+    Node* parent = parentNode();
+    if (!parent)
+        return;
+    Node* viableNextSibling = findViableNextSibling(*this, nodes);
+    parent->insertBefore(convertNodesIntoNode(nodes, document()), viableNextSibling, exceptionState);
+}
+
+void Node::replaceWith(const HeapVector<NodeOrString>& nodes, ExceptionState& exceptionState)
+{
+    Node* parent = parentNode();
+    if (!parent)
+        return;
+    Node* viableNextSibling = findViableNextSibling(*this, nodes);
+    RefPtrWillBeRawPtr<Node> nodeToReplaceWith = convertNodesIntoNode(nodes, document());

[philipj_slow, 2015/07/03 21:52:06]

The node is either replaced with or inserted before, so just naming this "node"
like in the spec seems more accurate.

[Paritosh Kumar, 2015/07/06 09:02:27]

Replaced.

+    if (parent == parentNode())
+        parent->replaceChild(nodeToReplaceWith, this, exceptionState);
+    else
+        parent->insertBefore(nodeToReplaceWith, viableNextSibling, 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