Revert of Add [TypeChecking=Interface] to Range interface

Source/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
@@ skipping 138 matching lines @@
         endRootContainer = endRootContainer->parentNode();
     Node* startRootContainer = start.container();
     while (startRootContainer->parentNode())
         startRootContainer = startRootContainer->parentNode();
 
     return startRootContainer != endRootContainer || (Range::compareBoundaryPoints(start, end, ASSERT_NO_EXCEPTION) > 0);
 }
 
 void Range::setStart(PassRefPtrWillBeRawPtr<Node> refNode, int offset, ExceptionState& exceptionState)
 {
+    if (!refNode) {
+        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())
         return;
 
     m_start.set(refNode, offset, childNode);
 
     if (didMoveDocument || checkForDifferentRootContainer(m_start, m_end))
         collapse(true);
 }
 
 void Range::setEnd(PassRefPtrWillBeRawPtr<Node> refNode, int offset, ExceptionState& exceptionState)
 {
+    if (!refNode) {
+        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())
         return;
 
@@ skipping 18 matching lines @@
 void Range::collapse(bool toStart)
 {
     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.");
+        return false;
+    }
+
     if (!refNode->inActiveDocument() || refNode->document() != m_ownerDocument) {
         return false;
     }
 
     checkNodeWOffset(refNode, offset, exceptionState);
     if (exceptionState.hadException())
         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();
@@ skipping 33 matching lines @@
     // 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.");
+        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;
     }
 
@@ skipping 165 matching lines @@
 void Range::deleteContents(ExceptionState& exceptionState)
 {
     ASSERT(boundaryPointsValid());
 
     {
         EventQueueScope eventQueueScope;
         processContents(DELETE_CONTENTS, exceptionState);
     }
 }
 
-static bool nodeValidForIntersects(Node* refNode, Document* expectedDocument)
+static bool nodeValidForIntersects(Node* refNode, Document* expectedDocument, ExceptionState& exceptionState)
 {
+    if (!refNode) {
+        exceptionState.throwDOMException(NotFoundError, "The node provided is null.");
+        return false;
+    }
+
     if (!refNode->inActiveDocument() || refNode->document() != expectedDocument) {
         // Firefox doesn't throw an exception for these cases; it returns false.
         return false;
     }
 
     return true;
 }
 
 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 (!nodeValidForIntersects(refNode, m_ownerDocument.get()))
+    if (!nodeValidForIntersects(refNode, m_ownerDocument.get(), exceptionState))
         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.");
         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
         return false;
     }
 
     return true; // all other cases
 }
 
 bool Range::intersectsNode(Node* refNode, const Position& start, const Position& end, ExceptionState& exceptionState)
 {
     // http://developer.mozilla.org/en/docs/DOM:range.intersectsNode
     // Returns a bool if the node intersects the range.
-    if (!nodeValidForIntersects(refNode, start.document()))
+    if (!nodeValidForIntersects(refNode, start.document(), exceptionState))
         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.");
         return false;
@@ skipping 319 matching lines @@
 
 PassRefPtrWillBeRawPtr<DocumentFragment> Range::cloneContents(ExceptionState& exceptionState)
 {
     return processContents(CLONE_CONTENTS, exceptionState);
 }
 
 void Range::insertNode(PassRefPtrWillBeRawPtr<Node> prpNewNode, ExceptionState& exceptionState)
 {
     RefPtrWillBeRawPtr<Node> newNode = prpNewNode;
 
+    if (!newNode) {
+        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.");
         return;
     }
 
@@ skipping 194 matching lines @@
                 exceptionState.throwDOMException(IndexSizeError, "There is no child at offset " + String::number(offset) + ".");
             return childBefore;
         }
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 void Range::checkNodeBA(Node* n, ExceptionState& exceptionState) const
 {
+    if (!n) {
+        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.");
         return;
     }
 
     switch (n->nodeType()) {
@@ skipping 58 matching lines @@
 {
     checkNodeBA(refNode, exceptionState);
     if (exceptionState.hadException())
         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.");
+        return;
+    }
+
     if (!refNode->parentNode()) {
         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.
     for (ContainerNode* anc = refNode->parentNode(); anc; anc = anc->parentNode()) {
         switch (anc->nodeType()) {
@@ skipping 29 matching lines @@
 
     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.");
+        return;
+    }
+
     // InvalidNodeTypeError: Raised if refNode or an ancestor of refNode is an Entity, Notation
     // or DocumentType node.
     for (Node* n = refNode; n; n = n->parentNode()) {
         switch (n->nodeType()) {
         case Node::ATTRIBUTE_NODE:
         case Node::CDATA_SECTION_NODE:
         case Node::COMMENT_NODE:
         case Node::DOCUMENT_FRAGMENT_NODE:
         case Node::DOCUMENT_NODE:
         case Node::ELEMENT_NODE:
@@ skipping 40 matching lines @@
     start = startBoundaryPoint.toPosition();
     RangeBoundaryPoint endBoundaryPoint(refNode);
     endBoundaryPoint.setToEndOfNode(*refNode);
     end = endBoundaryPoint.toPosition();
     return true;
 }
 
 void Range::surroundContents(PassRefPtrWillBeRawPtr<Node> passNewParent, ExceptionState& exceptionState)
 {
     RefPtrWillBeRawPtr<Node> newParent = passNewParent;
+    if (!newParent) {
+        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.");
@@ skipping 479 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