Avoid temporary range allocation in FrameSelection::respondToNodeModification.

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 452 matching lines @@
 void Range::deleteContents(ExceptionState& exceptionState)
 {
     ASSERT(boundaryPointsValid());
 
     {
         EventQueueScope eventQueueScope;
         processContents(DELETE_CONTENTS, exceptionState);
     }
 }
 
+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 (!refNode) {
-        exceptionState.throwDOMException(NotFoundError, "The node provided is null.");
+    if (!nodeValidForIntersects(refNode, m_ownerDocument.get(), exceptionState))
         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.");
         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(), 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;
+    }
+
+    Node* startContainerNode = start.containerNode();
+    int startOffset = start.computeOffsetInContainerNode();
+
+    if (compareBoundaryPoints(parentNode, nodeIndex, startContainerNode, startOffset, exceptionState) < 0 // starts before start
+        && compareBoundaryPoints(parentNode, nodeIndex + 1, startContainerNode, startOffset, exceptionState) < 0) { // ends before start
+        ASSERT(!exceptionState.hadException());
+        return false;
+    }
+
+    Node* endContainerNode = end.containerNode();
+    int endOffset = end.computeOffsetInContainerNode();
+
+    if (compareBoundaryPoints(parentNode, nodeIndex, endContainerNode, endOffset, exceptionState) > 0 // starts after end
+        && compareBoundaryPoints(parentNode, nodeIndex + 1, endContainerNode, endOffset, exceptionState) > 0) { // ends after end
+        ASSERT(!exceptionState.hadException());
+        return false;
+    }
+
+    return true; // all other cases
+}
+
 static inline Node* highestAncestorUnderCommonRoot(Node* node, Node* commonRoot)
 {
     if (node == commonRoot)
         return 0;
 
     ASSERT(commonRoot->contains(node));
 
     while (node->parentNode() != commonRoot)
         node = node->parentNode();
 
@@ skipping 1188 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