Range object should check root node identify instead of inActiveDocument().

third_party/WebKit/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
@@ skipping 229 matching lines @@
   int nodeIndex = node.nodeIndex();
   return isPointInRange(parentNode, nodeIndex,
                         IGNORE_EXCEPTION)  // starts in the middle of this
                                            // range, or on the boundary points.
          && isPointInRange(parentNode, nodeIndex + 1,
                            IGNORE_EXCEPTION);  // ends in the middle of this
                                                // range, or on the boundary
                                                // points.
 }
 
+bool Range::hasSameRoot(const Node& node) const {
+  if (node.document() != m_ownerDocument)
+    return false;
+  // commonAncestorContainer() is O(depth). We should avoid to call it in common
+  // cases.
+  if (node.isInTreeScope() && m_start.container()->isInTreeScope() &&
+      &node.treeScope() == &m_start.container()->treeScope())
+    return true;
+  return node.commonAncestor(*m_start.container(), NodeTraversal::parent);
+}
+
 bool Range::isPointInRange(Node* refNode,
                            int offset,
                            ExceptionState& exceptionState) const {
   if (!refNode) {
     // FIXME: Generated bindings code never calls with null, and neither should
     // other callers!
     exceptionState.throwTypeError("The node provided is null.");
     return false;
   }
-
-  if (!refNode->inActiveDocument() || refNode->document() != m_ownerDocument) {
+  if (!hasSameRoot(*refNode))
     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 (!refNode->inActiveDocument()) {
+  if (!hasSameRoot(*refNode)) {
     exceptionState.throwDOMException(
-        WrongDocumentError, "The node provided is not in an active document.");
+        WrongDocumentError,
+        "The node provided and the Range are not in the same tree.");
     return 0;
   }
 
-  if (refNode->document() != m_ownerDocument) {
-    exceptionState.throwDOMException(
-        WrongDocumentError,
-        "The node provided is not in this Range's Document.");
-    return 0;
-  }
-
   checkNodeWOffset(refNode, offset, exceptionState);
   if (exceptionState.hadException())
     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())
@@ skipping 91 matching lines @@
 
 void Range::deleteContents(ExceptionState& exceptionState) {
   DCHECK(boundaryPointsValid());
 
   {
     EventQueueScope eventQueueScope;
     processContents(DELETE_CONTENTS, exceptionState);
   }
 }
 
-static bool nodeValidForIntersects(Node* refNode,
-                                   Document* expectedDocument,
-                                   ExceptionState& 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) {
     // FIXME: Generated bindings code never calls with null, and neither should
     // other callers!
     exceptionState.throwTypeError("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(), exceptionState))
+  if (!hasSameRoot(*refNode))
     return false;
 
   ContainerNode* parentNode = refNode->parentNode();
   if (!parentNode)
     return true;
 
   int nodeIndex = refNode->nodeIndex();
 
   if (comparePoint(parentNode, nodeIndex, exceptionState) <
           0  // starts before start
@@ skipping 1287 matching lines @@
                      .data()
               << "start offset: " << range->startOffset()
               << ", end offset: " << range->endOffset();
   } else {
     LOG(INFO) << "Cannot show tree if range is null, or if boundary points are "
                  "invalid.";
   }
 }
 
 #endif