Make Range.detach() a no-op

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 22 matching lines @@
 #include "core/dom/Node.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/NodeWithIndex.h"
 #include "core/dom/ProcessingInstruction.h"
 #include "core/events/ScopedEventQueue.h"
 #include "core/dom/Text.h"
 #include "core/editing/TextIterator.h"
 #include "core/editing/VisiblePosition.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/markup.h"
+#include "core/frame/UseCounter.h"
 #include "core/html/HTMLElement.h"
 #include "core/rendering/RenderBoxModelObject.h"
 #include "core/rendering/RenderText.h"
 #include "platform/geometry/FloatQuad.h"
 #include "wtf/RefCountedLeakCounter.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 #ifndef NDEBUG
 #include <stdio.h>
 #endif
@@ skipping 65 matching lines @@
 {
     ASSERT(m_ownerDocument != document);
     ASSERT(m_ownerDocument);
     m_ownerDocument->detachRange(this);
     m_ownerDocument = &document;
     m_start.setToStartOfNode(document);
     m_end.setToStartOfNode(document);
     m_ownerDocument->attachRange(this);
 }
 
-Node* Range::startContainer(ExceptionState& exceptionState) const
+Node* Range::commonAncestorContainer() const
 {
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return 0;
-    }
-
-    return m_start.container();
-}
-
-int Range::startOffset(ExceptionState& exceptionState) const
-{
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return 0;
-    }
-
-    return m_start.offset();
-}
-
-Node* Range::endContainer(ExceptionState& exceptionState) const
-{
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return 0;
-    }
-
-    return m_end.container();
-}
-
-int Range::endOffset(ExceptionState& exceptionState) const
-{
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return 0;
-    }
-
-    return m_end.offset();
-}
-
-Node* Range::commonAncestorContainer(ExceptionState& exceptionState) const
-{
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return 0;
-    }
-
     return commonAncestorContainer(m_start.container(), m_end.container());
 }
 
 Node* Range::commonAncestorContainer(Node* containerA, Node* containerB)
 {
     for (Node* parentA = containerA; parentA; parentA = parentA->parentNode()) {
         for (Node* parentB = containerB; parentB; parentB = parentB->parentNode()) {
             if (parentA == parentB)
                 return parentA;
         }
     }
     return 0;
 }
 
-bool Range::collapsed(ExceptionState& exceptionState) const
-{
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return 0;
-    }
-
-    return m_start == m_end;
-}
-
 static inline bool checkForDifferentRootContainer(const RangeBoundaryPoint& start, const RangeBoundaryPoint& end)
 {
     Node* endRootContainer = end.container();
     while (endRootContainer->parentNode())
         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(PassRefPtr<Node> refNode, int offset, ExceptionState& exceptionState)
 {
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return;
-    }
-
     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, exceptionState);
+        collapse(true);
 }
 
 void Range::setEnd(PassRefPtr<Node> refNode, int offset, ExceptionState& exceptionState)
 {
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return;
-    }
-
     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_end.set(refNode, offset, childNode);
 
     if (didMoveDocument || checkForDifferentRootContainer(m_start, m_end))
-        collapse(false, exceptionState);
+        collapse(false);
 }
 
 void Range::setStart(const Position& start, ExceptionState& exceptionState)
 {
     Position parentAnchored = start.parentAnchoredEquivalent();
     setStart(parentAnchored.containerNode(), parentAnchored.offsetInContainerNode(), exceptionState);
 }
 
 void Range::setEnd(const Position& end, ExceptionState& exceptionState)
 {
     Position parentAnchored = end.parentAnchoredEquivalent();
     setEnd(parentAnchored.containerNode(), parentAnchored.offsetInContainerNode(), exceptionState);
 }
 
-void Range::collapse(bool toStart, ExceptionState& exceptionState)
+void Range::collapse(bool toStart)
 {
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return;
-    }
-
     if (toStart)
         m_end = m_start;
     else
         m_start = m_end;
 }
 
 bool Range::isPointInRange(Node* refNode, int offset, ExceptionState& exceptionState)
 {
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return false;
-    }
-
     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();
 }
 
 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 (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return 0;
-    }
-
     if (!refNode) {
         exceptionState.throwDOMException(HierarchyRequestError, "The node provided was null.");
         return 0;
     }
 
     if (!refNode->inActiveDocument()) {
         exceptionState.throwDOMException(WrongDocumentError, "The node provided is not in an active document.");
         return 0;
     }
 
@@ skipping 25 matching lines @@
 {
     // 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 (!m_start.container() && refNode->inActiveDocument()) {
-        exceptionState.throwDOMException(InvalidStateError, "This Range is detached, and the provided node is not.");
-        return NODE_BEFORE;
-    }
-
-    if (m_start.container() && !refNode->inActiveDocument()) {
+    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();
@@ skipping 12 matching lines @@
         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 (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return 0;
-    }
-
     if (!sourceRange) {
         exceptionState.throwDOMException(NotFoundError, "The source range provided was null.");
         return 0;
     }
 
-    Node* thisCont = commonAncestorContainer(exceptionState);
-    if (exceptionState.hadException())
-        return 0;
-    Node* sourceCont = sourceRange->commonAncestorContainer(exceptionState);
-    if (exceptionState.hadException())
-        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.");
         return 0;
     }
 
     Node* thisTop = thisCont;
     Node* sourceTop = sourceCont;
     while (thisTop->parentNode())
         thisTop = thisTop->parentNode();
     while (sourceTop->parentNode())
@@ skipping 112 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 m_start.container() && compareBoundaryPoints(m_start, m_end, exceptionState) <= 0 && !exceptionState.hadException();
+    return compareBoundaryPoints(m_start, m_end, exceptionState) <= 0 && !exceptionState.hadException();
 }
 
 void Range::deleteContents(ExceptionState& exceptionState)
 {
     checkDeleteExtract(exceptionState);
     if (exceptionState.hadException())
         return;
 
     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.
-
-    // Throw exception if the range is already detached.
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return false;
-    }
     if (!refNode) {
         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;
     }
 
@@ skipping 76 matching lines @@
 }
 
 PassRefPtr<DocumentFragment> Range::processContents(ActionType action, ExceptionState& exceptionState)
 {
     typedef Vector<RefPtr<Node> > NodeVector;
 
     RefPtr<DocumentFragment> fragment;
     if (action == EXTRACT_CONTENTS || action == CLONE_CONTENTS)
         fragment = DocumentFragment::create(*m_ownerDocument.get());
 
-    if (collapsed(exceptionState))
+    if (collapsed())
         return fragment.release();
-    if (exceptionState.hadException())
-        return nullptr;
 
-    RefPtr<Node> commonRoot = commonAncestorContainer(exceptionState);
-    if (exceptionState.hadException())
-        return nullptr;
+    RefPtr<Node> commonRoot = commonAncestorContainer();
     ASSERT(commonRoot);
 
     if (m_start.container() == m_end.container()) {
         processContentsBetweenOffsets(action, fragment, m_start.container(), m_start.offset(), m_end.offset(), exceptionState);
         return fragment;
     }
 
     // Since mutation observers can modify the range during the process, the boundary points need to be saved.
     RangeBoundaryPoint originalStart(m_start);
     RangeBoundaryPoint originalEnd(m_end);
@@ skipping 235 matching lines @@
 {
     checkDeleteExtract(exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
     return processContents(EXTRACT_CONTENTS, exceptionState);
 }
 
 PassRefPtr<DocumentFragment> Range::cloneContents(ExceptionState& exceptionState)
 {
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return nullptr;
-    }
-
     return processContents(CLONE_CONTENTS, exceptionState);
 }
 
 void Range::insertNode(PassRefPtr<Node> prpNewNode, ExceptionState& exceptionState)
 {
     RefPtr<Node> newNode = prpNewNode;
 
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return;
-    }
-
     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();
@@ skipping 83 matching lines @@
         if (exceptionState.hadException())
             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(ExceptionState& exceptionState) const
+String Range::toString() const
 {
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return String();
-    }
-
     StringBuilder builder;
 
     Node* pastLast = pastLastNode();
     for (Node* n = firstNode(); n != pastLast; n = NodeTraversal::next(*n)) {
         if (n->nodeType() == Node::TEXT_NODE || n->nodeType() == Node::CDATA_SECTION_NODE) {
             String data = toCharacterData(n)->data();
             int length = data.length();
             int start = (n == m_start.container()) ? min(max(0, m_start.offset()), length) : 0;
             int end = (n == m_end.container()) ? min(max(start, m_end.offset()), length) : length;
             builder.append(data, start, end - start);
         }
     }
 
     return builder.toString();
 }
 
 String Range::toHTML() const
 {
     return createMarkup(this);
 }
 
 String Range::text() const
 {
-    if (!m_start.container())
-        return String();
-
     // We need to update layout, since plainText uses line boxes in the render tree.
     // FIXME: As with innerText, we'd like this to work even if there are no render objects.
     m_start.container()->document().updateLayout();
 
     return plainText(this);
 }
 
 PassRefPtr<DocumentFragment> Range::createContextualFragment(const String& markup, ExceptionState& exceptionState)
 {
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return nullptr;
-    }
-
     Node* element = m_start.container()->isElementNode() ? m_start.container() : m_start.container()->parentNode();
     if (!element || !element->isHTMLElement()) {
         exceptionState.throwDOMException(NotSupportedError, "The range's container must be an HTML element.");
         return nullptr;
     }
 
     RefPtr<DocumentFragment> fragment = WebCore::createContextualFragment(markup, toHTMLElement(element), AllowScriptingContentAndDoNotMarkAlreadyStarted, exceptionState);
     if (!fragment)
         return nullptr;
 
     return fragment.release();
 }
 
 
-void Range::detach(ExceptionState& exceptionState)
+void Range::detach()
 {
-    // Check first to see if we've already detached:
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return;
-    }
-
-    m_ownerDocument->detachRange(this);
-
-    m_start.clear();
-    m_end.clear();
+    // This is now a no-op as per the DOM specification.
+    UseCounter::countDeprecation(ownerDocument(), UseCounter::RangeDetach);

[Yuta Kitamura, 2014/04/28 09:27:38]

Why don't you use "DeprecateAs=" IDL attribute here?

[Inactive, 2014/04/28 14:44:18]

Done.

 }
 
 Node* Range::checkNodeWOffset(Node* n, int offset, ExceptionState& exceptionState) const
 {
     switch (n->nodeType()) {
         case Node::DOCUMENT_TYPE_NODE:
             exceptionState.throwDOMException(InvalidNodeTypeError, "The node provided is of type '" + n->nodeName() + "'.");
             return 0;
         case Node::CDATA_SECTION_NODE:
         case Node::COMMENT_NODE:
@@ skipping 16 matching lines @@
                 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 (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return;
-    }
-
     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()) {
@@ skipping 29 matching lines @@
         case Node::CDATA_SECTION_NODE:
         case Node::COMMENT_NODE:
         case Node::DOCUMENT_TYPE_NODE:
         case Node::PROCESSING_INSTRUCTION_NODE:
         case Node::TEXT_NODE:
             exceptionState.throwDOMException(InvalidNodeTypeError, "The node provided is of type '" + n->nodeName() + "'.");
             return;
     }
 }
 
-PassRefPtrWillBeRawPtr<Range> Range::cloneRange(ExceptionState& exceptionState) const
+PassRefPtrWillBeRawPtr<Range> Range::cloneRange() const
 {
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return nullptr;
-    }
-
     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())
         return;
 
     setStart(refNode->parentNode(), refNode->nodeIndex() + 1, exceptionState);
@@ skipping 12 matching lines @@
 {
     checkNodeBA(refNode, exceptionState);
     if (exceptionState.hadException())
         return;
 
     setEnd(refNode->parentNode(), refNode->nodeIndex() + 1, exceptionState);
 }
 
 void Range::selectNode(Node* refNode, ExceptionState& exceptionState)
 {
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return;
-    }
-
     if (!refNode) {
         exceptionState.throwDOMException(NotFoundError, "The node provided is null.");
         return;
     }
 
     if (!refNode->parentNode()) {
         exceptionState.throwDOMException(InvalidNodeTypeError, "the given Node has no parent.");
         return;
     }
 
@@ skipping 34 matching lines @@
 
     if (m_ownerDocument != refNode->document())
         setDocument(refNode->document());
 
     setStartBefore(refNode);
     setEndAfter(refNode);
 }
 
 void Range::selectNodeContents(Node* refNode, ExceptionState& exceptionState)
 {
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return;
-    }
-
     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:
@@ skipping 14 matching lines @@
     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 (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return;
-    }
-
     if (!newParent) {
         exceptionState.throwDOMException(NotFoundError, "The node provided is null.");
         return;
     }
 
     // InvalidNodeTypeError: Raised if node is an Attr, Entity, DocumentType, Notation,
     // Document, or DocumentFragment node.
     switch (newParent->nodeType()) {
         case Node::ATTRIBUTE_NODE:
         case Node::DOCUMENT_FRAGMENT_NODE:
@@ skipping 69 matching lines @@
 {
     checkNodeBA(refNode, exceptionState);
     if (exceptionState.hadException())
         return;
 
     setStart(refNode->parentNode(), refNode->nodeIndex(), exceptionState);
 }
 
 void Range::checkDeleteExtract(ExceptionState& exceptionState)
 {
-    if (!m_start.container()) {
-        exceptionState.throwDOMException(InvalidStateError, "The range has no container. Perhaps 'detach()' has been invoked on this object?");
-        return;
-    }
-
     ASSERT(boundaryPointsValid());
 
-    if (!commonAncestorContainer(exceptionState) || exceptionState.hadException())
+    if (!commonAncestorContainer())
         return;
 
     Node* pastLast = pastLastNode();
     for (Node* n = firstNode(); n != pastLast; n = NodeTraversal::next(*n)) {
         if (n->isDocumentTypeNode()) {
             exceptionState.throwDOMException(HierarchyRequestError, "The Range contains a doctype node.");
             return;
         }
     }
 }
 
 Node* Range::firstNode() const
 {
-    if (!m_start.container())
-        return 0;
     if (m_start.container()->offsetInCharacters())
         return m_start.container();
     if (Node* child = m_start.container()->traverseToChildAt(m_start.offset()))
         return child;
     if (!m_start.offset())
         return m_start.container();
     return NodeTraversal::nextSkippingChildren(*m_start.container());
 }
 
 ShadowRoot* Range::shadowRoot() const
 {
     return startContainer() ? startContainer()->containingShadowRoot() : 0;
 }
 
 Node* Range::pastLastNode() const
 {
-    if (!m_start.container() || !m_end.container())
-        return 0;
     if (m_end.container()->offsetInCharacters())
         return NodeTraversal::nextSkippingChildren(*m_end.container());
     if (Node* child = m_end.container()->traverseToChildAt(m_end.offset()))
         return child;
     return NodeTraversal::nextSkippingChildren(*m_end.container());
 }
 
 IntRect Range::boundingBox() const
 {
     IntRect result;
     Vector<IntRect> rects;
     textRects(rects);
     const size_t n = rects.size();
     for (size_t i = 0; i < n; ++i)
         result.unite(rects[i]);
     return result;
 }
 
 void Range::textRects(Vector<IntRect>& rects, bool useSelectionHeight, RangeInFixedPosition* inFixed) const
 {
     Node* startContainer = m_start.container();
+    ASSERT(startContainer);
     Node* endContainer = m_end.container();
-
-    if (!startContainer || !endContainer) {
-        if (inFixed)
-            *inFixed = NotFixedPosition;
-        return;
-    }
+    ASSERT(endContainer);
 
     bool allFixed = true;
     bool someFixed = false;
 
     Node* stopNode = pastLastNode();
     for (Node* node = firstNode(); node != stopNode; node = NodeTraversal::next(*node)) {
         RenderObject* r = node->renderer();
         if (!r || !r->isText())
             continue;
         RenderText* renderText = toRenderText(r);
         int startOffset = node == startContainer ? m_start.offset() : 0;
         int endOffset = node == endContainer ? m_end.offset() : numeric_limits<int>::max();
         bool isFixed = false;
         renderText->absoluteRectsForRange(rects, startOffset, endOffset, useSelectionHeight, &isFixed);
         allFixed &= isFixed;
         someFixed |= isFixed;
     }
 
     if (inFixed)
         *inFixed = allFixed ? EntirelyFixedPosition : (someFixed ? PartiallyFixedPosition : NotFixedPosition);
 }
 
 void Range::textQuads(Vector<FloatQuad>& quads, bool useSelectionHeight, RangeInFixedPosition* inFixed) const
 {
     Node* startContainer = m_start.container();
+    ASSERT(startContainer);
     Node* endContainer = m_end.container();
-
-    if (!startContainer || !endContainer) {
-        if (inFixed)
-            *inFixed = NotFixedPosition;
-        return;
-    }
+    ASSERT(endContainer);
 
     bool allFixed = true;
     bool someFixed = false;
 
     Node* stopNode = pastLastNode();
     for (Node* node = firstNode(); node != stopNode; node = NodeTraversal::next(*node)) {
         RenderObject* r = node->renderer();
         if (!r || !r->isText())
             continue;
         RenderText* renderText = toRenderText(r);
         int startOffset = node == startContainer ? m_start.offset() : 0;
         int endOffset = node == endContainer ? m_end.offset() : numeric_limits<int>::max();
         bool isFixed = false;
         renderText->absoluteQuadsForRange(quads, startOffset, endOffset, useSelectionHeight, &isFixed);
         allFixed &= isFixed;
         someFixed |= isFixed;
     }
 
     if (inFixed)
         *inFixed = allFixed ? EntirelyFixedPosition : (someFixed ? PartiallyFixedPosition : NotFixedPosition);
 }
 
 #ifndef NDEBUG
 void Range::formatForDebugger(char* buffer, unsigned length) const
 {
     StringBuilder result;
-    String s;
 
-    if (!m_start.container() || !m_end.container())
-        result.appendLiteral("<empty>");
-    else {
-        const int FormatBufferSize = 1024;
-        char s[FormatBufferSize];
-        result.appendLiteral("from offset ");
-        result.appendNumber(m_start.offset());
-        result.appendLiteral(" of ");
-        m_start.container()->formatForDebugger(s, FormatBufferSize);
-        result.append(s);
-        result.appendLiteral(" to offset ");
-        result.appendNumber(m_end.offset());
-        result.appendLiteral(" of ");
-        m_end.container()->formatForDebugger(s, FormatBufferSize);
-        result.append(s);
-    }
+    const int FormatBufferSize = 1024;
+    char s[FormatBufferSize];
+    result.appendLiteral("from offset ");
+    result.appendNumber(m_start.offset());
+    result.appendLiteral(" of ");
+    m_start.container()->formatForDebugger(s, FormatBufferSize);
+    result.append(s);
+    result.appendLiteral(" to offset ");
+    result.appendNumber(m_end.offset());
+    result.appendLiteral(" of ");
+    m_end.container()->formatForDebugger(s, FormatBufferSize);
+    result.append(s);
 
     strncpy(buffer, result.toString().utf8().data(), length - 1);
 }
 #endif
 
 bool areRangesEqual(const Range* a, const Range* b)
 {
     if (a == b)
         return true;
     if (!a || !b)
@@ skipping 175 matching lines @@
         start = startOfDocument(start);
         end = endOfDocument(end);
     } else
         return;
     setStart(start.deepEquivalent().containerNode(), start.deepEquivalent().computeOffsetInContainerNode(), exceptionState);
     setEnd(end.deepEquivalent().containerNode(), end.deepEquivalent().computeOffsetInContainerNode(), exceptionState);
 }
 
 PassRefPtrWillBeRawPtr<ClientRectList> Range::getClientRects() const
 {
-    if (!m_start.container())
-        return ClientRectList::create();
-
     m_ownerDocument->updateLayoutIgnorePendingStylesheets();
 
     Vector<FloatQuad> quads;
     getBorderAndTextQuads(quads);
 
     return ClientRectList::create(quads);
 }
 
 PassRefPtrWillBeRawPtr<ClientRect> Range::getBoundingClientRect() const
 {
@@ skipping 34 matching lines @@
                 m_ownerDocument->adjustFloatQuadsForScrollAndAbsoluteZoom(textQuads, renderText);
 
                 quads.appendVector(textQuads);
             }
         }
     }
 }
 
 FloatRect Range::boundingRect() const
 {
-    if (!m_start.container())
-        return FloatRect();
-
     m_ownerDocument->updateLayoutIgnorePendingStylesheets();
 
     Vector<FloatQuad> quads;
     getBorderAndTextQuads(quads);
     if (quads.isEmpty())
         return FloatRect();
 
     FloatRect result;
     for (size_t i = 0; i < quads.size(); ++i)
         result.unite(quads[i].boundingBox());
@@ skipping 11 matching lines @@
 
 void showTree(const WebCore::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