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

sky/engine/core/dom/ContainerNode.h

 /*
  * 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, 2009, 2010, 2011, 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 25 matching lines @@
 template <typename NodeType> class StaticNodeTypeList;
 typedef StaticNodeTypeList<Element> StaticElementList;
 
 // This constant controls how much buffer is initially allocated
 // for a Node Vector that is used to store child Nodes of a given Node.
 // FIXME: Optimize the value.
 const int initialNodeVectorSize = 11;
 typedef Vector<RefPtr<Node>, initialNodeVectorSize> NodeVector;
 
 class ContainerNode : public Node {
+    DEFINE_WRAPPERTYPEINFO();
 public:
     virtual ~ContainerNode();
 
     Node* firstChild() const { return m_firstChild; }
     Node* lastChild() const { return m_lastChild; }
     bool hasChildren() const { return m_firstChild; }
 
+    Element* firstElementChild() const;

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

So now ContainerNode knows about its subclass Element? :/

+    Element* lastElementChild() const;
+
+    Vector<RefPtr<Node>> getChildNodes() const;

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

Are you sure you want to copy the vector? :)

+    Vector<RefPtr<Element>> getChildElements() const;
+
+    // These functions release the nodes from |nodes|.
+    void append(Vector<RefPtr<Node>>& nodes, ExceptionState&);

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

Another way to do this would be to use a PassOwnPtr<Vector>.  We could also use
an ImplmentedAs=takeFromAndAppend or similar if we wanted to make the c++ naming
more clear.

+    void prepend(Vector<RefPtr<Node>>& nodes, ExceptionState&);
+    PassRefPtr<Node> prependChild(PassRefPtr<Node> node, ExceptionState&);
+
+    void removeChildren();
+    PassRefPtr<Node> setChild(PassRefPtr<Node> node, ExceptionState&);
+    void setChildren(Vector<RefPtr<Node>>& nodes, ExceptionState&);
+
     bool hasOneChild() const { return m_firstChild && !m_firstChild->nextSibling(); }
     bool hasOneTextChild() const { return hasOneChild() && m_firstChild->isTextNode(); }
 
     unsigned countChildren() const;
 
     PassRefPtr<Element> querySelector(const AtomicString& selectors, ExceptionState&);
     PassRefPtr<StaticElementList> querySelectorAll(const AtomicString& selectors, ExceptionState&);
 
     PassRefPtr<Node> insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionState& = ASSERT_NO_EXCEPTION);
     PassRefPtr<Node> replaceChild(PassRefPtr<Node> newChild, PassRefPtr<Node> oldChild, ExceptionState& = ASSERT_NO_EXCEPTION);
     PassRefPtr<Node> removeChild(PassRefPtr<Node> child, ExceptionState& = ASSERT_NO_EXCEPTION);
     PassRefPtr<Node> appendChild(PassRefPtr<Node> newChild, ExceptionState& = ASSERT_NO_EXCEPTION);
 
     Element* getElementById(const AtomicString& id) const;
 
     // These methods are only used during parsing.
     // They don't send DOM mutation events or handle reparenting.
     void parserAppendChild(PassRefPtr<Node>);
 
-    void removeChildren();
 
     void cloneChildNodes(ContainerNode* clone);
 
     virtual void attach(const AttachContext& = AttachContext()) override;
     virtual void detach(const AttachContext& = AttachContext()) override;
     virtual LayoutRect boundingBox() const override final;
     virtual void setFocus(bool) override;
     void focusStateChanged();
     virtual void setActive(bool = true) override;
     virtual void setHovered(bool = true) override;
@@ skipping 126 matching lines @@
     if (!isContainerNode())
         return 0;
     return toContainerNode(this)->lastChild();
 }
 
 inline bool Node::isTreeScope() const
 {
     return &treeScope().rootNode() == this;
 }
 
-inline void getChildNodes(ContainerNode& node, NodeVector& nodes)
+inline void appendChildNodes(ContainerNode& node, NodeVector& nodes)
 {
     ASSERT(!nodes.size());
     for (Node* child = node.firstChild(); child; child = child->nextSibling())
         nodes.append(child);
 }
 
 } // namespace blink
 
 #endif  // SKY_ENGINE_CORE_DOM_CONTAINERNODE_H_