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 363 matching lines @@
     LayoutObject* renderer = 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 = renderer;
     clearFlag(HasRareDataFlag);
 }
 #endif
 
+PassRefPtr<Node> Node::mutationMethodMacro(const Vector<NodeOrString>& nodes, ExceptionState& exceptionState)

[philipj_slow, 2015/04/29 13:16:57]

If I'm not mistaken, this should be PassRefPtrWillBeRawPtr<Node>, and the below
should be RefPtrWillBeRawPtr<Node>. If in doubt, compile with enable_oilpan=1 in
GYP_DEFINES.

[Paritosh Kumar, 2015/06/08 12:21:24]

Yes, This will be PassRefPtrWillBeRawPtr<Node> and RefPtrWillBeRawPtr<Node>.
Ohh, great. Thanks.

+{
+    RefPtr<Node> node;
+    if (nodes.size() == 1) {
+        if (nodes[0].isNode())
+            node = nodes[0].getAsNode();
+        else if (nodes[0].isString())
+            node = Text::create(document(), nodes[0].getAsString());
+        else
+            return nullptr;

[philipj_slow, 2015/04/29 13:16:57]

This case should be unreachable.

[Paritosh Kumar, 2015/06/08 12:21:24]

Yes, Removing it.

+    } else {
+        node = DocumentFragment::create(document());

[philipj_slow, 2015/04/29 13:16:57]

This is what the spec says, but implementing it like this means that any
multi-argument call like elm.append(node1, node2) will create an unnecessary
DocumentFragment object, which seems unfortunate. Did you look into how much
work it would be to avoid this? Maybe collectChildrenAndRemoveFromOldParent
would come in handy.

[Paritosh Kumar, 2015/06/08 12:21:24]

I looked into this and found that we may use
collectChildrenAndRemoveFromOldParent as in insertBefore. But, our 
mutationMethodMacro will do only convertion of DOMString to Text Node.

+        for (size_t i = 0; i < nodes.size(); ++i) {

[philipj_slow, 2015/04/29 13:16:57]

Will a range-based for loop work here? for (NodeOrString& nodeOrString : nodes)

[Paritosh Kumar, 2015/06/08 12:21:24]

Yes, Done.

+            if (nodes[i].isNode())
+                node->appendChild(nodes[i].getAsNode(), exceptionState);
+            else
+                node->appendChild(Text::create(document(), nodes[i].getAsString()), exceptionState);
+            if (exceptionState.hadException()) {
+                exceptionState.throwIfNeeded();

[philipj_slow, 2015/04/29 13:16:57]

This looks unusual, why throwIfNeeded() here? If will boil down to just
exceptionState.throwException(), which I also kind used anywhere in core.

[Paritosh Kumar, 2015/06/08 12:21:24]

Done.

+                return nullptr;
+            }
+        }
+    }
+    return node.release();
+}
+

[philipj_slow, 2015/04/29 13:16:57]

There's an extra blank line here.

[Paritosh Kumar, 2015/06/08 12:21:24]

Done.

+
 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 Vector<NodeOrString>& nodes, ExceptionState& exceptionState)
+{
+    RefPtr<Node> nodeToPrepend = mutationMethodMacro(nodes, exceptionState);

[philipj_slow, 2015/04/29 13:16:57]

All of these will also need to use the Oilpan transitional types.

[Paritosh Kumar, 2015/06/08 12:21:24]

Done.

+    this->insertBefore(nodeToPrepend, this->firstChild(), exceptionState);

[philipj_slow, 2015/04/29 13:16:57]

In the spec none of these are expressed in terms of the other Web-exposed
methods but internals like https://dom.spec.whatwg.org/#concept-node-pre-insert
in this case. If one looks at the spec one finds that it's equivalent, but it's
nice when the implementation just does exactly what the spec says.

I don't think this CL is a good place to do that refactoring, but if you
annotate everything with spec links and spec steps, it will be more obvious that
the use of insertBefore is intentional. Something like:

// https://dom.spec.whatwg.org/#dom-parentnode-prependnodes
// 1. Run the mutation method macro.
RefPtrWillBeRawPtr<Node> nodeToPrepend = mutationMethodMacro(nodes,
exceptionState);
// 2. Pre-insert |node| into the context object before the context object’s
first child.
this->insertBefore(nodeToPrepend, this->firstChild(), exceptionState);

+}
+
+void Node::append(const Vector<NodeOrString>& nodes, ExceptionState& exceptionState)
+{
+    RefPtr<Node> nodeToAppend = mutationMethodMacro(nodes, exceptionState);
+    this->appendChild(nodeToAppend, exceptionState);
+}
+
+void Node::before(const Vector<NodeOrString>& nodes, ExceptionState& exceptionState)
+{
+    Node* parent = parentNode();
+    if (!parent)
+        return;
+    RefPtr<Node> nodeToInsert = mutationMethodMacro(nodes, exceptionState);
+    parent->insertBefore(nodeToInsert, this, exceptionState);
+}
+
+void Node::after(const Vector<NodeOrString>& nodes, ExceptionState& exceptionState)
+{
+    Node* parent = parentNode();
+    if (!parent)
+        return;
+    RefPtr<Node> nodeToInsert = mutationMethodMacro(nodes, exceptionState);
+    parent->insertBefore(nodeToInsert, this->nextSibling(), exceptionState);
+}
+
+void Node::replaceWith(const Vector<NodeOrString>& nodes, ExceptionState& exceptionState)
+{
+    Node* parent = parentNode();
+    if (!parent)
+        return;
+    RefPtr<Node> nodeToReplaceWith = mutationMethodMacro(nodes, exceptionState);
+    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 @@
         node->showTreeForThis();
 }
 
 void showNodePath(const blink::Node* node)
 {
     if (node)
         node->showNodePathForThis();
 }
 
 #endif