Merge the Sky Engine changes from the SkyDart branch

sky/engine/core/dom/ContainerNode.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, 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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "sky/engine/config.h"
 #include "sky/engine/core/dom/ContainerNode.h"
 
-#include "sky/engine/bindings/core/v8/ExceptionState.h"
+#include "sky/engine/bindings2/exception_state.h"
 #include "sky/engine/core/dom/ChildListMutationScope.h"
 #include "sky/engine/core/dom/ElementTraversal.h"
 #include "sky/engine/core/dom/ExceptionCode.h"
 #include "sky/engine/core/dom/NodeRareData.h"
 #include "sky/engine/core/dom/NodeRenderStyle.h"
 #include "sky/engine/core/dom/NodeTraversal.h"
 #include "sky/engine/core/dom/SelectorQuery.h"
 #include "sky/engine/core/dom/StaticNodeList.h"
 #include "sky/engine/core/dom/StyleEngine.h"
 #include "sky/engine/core/dom/shadow/ElementShadow.h"
@@ skipping 39 matching lines @@
 bool ContainerNode::containsConsideringHostElements(const Node& newChild) const
 {
     if (isInShadowTree() || document().isTemplateDocument())
         return newChild.containsIncludingHostElements(*this);
     return newChild.contains(this);
 }
 
 void ContainerNode::checkAcceptChildType(const Node* newChild, ExceptionState& exceptionState) const
 {
     if (!newChild) {
-        exceptionState.throwDOMException(NotFoundError, "The new child element is null.");
+        exceptionState.ThrowDOMException(NotFoundError, "The new child element is null.");
         return;
     }
 
     if (newChild->isTreeScope()) {
-        exceptionState.throwDOMException(HierarchyRequestError, "Nodes of type '" + newChild->nodeName() + "' may not be inserted inside nodes of type '" + nodeName() + "'.");
+        exceptionState.ThrowDOMException(HierarchyRequestError, "Nodes of type '" + newChild->nodeName() + "' may not be inserted inside nodes of type '" + nodeName() + "'.");
         return;
     }
 }
 
 void ContainerNode::checkAcceptChildHierarchy(const Node& newChild, const Node* oldChild, ExceptionState& exceptionState) const
 {
     if (containsConsideringHostElements(newChild)) {
-        exceptionState.throwDOMException(HierarchyRequestError, "The new child element contains the parent.");
+        exceptionState.ThrowDOMException(HierarchyRequestError, "The new child element contains the parent.");
         return;
     }
 
     // TODO(esprehn): Remove this, sky should allow multiple top level elements.
     if (isDocumentNode()) {
         unsigned elementCount = 0;
         if (newChild.isElementNode()) {
             elementCount = 1;
         } else if (newChild.isDocumentFragment()) {
             for (Element* element = ElementTraversal::firstChild(newChild); element; element = ElementTraversal::nextSibling(*element))
                 ++elementCount;
         }
         if (elementCount > 1 || ((!oldChild || !oldChild->isElementNode()) && elementCount && document().documentElement())) {
-            exceptionState.throwDOMException(HierarchyRequestError, "Document can only contain one Element.");
+            exceptionState.ThrowDOMException(HierarchyRequestError, "Document can only contain one Element.");
             return;
         }
     }
 }
 
 PassRefPtr<Node> ContainerNode::insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionState& exceptionState)
 {
     // Check that this node is not "floating".
     // If it is, it can be deleted as a side effect of sending mutation events.
     ASSERT(refCount() || parentOrShadowHostNode());
 
     RefPtr<Node> protect(this);
 
     // insertBefore(node, 0) is equivalent to appendChild(node)
     if (!refChild) {
         return appendChild(newChild, exceptionState);
     }
 
     checkAcceptChildType(newChild.get(), exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return nullptr;
 
     checkAcceptChildHierarchy(*newChild, 0, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return nullptr;
 
     ASSERT(newChild);
 
     // NotFoundError: Raised if refChild is not a child of this node
     if (refChild->parentNode() != this) {
-        exceptionState.throwDOMException(NotFoundError, "The node before which the new node is to be inserted is not a child of this node.");
+        exceptionState.ThrowDOMException(NotFoundError, "The node before which the new node is to be inserted is not a child of this node.");
         return nullptr;
     }
 
     // nothing to do
     if (refChild->previousSibling() == newChild || refChild == newChild)
         return newChild;
 
     RefPtr<Node> next = refChild;
 
     NodeVector targets;
     collectChildrenAndRemoveFromOldParent(*newChild, targets, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return nullptr;
     if (targets.isEmpty())
         return newChild;
 
     // Must check this again beacuse focus events might run synchronously when
     // removing children.
     checkAcceptChildHierarchy(*newChild, 0, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return nullptr;
 
     ChildListMutationScope mutation(*this);
     for (NodeVector::const_iterator it = targets.begin(); it != targets.end(); ++it) {
         ASSERT(*it);
         Node& child = **it;
 
         // Due to arbitrary code running in response to a DOM mutation event it's
         // possible that "next" is no longer a child of "this".
         // It's also possible that "child" has been inserted elsewhere.
@@ skipping 58 matching lines @@
     // Check that this node is not "floating".
     // If it is, it can be deleted as a side effect of sending mutation events.
     ASSERT(refCount() || parentOrShadowHostNode());
 
     RefPtr<Node> protect(this);
 
     if (oldChild == newChild) // nothing to do
         return oldChild;
 
     if (!oldChild) {
-        exceptionState.throwDOMException(NotFoundError, "The node to be replaced is null.");
+        exceptionState.ThrowDOMException(NotFoundError, "The node to be replaced is null.");
         return nullptr;
     }
 
     RefPtr<Node> child = oldChild;
 
     checkAcceptChildType(newChild.get(), exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return nullptr;
 
     checkAcceptChildHierarchy(*newChild, child.get(), exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return nullptr;
 
     // NotFoundError: Raised if oldChild is not a child of this node.
     if (child->parentNode() != this) {
-        exceptionState.throwDOMException(NotFoundError, "The node to be replaced is not a child of this node.");
+        exceptionState.ThrowDOMException(NotFoundError, "The node to be replaced is not a child of this node.");
         return nullptr;
     }
 
     ChildListMutationScope mutation(*this);
 
     RefPtr<Node> next = child->nextSibling();
 
     // Remove the node we're replacing
     removeChild(child, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return nullptr;
 
     if (next && (next->previousSibling() == newChild || next == newChild)) // nothing to do
         return child;
 
     NodeVector targets;
     collectChildrenAndRemoveFromOldParent(*newChild, targets, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return nullptr;
 
     // Must check this again beacuse focus events might run synchronously when
     // removing children.
     checkAcceptChildHierarchy(*newChild, child.get(),exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return nullptr;
 
     // Add the new child(ren)
     for (NodeVector::const_iterator it = targets.begin(); it != targets.end(); ++it) {
         ASSERT(*it);
         Node& child = **it;
 
         // Due to arbitrary code running in response to a DOM mutation event it's
         // possible that "next" is no longer a child of "this".
         // It's also possible that "child" has been inserted elsewhere.
@@ skipping 113 matching lines @@
     ASSERT(refCount() || parentOrShadowHostNode());
 
     RefPtr<Node> protect(this);
     RefPtr<Node> child = oldChild;
 
     document().removeFocusedElementOfSubtree(child.get());
 
     // Events fired when blurring currently focused node might have moved this
     // child into a different parent.
     if (child->parentNode() != this) {
-        exceptionState.throwDOMException(NotFoundError, "The node to be removed is no longer a child of this node. Perhaps it was moved in a 'blur' event handler?");
+        exceptionState.ThrowDOMException(NotFoundError, "The node to be removed is no longer a child of this node. Perhaps it was moved in a 'blur' event handler?");
         return nullptr;
     }
 
     willRemoveChild(*child);
 
     // Mutation events might have moved this child into a different parent.
     if (child->parentNode() != this) {
-        exceptionState.throwDOMException(NotFoundError, "The node to be removed is no longer a child of this node. Perhaps it was moved in response to a mutation?");
+        exceptionState.ThrowDOMException(NotFoundError, "The node to be removed is no longer a child of this node. Perhaps it was moved in response to a mutation?");
         return nullptr;
     }
 
     Node* prev = child->previousSibling();
     Node* next = child->nextSibling();
     removeBetween(prev, next, *child);
     notifyNodeRemoved(*child);
     childrenChanged(ChildrenChange::forRemoval(*child, ChildrenChangeSourceAPI));
 
     return child;
@@ skipping 74 matching lines @@
 
 PassRefPtr<Node> ContainerNode::appendChild(PassRefPtr<Node> newChild, ExceptionState& exceptionState)
 {
     RefPtr<ContainerNode> protect(this);
 
     // Check that this node is not "floating".
     // If it is, it can be deleted as a side effect of sending mutation events.
     ASSERT(refCount() || parentOrShadowHostNode());
 
     checkAcceptChildType(newChild.get(), exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return nullptr;
 
     checkAcceptChildHierarchy(*newChild, 0, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return nullptr;
 
     ASSERT(newChild);
 
     if (newChild == m_lastChild) // nothing to do
         return newChild;
 
     NodeVector targets;
     collectChildrenAndRemoveFromOldParent(*newChild, targets, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return nullptr;
 
     if (targets.isEmpty())
         return newChild;
 
     // Must check this again beacuse focus events might run synchronously when
     // removing children.
     checkAcceptChildHierarchy(*newChild, 0, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return nullptr;
 
     // Now actually add the child(ren)
     ChildListMutationScope mutation(*this);
     for (NodeVector::const_iterator it = targets.begin(); it != targets.end(); ++it) {
         ASSERT(*it);
         Node& child = **it;
 
         // If the child has a parent again, just stop what we're doing, because
         // that means someone is doing something with DOM mutation -- can't re-parent
@@ skipping 105 matching lines @@
         document().updateRangesAfterChildrenChanged(this);
     if (change.isChildInsertion() && !childNeedsStyleRecalc()) {
         setChildNeedsStyleRecalc();
         markAncestorsWithChildNeedsStyleRecalc();
     }
 }
 
 void ContainerNode::cloneChildNodes(ContainerNode *clone)
 {
     TrackExceptionState exceptionState;
-    for (Node* n = firstChild(); n && !exceptionState.hadException(); n = n->nextSibling())
+    for (Node* n = firstChild(); n && !exceptionState.had_exception(); n = n->nextSibling())
         clone->appendChild(n->cloneNode(true), exceptionState);
 }
 
 
 bool ContainerNode::getUpperLeftCorner(FloatPoint& point) const
 {
     if (!renderer())
         return false;
     // What is this code really trying to do?
     RenderObject* o = renderer();
@@ skipping 194 matching lines @@
     unsigned count = 0;
     Node *n;
     for (n = firstChild(); n; n = n->nextSibling())
         count++;
     return count;
 }
 
 PassRefPtr<Element> ContainerNode::querySelector(const AtomicString& selectors, ExceptionState& exceptionState)
 {
     if (selectors.isEmpty()) {
-        exceptionState.throwDOMException(SyntaxError, "The provided selector is empty.");
+        exceptionState.ThrowDOMException(SyntaxError, "The provided selector is empty.");
         return nullptr;
     }
 
     SelectorQuery* selectorQuery = document().selectorQueryCache().add(selectors, document(), exceptionState);
     if (!selectorQuery)
         return nullptr;
     return selectorQuery->queryFirst(*this);
 }
 
 PassRefPtr<StaticElementList> ContainerNode::querySelectorAll(const AtomicString& selectors, ExceptionState& exceptionState)
 {
     if (selectors.isEmpty()) {
-        exceptionState.throwDOMException(SyntaxError, "The provided selector is empty.");
+        exceptionState.ThrowDOMException(SyntaxError, "The provided selector is empty.");
         return nullptr;
     }
 
     SelectorQuery* selectorQuery = document().selectorQueryCache().add(selectors, document(), exceptionState);
     if (!selectorQuery)
         return nullptr;
 
     return selectorQuery->queryAll(*this);
 }
 
@@ skipping 37 matching lines @@
         return true;
 
     if (node->isElementNode() && toElement(node)->shadow())
         return true;
 
     return false;
 }
 #endif
 
 } // namespace blink