Remove Range.compareNode() as it is not in the spec

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 275 matching lines @@
         return 0;
 
     // compare to end, and point comes after
     if (compareBoundaryPoints(refNode, offset, m_end.container(), m_end.offset(), exceptionState) > 0 && !exceptionState.hadException())
         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
+bool Range::isNodeFullyContained(Node& node, 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
+    ContainerNode* parentNode = node.parentNode();
+    int nodeIndex = node.nodeIndex();

[philipj_slow, 2015/07/01 08:22:01]

Move this down to after the parentNode check, just before it is used.

[deepak.s, 2015/07/07 05:41:32]

Done.

 
-    if (!refNode) {
-        // FIXME: Generated bindings code never calls with null, and neither should other callers!
-        exceptionState.throwTypeError("The node provided is null.");
-        return NODE_BEFORE;
+    if (!parentNode) {
+        exceptionState.throwDOMException(NotFoundError, "The node provided has no parent.");

[philipj_slow, 2015/07/01 08:22:01]

This exception is ignored on both call sites, so just remove the ExceptionState&
argument and return false here.

[deepak.s, 2015/07/07 05:41:32]

Done.

+        return false;
     }
 
-    if (!refNode->inActiveDocument()) {
-        // Firefox doesn't throw an exception for this case; it returns 0.
-        return NODE_BEFORE;
-    }
+    if (comparePoint(parentNode, nodeIndex, exceptionState) == 0 // starts in the middle of this range, or on the boundary points

[philipj_slow, 2015/07/01 08:22:01]

To actually handle these exceptions, you'll have to add
exceptionState.hadException() after each comparePoint() call. I'd say just make
this a big return statement like in Range::isPointInRange.

[deepak.s, 2015/07/07 05:41:32]

Removed exception handling and passed IGNORE_EXCEPTION.
Made it as one big return as well.

[philipj_slow, 2015/07/07 08:27:29]

There are exception cases in Range::comparePoint that return 0 that will now be
treated as the node being fully contained, you would need
exceptionState.hadException() interleaved in the return statement, similar to in
Range::isPointInRange.

Alternatively, you could simply use isPointInRange, which already returns false
in all exception cases, making this method simply:

bool Range::isNodeFullyContained(Node& node) const
{
    ContainerNode* parentNode = node.parentNode();
    int nodeIndex = node.nodeIndex();
    return isPointInRange(parentNode, nodeIndex, IGNORE_EXCEPTION)
        && isPointInRange(parentNode, nodeIndex + 1, IGNORE_EXCEPTION);
}

You'll have to make Range::isPointInRange const for it to compile.

Please also move it to before Range::isPointInRange to match the header and to
make it easier to see read both together.

[deepak.s, 2015/07/08 04:57:02]

Updated method by using isPointInRange.

+        && comparePoint(parentNode, nodeIndex + 1, exceptionState) == 0) // ends in the middle of this range, or on the boundary points
+        return true;
 
-    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.");
-        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
+    return false;
 }
 
 short Range::compareBoundaryPoints(unsigned 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'.");
         return 0;
     }
 
     Node* thisCont = commonAncestorContainer();
@@ skipping 1378 matching lines @@
 {
     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());
     } else {
         fprintf(stderr, "Cannot show tree if range is null, or if boundary points are invalid.\n");
     }
 }
 
 #endif