Morph the APIs for Node, ParentNode, and Element closer to the specs

sky/engine/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 361 matching lines @@
 
 PassRefPtr<Node> Node::appendChild(PassRefPtr<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;
 }
 
+Element* Node::previousElementSibling()
+{
+    return ElementTraversal::previousSibling(*this);
+}
+
+Element* Node::nextElementSibling()
+{
+    return ElementTraversal::nextSibling(*this);
+}
+
+void Node::newInsertBefore(Vector<RefPtr<Node>>& nodes, ExceptionState& es)
+{
+    RefPtr<Node> protect(this);
+    for (auto& node : nodes) {
+        ContainerNode* parent = parentNode();
+        if (!parent)
+            return;
+        parent->insertBefore(node.release(), this, es);
+        if (es.had_exception())
+            return;
+    }
+}
+
+void Node::newInsertAfter(Vector<RefPtr<Node>>& nodes, ExceptionState& es)
+{
+    RefPtr<Node> refNode = this;
+    for (auto& node : nodes) {

[eseidel, 2015/02/14 00:12:23]

Living the dream.

+        ContainerNode* parent = refNode->parentNode();
+        if (!parent)
+            return;
+        parent->insertBefore(node, refNode.get(), es);
+        if (es.had_exception())
+            return;
+        refNode = node.release();

[esprehn, 2015/02/13 23:53:48]

This doesn't look right, why are you reffing and then dropping each new node as
you go? You need to ref yourself, not each child as you insert them.

[abarth-chromium, 2015/02/13 23:59:45]

The question is how should this code behave if there are tree mutations inside
this loop.  There are a couple of different semantics you could choose.  This
one always inserts the next element in the list after the previous one, even if
you move the previous one to some other crazy place.  Another approach would be
to walk the list backwards and always insert after |this| even if |this| moved
somewhere else, but we thought it was more sensible to insert the elements in
the order given.

[esprehn, 2015/02/14 01:09:25]

There can't be mutations inside this loop.

[abarth-chromium, 2015/02/14 01:28:26]

Ok, I'll change this to ASSERT that.

+    }
+}
+
+void Node::replaceWith(Vector<RefPtr<Node>>& nodes, ExceptionState& es)
+{
+    if (RefPtr<Node> next = m_next) {
+        remove(es);
+        if (es.had_exception())
+            return;
+        next->newInsertBefore(nodes, es);
+    } else if (RefPtr<ContainerNode> parent = parentNode()) {
+        remove(es);
+        if (es.had_exception())
+            return;
+        parent->append(nodes, es);

[esprehn, 2015/02/13 23:53:48]

You don't need this branch, we can just call insertBefore with null for the next
sibling.

[abarth-chromium, 2015/02/13 23:59:45]

I don't follow.  Which function would you like me to call if |m_next| is null?

[esprehn, 2015/02/14 01:09:24]

Just always call

RefPtr<Node> next = m_next;
remove();
parent()->insertBefore(this, m_next);

[abarth-chromium, 2015/02/14 01:28:26]

That doesn't work because |this| isn't a child of |parent| anymore because
|this| is removed on the previous line.

+    }
+}
+
 void Node::remove(ExceptionState& exceptionState)
 {
     if (ContainerNode* parent = parentNode())
         parent->removeChild(this, exceptionState);
 }
 
 const AtomicString& Node::localName() const
 {
     return nullAtom;
 }
@@ skipping 463 matching lines @@
 }
 
 // FIXME: End of obviously misplaced HTML editing functions.  Try to move these out of Node.
 
 Document* Node::ownerDocument() const
 {
     Document* doc = &document();
     return doc == this ? 0 : doc;
 }
 
-ContainerNode* Node::ownerScope() const
+ContainerNode* Node::owner() const
 {
     if (inDocument())
         return &treeScope().rootNode();
     if (ShadowRoot* root = containingShadowRoot())
         return root;
     return 0;
 }
 
 String Node::textContent() const
 {
@@ skipping 734 matching lines @@
         node->showTreeForThis();
 }
 
 void showNodePath(const blink::Node* node)
 {
     if (node)
         node->showNodePathForThis();
 }
 
 #endif