Merge the Sky Engine changes from the SkyDart branch

sky/engine/core/dom/Range.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Gunnstein Lye (gunnstein@netcom.no)
  * (C) 2000 Frederik Holljen (frederik.holljen@hig.no)
  * (C) 2001 Peter Kelly (pmk@post.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Motorola Mobility. 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/Range.h"
 
-#include "sky/engine/bindings/core/v8/ExceptionState.h"
+#include "sky/engine/bindings2/exception_state.h"
 #include "sky/engine/core/dom/ClientRect.h"
 #include "sky/engine/core/dom/ClientRectList.h"
 #include "sky/engine/core/dom/DocumentFragment.h"
 #include "sky/engine/core/dom/ExceptionCode.h"
 #include "sky/engine/core/dom/Node.h"
 #include "sky/engine/core/dom/NodeTraversal.h"
 #include "sky/engine/core/dom/NodeWithIndex.h"
 #include "sky/engine/core/dom/Text.h"
 #include "sky/engine/core/editing/TextIterator.h"
 #include "sky/engine/core/editing/VisiblePosition.h"
@@ skipping 105 matching lines @@
     Node* startRootContainer = start.container();
     while (startRootContainer->parentNode())
         startRootContainer = startRootContainer->parentNode();
 
     return startRootContainer != endRootContainer || (Range::compareBoundaryPoints(start, end, ASSERT_NO_EXCEPTION) > 0);
 }
 
 void Range::setStart(PassRefPtr<Node> refNode, int offset, ExceptionState& exceptionState)
 {
     if (!refNode) {
-        exceptionState.throwDOMException(NotFoundError, "The node provided was null.");
+        exceptionState.ThrowDOMException(NotFoundError, "The node provided was null.");
         return;
     }
 
     bool didMoveDocument = false;
     if (refNode->document() != m_ownerDocument) {
         setDocument(refNode->document());
         didMoveDocument = true;
     }
 
     Node* childNode = checkNodeWOffset(refNode.get(), offset, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return;
 
     m_start.set(refNode, offset, childNode);
 
     if (didMoveDocument || checkForDifferentRootContainer(m_start, m_end))
         collapse(true);
 }
 
 void Range::setEnd(PassRefPtr<Node> refNode, int offset, ExceptionState& exceptionState)
 {
     if (!refNode) {
-        exceptionState.throwDOMException(NotFoundError, "The node provided was null.");
+        exceptionState.ThrowDOMException(NotFoundError, "The node provided was null.");
         return;
     }
 
     bool didMoveDocument = false;
     if (refNode->document() != m_ownerDocument) {
         setDocument(refNode->document());
         didMoveDocument = true;
     }
 
     Node* childNode = checkNodeWOffset(refNode.get(), offset, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return;
 
     m_end.set(refNode, offset, childNode);
 
     if (didMoveDocument || checkForDifferentRootContainer(m_start, m_end))
         collapse(false);
 }
 
 void Range::setStart(const Position& start, ExceptionState& exceptionState)
 {
@@ skipping 11 matching lines @@
 {
     if (toStart)
         m_end = m_start;
     else
         m_start = m_end;
 }
 
 bool Range::isPointInRange(Node* refNode, int offset, ExceptionState& exceptionState)
 {
     if (!refNode) {
-        exceptionState.throwDOMException(HierarchyRequestError, "The node provided was null.");
+        exceptionState.ThrowDOMException(HierarchyRequestError, "The node provided was null.");
         return false;
     }
 
     if (!refNode->inActiveDocument() || refNode->document() != m_ownerDocument) {
         return false;
     }
 
     checkNodeWOffset(refNode, offset, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return false;
 
-    return compareBoundaryPoints(refNode, offset, m_start.container(), m_start.offset(), exceptionState) >= 0 && !exceptionState.hadException()
-        && compareBoundaryPoints(refNode, offset, m_end.container(), m_end.offset(), exceptionState) <= 0 && !exceptionState.hadException();
+    return compareBoundaryPoints(refNode, offset, m_start.container(), m_start.offset(), exceptionState) >= 0 && !exceptionState.had_exception()
+        && compareBoundaryPoints(refNode, offset, m_end.container(), m_end.offset(), exceptionState) <= 0 && !exceptionState.had_exception();
 }
 
 short Range::comparePoint(Node* refNode, int offset, ExceptionState& exceptionState) const
 {
     // http://developer.mozilla.org/en/docs/DOM:range.comparePoint
     // This method returns -1, 0 or 1 depending on if the point described by the
     // refNode node and an offset within the node is before, same as, or after the range respectively.
 
     if (!refNode->inActiveDocument()) {
-        exceptionState.throwDOMException(WrongDocumentError, "The node provided is not in an active document.");
+        exceptionState.ThrowDOMException(WrongDocumentError, "The node provided is not in an active document.");
         return 0;
     }
 
     if (refNode->document() != m_ownerDocument) {
-        exceptionState.throwDOMException(WrongDocumentError, "The node provided is not in this Range's Document.");
+        exceptionState.ThrowDOMException(WrongDocumentError, "The node provided is not in this Range's Document.");
         return 0;
     }
 
     checkNodeWOffset(refNode, offset, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return 0;
 
     // compare to start, and point comes before
     if (compareBoundaryPoints(refNode, offset, m_start.container(), m_start.offset(), exceptionState) < 0)
         return -1;
 
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return 0;
 
     // compare to end, and point comes after
-    if (compareBoundaryPoints(refNode, offset, m_end.container(), m_end.offset(), exceptionState) > 0 && !exceptionState.hadException())
+    if (compareBoundaryPoints(refNode, offset, m_end.container(), m_end.offset(), exceptionState) > 0 && !exceptionState.had_exception())
         return 1;
 
     // point is in the middle of this range, or on the boundary points
     return 0;
 }
 
 Range::CompareResults Range::compareNode(Node* refNode, ExceptionState& exceptionState) const
 {
     // http://developer.mozilla.org/en/docs/DOM:range.compareNode
     // This method returns 0, 1, 2, or 3 based on if the node is before, after,
     // before and after(surrounds), or inside the range, respectively
 
     if (!refNode) {
-        exceptionState.throwDOMException(NotFoundError, "The node provided was null.");
+        exceptionState.ThrowDOMException(NotFoundError, "The node provided was null.");
         return NODE_BEFORE;
     }
 
     if (!refNode->inActiveDocument()) {
         // Firefox doesn't throw an exception for this case; it returns 0.
         return NODE_BEFORE;
     }
 
     if (refNode->document() != m_ownerDocument) {
         // Firefox doesn't throw an exception for this case; it returns 0.
         return NODE_BEFORE;
     }
 
     ContainerNode* parentNode = refNode->parentNode();
     int nodeIndex = refNode->nodeIndex();
 
     if (!parentNode) {
         // if the node is the top document we should return NODE_BEFORE_AND_AFTER
         // but we throw to match firefox behavior
-        exceptionState.throwDOMException(NotFoundError, "The provided node has no parent.");
+        exceptionState.ThrowDOMException(NotFoundError, "The provided node has no parent.");
         return NODE_BEFORE;
     }
 
     if (comparePoint(parentNode, nodeIndex, exceptionState) < 0) { // starts before
         if (comparePoint(parentNode, nodeIndex + 1, exceptionState) > 0) // ends after the range
             return NODE_BEFORE_AND_AFTER;
         return NODE_BEFORE; // ends before or in the range
     }
     // starts at or after the range start
     if (comparePoint(parentNode, nodeIndex + 1, exceptionState) > 0) // ends after the range
         return NODE_AFTER;
     return NODE_INSIDE; // ends inside the range
 }
 
 short Range::compareBoundaryPoints(CompareHow how, const Range* sourceRange, ExceptionState& exceptionState) const
 {
     if (!(how == START_TO_START || how == START_TO_END || how == END_TO_END || how == END_TO_START)) {
-        exceptionState.throwDOMException(NotSupportedError, "The comparison method provided must be one of 'START_TO_START', 'START_TO_END', 'END_TO_END', or 'END_TO_START'.");
+        exceptionState.ThrowDOMException(NotSupportedError, "The comparison method provided must be one of 'START_TO_START', 'START_TO_END', 'END_TO_END', or 'END_TO_START'.");
         return 0;
     }
 
     Node* thisCont = commonAncestorContainer();
     Node* sourceCont = sourceRange->commonAncestorContainer();
     if (thisCont->document() != sourceCont->document()) {
-        exceptionState.throwDOMException(WrongDocumentError, "The source range is in a different document than this range.");
+        exceptionState.ThrowDOMException(WrongDocumentError, "The source range is in a different document than this range.");
         return 0;
     }
 
     Node* thisTop = thisCont;
     Node* sourceTop = sourceCont;
     while (thisTop->parentNode())
         thisTop = thisTop->parentNode();
     while (sourceTop->parentNode())
         sourceTop = sourceTop->parentNode();
     if (thisTop != sourceTop) { // in different DocumentFragments
-        exceptionState.throwDOMException(WrongDocumentError, "The source range is in a different document than this range.");
+        exceptionState.ThrowDOMException(WrongDocumentError, "The source range is in a different document than this range.");
         return 0;
     }
 
     switch (how) {
         case START_TO_START:
             return compareBoundaryPoints(m_start, sourceRange->m_start, exceptionState);
         case START_TO_END:
             return compareBoundaryPoints(m_end, sourceRange->m_start, exceptionState);
         case END_TO_END:
             return compareBoundaryPoints(m_end, sourceRange->m_end, exceptionState);
@@ skipping 60 matching lines @@
         if (offsetC < offsetB)
             return -1;              // A is before B
         else
             return 1;               // A is after B
     }
 
     // case 4: containers A & B are siblings, or children of siblings
     // ### we need to do a traversal here instead
     Node* commonAncestor = commonAncestorContainer(containerA, containerB);
     if (!commonAncestor) {
-        exceptionState.throwDOMException(WrongDocumentError, "The two ranges are in separate documents.");
+        exceptionState.ThrowDOMException(WrongDocumentError, "The two ranges are in separate documents.");
         return 0;
     }
     Node* childA = containerA;
     while (childA && childA->parentNode() != commonAncestor)
         childA = childA->parentNode();
     if (!childA)
         childA = commonAncestor;
     Node* childB = containerB;
     while (childB && childB->parentNode() != commonAncestor)
         childB = childB->parentNode();
@@ skipping 18 matching lines @@
 }
 
 short Range::compareBoundaryPoints(const RangeBoundaryPoint& boundaryA, const RangeBoundaryPoint& boundaryB, ExceptionState& exceptionState)
 {
     return compareBoundaryPoints(boundaryA.container(), boundaryA.offset(), boundaryB.container(), boundaryB.offset(), exceptionState);
 }
 
 bool Range::boundaryPointsValid() const
 {
     TrackExceptionState exceptionState;
-    return compareBoundaryPoints(m_start, m_end, exceptionState) <= 0 && !exceptionState.hadException();
+    return compareBoundaryPoints(m_start, m_end, exceptionState) <= 0 && !exceptionState.had_exception();
 }
 
 void Range::deleteContents(ExceptionState& exceptionState)
 {
     ASSERT(boundaryPointsValid());
 
     {
         EventQueueScope eventQueueScope;
         processContents(DELETE_CONTENTS, exceptionState);
     }
 }
 
 bool Range::intersectsNode(Node* refNode, ExceptionState& exceptionState)
 {
     // http://developer.mozilla.org/en/docs/DOM:range.intersectsNode
     // Returns a bool if the node intersects the range.
     if (!refNode) {
-        exceptionState.throwDOMException(NotFoundError, "The node provided is null.");
+        exceptionState.ThrowDOMException(NotFoundError, "The node provided is null.");
         return false;
     }
 
     if (!refNode->inActiveDocument() || refNode->document() != m_ownerDocument) {
         // Firefox doesn't throw an exception for these cases; it returns false.
         return false;
     }
 
     ContainerNode* parentNode = refNode->parentNode();
     int nodeIndex = refNode->nodeIndex();
 
     if (!parentNode) {
         // if the node is the top document we should return NODE_BEFORE_AND_AFTER
         // but we throw to match firefox behavior
-        exceptionState.throwDOMException(NotFoundError, "The node provided has no parent.");
+        exceptionState.ThrowDOMException(NotFoundError, "The node provided has no parent.");
         return false;
     }
 
     if (comparePoint(parentNode, nodeIndex, exceptionState) < 0 // starts before start
         && comparePoint(parentNode, nodeIndex + 1, exceptionState) < 0) { // ends before start
         return false;
     }
 
     if (comparePoint(parentNode, nodeIndex, exceptionState) > 0 // starts after end
         && comparePoint(parentNode, nodeIndex + 1, exceptionState) > 0) { // ends after end
@@ skipping 98 matching lines @@
     // delete all children of commonRoot between the start and end container
     RefPtr<Node> processStart = childOfCommonRootBeforeOffset(originalStart.container(), originalStart.offset(), commonRoot.get());
     if (processStart && originalStart.container() != commonRoot) // processStart contains nodes before m_start.
         processStart = processStart->nextSibling();
     RefPtr<Node> processEnd = childOfCommonRootBeforeOffset(originalEnd.container(), originalEnd.offset(), commonRoot.get());
 
     // Collapse the range, making sure that the result is not within a node that was partially selected.
     if (action == EXTRACT_CONTENTS || action == DELETE_CONTENTS) {
         if (partialStart && commonRoot->contains(partialStart.get())) {
             // FIXME: We should not continue if we have an earlier error.
-            exceptionState.clearException();
+            exceptionState.ClearException();
             setStart(partialStart->parentNode(), partialStart->nodeIndex() + 1, exceptionState);
         } else if (partialEnd && commonRoot->contains(partialEnd.get())) {
             // FIXME: We should not continue if we have an earlier error.
-            exceptionState.clearException();
+            exceptionState.ClearException();
             setStart(partialEnd->parentNode(), partialEnd->nodeIndex(), exceptionState);
         }
-        if (exceptionState.hadException())
+        if (exceptionState.had_exception())
             return nullptr;
         m_end = m_start;
     }
 
     originalStart.clear();
     originalEnd.clear();
 
     // Now add leftContents, stuff in between, and rightContents to the fragment
     // (or just delete the stuff in between)
 
@@ skipping 140 matching lines @@
         }
         firstChildInAncestorToProcess = direction == ProcessContentsForward ? ancestor->nextSibling() : ancestor->previousSibling();
     }
 
     return clonedContainer.release();
 }
 
 PassRefPtr<DocumentFragment> Range::extractContents(ExceptionState& exceptionState)
 {
     checkExtractPrecondition(exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return nullptr;
 
     return processContents(EXTRACT_CONTENTS, exceptionState);
 }
 
 PassRefPtr<DocumentFragment> Range::cloneContents(ExceptionState& exceptionState)
 {
     return processContents(CLONE_CONTENTS, exceptionState);
 }
 
 void Range::insertNode(PassRefPtr<Node> prpNewNode, ExceptionState& exceptionState)
 {
     RefPtr<Node> newNode = prpNewNode;
 
     if (!newNode) {
-        exceptionState.throwDOMException(NotFoundError, "The node provided is null.");
+        exceptionState.ThrowDOMException(NotFoundError, "The node provided is null.");
         return;
     }
 
     // HierarchyRequestError: Raised if the container of the start of the Range is of a type that
     // does not allow children of the type of newNode or if newNode is an ancestor of the container.
 
     // an extra one here - if a text node is going to split, it must have a parent to insert into
     bool startIsText = m_start.container()->isTextNode();
     if (startIsText && !m_start.container()->parentNode()) {
-        exceptionState.throwDOMException(HierarchyRequestError, "This operation would split a text node, but there's no parent into which to insert.");
+        exceptionState.ThrowDOMException(HierarchyRequestError, "This operation would split a text node, but there's no parent into which to insert.");
         return;
     }
 
     // In the case where the container is a text node, we check against the container's parent, because
     // text nodes get split up upon insertion.
     Node* checkAgainst;
     if (startIsText)
         checkAgainst = m_start.container()->parentNode();
     else
         checkAgainst = m_start.container();
 
     Node::NodeType newNodeType = newNode->nodeType();
     int numNewChildren;
     if (newNodeType == Node::DOCUMENT_FRAGMENT_NODE && !newNode->isShadowRoot()) {
         // check each child node, not the DocumentFragment itself
         numNewChildren = 0;
         for (Node* c = toDocumentFragment(newNode)->firstChild(); c; c = c->nextSibling()) {
             ++numNewChildren;
         }
     } else {
         numNewChildren = 1;
     }
 
     for (Node* n = m_start.container(); n; n = n->parentNode()) {
         if (n == newNode) {
-            exceptionState.throwDOMException(HierarchyRequestError, "The node to be inserted contains the insertion point; it may not be inserted into itself.");
+            exceptionState.ThrowDOMException(HierarchyRequestError, "The node to be inserted contains the insertion point; it may not be inserted into itself.");
             return;
         }
     }
 
     // InvalidNodeTypeError: Raised if newNode is an Attr, Entity, Notation, ShadowRoot or Document node.
     switch (newNodeType) {
     case Node::DOCUMENT_NODE:
-        exceptionState.throwDOMException(InvalidNodeTypeError, "The node to be inserted is a '" + newNode->nodeName() + "' node, which may not be inserted here.");
+        exceptionState.ThrowDOMException(InvalidNodeTypeError, "The node to be inserted is a '" + newNode->nodeName() + "' node, which may not be inserted here.");
         return;
     default:
         if (newNode->isShadowRoot()) {
-            exceptionState.throwDOMException(InvalidNodeTypeError, "The node to be inserted is a shadow root, which may not be inserted here.");
+            exceptionState.ThrowDOMException(InvalidNodeTypeError, "The node to be inserted is a shadow root, which may not be inserted here.");
             return;
         }
         break;
     }
 
     EventQueueScope scope;
     bool collapsed = m_start == m_end;
     RefPtr<Node> container = nullptr;
     if (startIsText) {
         container = m_start.container();
         RefPtr<Text> newText = toText(container)->splitText(m_start.offset(), exceptionState);
-        if (exceptionState.hadException())
+        if (exceptionState.had_exception())
             return;
 
         container = m_start.container();
         container->parentNode()->insertBefore(newNode.release(), newText.get(), exceptionState);
-        if (exceptionState.hadException())
+        if (exceptionState.had_exception())
             return;
 
         if (collapsed) {
             // The load event would be fired regardless of EventQueueScope;
             // e.g. by ContainerNode::updateTreeAfterInsertion
             // Given circumstance may mutate the tree so newText->parentNode() may become null
             if (!newText->parentNode()) {
-                exceptionState.throwDOMException(HierarchyRequestError, "This operation would set range's end to parent with new offset, but there's no parent into which to continue.");
+                exceptionState.ThrowDOMException(HierarchyRequestError, "This operation would set range's end to parent with new offset, but there's no parent into which to continue.");
                 return;
             }
             m_end.setToBeforeChild(*newText);
         }
     } else {
         RefPtr<Node> lastChild = (newNodeType == Node::DOCUMENT_FRAGMENT_NODE) ? toDocumentFragment(newNode)->lastChild() : newNode.get();
         if (lastChild && lastChild == m_start.childBefore()) {
             // The insertion will do nothing, but we need to extend the range to include
             // the inserted nodes.
             Node* firstChild = (newNodeType == Node::DOCUMENT_FRAGMENT_NODE) ? toDocumentFragment(newNode)->firstChild() : newNode.get();
             ASSERT(firstChild);
             m_start.setToBeforeChild(*firstChild);
             return;
         }
 
         container = m_start.container();
         container->insertBefore(newNode.release(), NodeTraversal::childAt(*container, m_start.offset()), exceptionState);
-        if (exceptionState.hadException())
+        if (exceptionState.had_exception())
             return;
 
         // Note that m_start.offset() may have changed as a result of container->insertBefore,
         // when the node we are inserting comes before the range in the same container.
         if (collapsed && numNewChildren)
             m_end.set(m_start.container(), m_start.offset() + numNewChildren, lastChild.get());
     }
 }
 
 String Range::toString() const
@@ skipping 23 matching lines @@
 void Range::detach()
 {
     // This is now a no-op as per the DOM specification.
 }
 
 Node* Range::checkNodeWOffset(Node* n, int offset, ExceptionState& exceptionState) const
 {
     switch (n->nodeType()) {
         case Node::TEXT_NODE:
             if (static_cast<unsigned>(offset) > toCharacterData(n)->length())
-                exceptionState.throwDOMException(IndexSizeError, "The offset " + String::number(offset) + " is larger than or equal to the node's length (" + String::number(toCharacterData(n)->length()) + ").");
+                exceptionState.ThrowDOMException(IndexSizeError, "The offset " + String::number(offset) + " is larger than or equal to the node's length (" + String::number(toCharacterData(n)->length()) + ").");
             return 0;
         case Node::DOCUMENT_FRAGMENT_NODE:
         case Node::DOCUMENT_NODE:
         case Node::ELEMENT_NODE: {
             if (!offset)
                 return 0;
             Node* childBefore = NodeTraversal::childAt(*n, offset - 1);
             if (!childBefore)
-                exceptionState.throwDOMException(IndexSizeError, "There is no child at offset " + String::number(offset) + ".");
+                exceptionState.ThrowDOMException(IndexSizeError, "There is no child at offset " + String::number(offset) + ".");
             return childBefore;
         }
     }
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 void Range::checkNodeBA(Node* n, ExceptionState& exceptionState) const
 {
     if (!n) {
-        exceptionState.throwDOMException(NotFoundError, "The node provided is null.");
+        exceptionState.ThrowDOMException(NotFoundError, "The node provided is null.");
         return;
     }
 
     // InvalidNodeTypeError: Raised if the root container of refNode is not an
     // Attr, Document, DocumentFragment or ShadowRoot node, or part of a SVG shadow DOM tree,
     // or if refNode is a Document, DocumentFragment, ShadowRoot, Attr, Entity, or Notation node.
 
     if (!n->parentNode()) {
-        exceptionState.throwDOMException(InvalidNodeTypeError, "the given Node has no parent.");
+        exceptionState.ThrowDOMException(InvalidNodeTypeError, "the given Node has no parent.");
         return;
     }
 
     switch (n->nodeType()) {
         case Node::DOCUMENT_FRAGMENT_NODE:
         case Node::DOCUMENT_NODE:
-            exceptionState.throwDOMException(InvalidNodeTypeError, "The node provided is of type '" + n->nodeName() + "'.");
+            exceptionState.ThrowDOMException(InvalidNodeTypeError, "The node provided is of type '" + n->nodeName() + "'.");
             return;
         case Node::ELEMENT_NODE:
         case Node::TEXT_NODE:
             break;
     }
 
     Node* root = n;
     while (ContainerNode* parent = root->parentNode())
         root = parent;
 
     switch (root->nodeType()) {
         case Node::DOCUMENT_NODE:
         case Node::DOCUMENT_FRAGMENT_NODE:
         case Node::ELEMENT_NODE:
             break;
         case Node::TEXT_NODE:
-            exceptionState.throwDOMException(InvalidNodeTypeError, "The node provided is of type '" + n->nodeName() + "'.");
+            exceptionState.ThrowDOMException(InvalidNodeTypeError, "The node provided is of type '" + n->nodeName() + "'.");
             return;
     }
 }
 
 PassRefPtr<Range> Range::cloneRange() const
 {
     return Range::create(*m_ownerDocument.get(), m_start.container(), m_start.offset(), m_end.container(), m_end.offset());
 }
 
 void Range::setStartAfter(Node* refNode, ExceptionState& exceptionState)
 {
     checkNodeBA(refNode, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return;
 
     setStart(refNode->parentNode(), refNode->nodeIndex() + 1, exceptionState);
 }
 
 void Range::setEndBefore(Node* refNode, ExceptionState& exceptionState)
 {
     checkNodeBA(refNode, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return;
 
     setEnd(refNode->parentNode(), refNode->nodeIndex(), exceptionState);
 }
 
 void Range::setEndAfter(Node* refNode, ExceptionState& exceptionState)
 {
     checkNodeBA(refNode, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return;
 
     setEnd(refNode->parentNode(), refNode->nodeIndex() + 1, exceptionState);
 }
 
 void Range::selectNode(Node* refNode, ExceptionState& exceptionState)
 {
     if (!refNode) {
-        exceptionState.throwDOMException(NotFoundError, "The node provided is null.");
+        exceptionState.ThrowDOMException(NotFoundError, "The node provided is null.");
         return;
     }
 
     if (!refNode->parentNode()) {
-        exceptionState.throwDOMException(InvalidNodeTypeError, "the given Node has no parent.");
+        exceptionState.ThrowDOMException(InvalidNodeTypeError, "the given Node has no parent.");
         return;
     }
 
     // InvalidNodeTypeError: Raised if an ancestor of refNode is an Entity, Notation or
     // DocumentType node or if refNode is a Document, DocumentFragment, ShadowRoot, Attr, Entity, or Notation
     // node.
     switch (refNode->nodeType()) {
         case Node::ELEMENT_NODE:
         case Node::TEXT_NODE:
             break;
         case Node::DOCUMENT_FRAGMENT_NODE:
         case Node::DOCUMENT_NODE:
-            exceptionState.throwDOMException(InvalidNodeTypeError, "The node provided is of type '" + refNode->nodeName() + "'.");
+            exceptionState.ThrowDOMException(InvalidNodeTypeError, "The node provided is of type '" + refNode->nodeName() + "'.");
             return;
     }
 
     if (m_ownerDocument != refNode->document())
         setDocument(refNode->document());
 
     setStartBefore(refNode);
     setEndAfter(refNode);
 }
 
 void Range::selectNodeContents(Node* refNode, ExceptionState& exceptionState)
 {
     if (!refNode) {
-        exceptionState.throwDOMException(NotFoundError, "The node provided is null.");
+        exceptionState.ThrowDOMException(NotFoundError, "The node provided is null.");
         return;
     }
 
     if (m_ownerDocument != refNode->document())
         setDocument(refNode->document());
 
     m_start.setToStartOfNode(*refNode);
     m_end.setToEndOfNode(*refNode);
 }
 
 void Range::surroundContents(PassRefPtr<Node> passNewParent, ExceptionState& exceptionState)
 {
     RefPtr<Node> newParent = passNewParent;
     if (!newParent) {
-        exceptionState.throwDOMException(NotFoundError, "The node provided is null.");
+        exceptionState.ThrowDOMException(NotFoundError, "The node provided is null.");
         return;
     }
 
     // InvalidStateError: Raised if the Range partially selects a non-Text node.
     Node* startNonTextContainer = m_start.container();
     if (startNonTextContainer->nodeType() == Node::TEXT_NODE)
         startNonTextContainer = startNonTextContainer->parentNode();
     Node* endNonTextContainer = m_end.container();
     if (endNonTextContainer->nodeType() == Node::TEXT_NODE)
         endNonTextContainer = endNonTextContainer->parentNode();
     if (startNonTextContainer != endNonTextContainer) {
-        exceptionState.throwDOMException(InvalidStateError, "The Range has partially selected a non-Text node.");
+        exceptionState.ThrowDOMException(InvalidStateError, "The Range has partially selected a non-Text node.");
         return;
     }
 
     // InvalidNodeTypeError: Raised if node is an Attr, Entity, DocumentType, Notation,
     // Document, or DocumentFragment node.
     switch (newParent->nodeType()) {
         case Node::DOCUMENT_FRAGMENT_NODE:
         case Node::DOCUMENT_NODE:
-            exceptionState.throwDOMException(InvalidNodeTypeError, "The node provided is of type '" + newParent->nodeName() + "'.");
+            exceptionState.ThrowDOMException(InvalidNodeTypeError, "The node provided is of type '" + newParent->nodeName() + "'.");
             return;
         case Node::ELEMENT_NODE:
         case Node::TEXT_NODE:
             break;
     }
 
     // Raise a HierarchyRequestError if m_start.container() doesn't accept children like newParent.
     Node* parentOfNewParent = m_start.container();
 
     // If m_start.container() is a character data node, it will be split and it will be its parent that will
     // need to accept newParent (or in the case of a comment, it logically "would" be inserted into the parent,
     // although this will fail below for another reason).
     if (parentOfNewParent->isTextNode())
         parentOfNewParent = parentOfNewParent->parentNode();
 
     if (!parentOfNewParent) {
-        exceptionState.throwDOMException(HierarchyRequestError, "The container node is a detached character data node; no parent node is available for insertion.");
+        exceptionState.ThrowDOMException(HierarchyRequestError, "The container node is a detached character data node; no parent node is available for insertion.");
         return;
     }
 
     if (newParent->contains(m_start.container())) {
-        exceptionState.throwDOMException(HierarchyRequestError, "The node provided contains the insertion point; it may not be inserted into itself.");
+        exceptionState.ThrowDOMException(HierarchyRequestError, "The node provided contains the insertion point; it may not be inserted into itself.");
         return;
     }
 
     // FIXME: Do we need a check if the node would end up with a child node of a type not
     // allowed by the type of node?
 
     while (Node* n = newParent->firstChild()) {
         toContainerNode(newParent)->removeChild(n, exceptionState);
-        if (exceptionState.hadException())
+        if (exceptionState.had_exception())
             return;
     }
     RefPtr<DocumentFragment> fragment = extractContents(exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return;
     insertNode(newParent, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return;
     newParent->appendChild(fragment.release(), exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return;
     selectNode(newParent.get(), exceptionState);
 }
 
 void Range::setStartBefore(Node* refNode, ExceptionState& exceptionState)
 {
     checkNodeBA(refNode, exceptionState);
-    if (exceptionState.hadException())
+    if (exceptionState.had_exception())
         return;
 
     setStart(refNode->parentNode(), refNode->nodeIndex(), exceptionState);
 }
 
 void Range::checkExtractPrecondition(ExceptionState&)
 {
     // FIXME: Remove.
 }
 
@@ skipping 366 matching lines @@
 
 void showTree(const blink::Range* range)
 {
     if (range && range->boundaryPointsValid()) {
         range->startContainer()->showTreeAndMark(range->startContainer(), "S", range->endContainer(), "E");
         fprintf(stderr, "start offset: %d, end offset: %d\n", range->startOffset(), range->endOffset());
     }
 }
 
 #endif