Range: node offsets should be unsigned.

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 52 matching lines @@
       m_end(m_ownerDocument) {
   m_ownerDocument->attachRange(this);
 }
 
 Range* Range::create(Document& ownerDocument) {
   return new Range(ownerDocument);
 }
 
 inline Range::Range(Document& ownerDocument,
                     Node* startContainer,
-                    int startOffset,
+                    unsigned startOffset,
                     Node* endContainer,
-                    int endOffset)
+                    unsigned endOffset)
     : m_ownerDocument(&ownerDocument),
       m_start(m_ownerDocument),
       m_end(m_ownerDocument) {
   m_ownerDocument->attachRange(this);
 
   // Simply setting the containers and offsets directly would not do any of the
   // checking that setStart and setEnd do, so we call those functions.
   setStart(startContainer, startOffset);
   setEnd(endContainer, endOffset);
 }
 
 Range* Range::create(Document& ownerDocument,
                      Node* startContainer,
-                     int startOffset,
+                     unsigned startOffset,
                      Node* endContainer,
-                     int endOffset) {
+                     unsigned endOffset) {
   return new Range(ownerDocument, startContainer, startOffset, endContainer,
                    endOffset);
 }
 
 Range* Range::create(Document& ownerDocument,
                      const Position& start,
                      const Position& end) {
   return new Range(ownerDocument, start.computeContainerNode(),
                    start.computeOffsetInContainerNode(),
                    end.computeContainerNode(),
@@ skipping 54 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(Node* refNode,
-                     int offset,
+                     unsigned offset,
                      ExceptionState& exceptionState) {
   if (!refNode) {
     // FIXME: Generated bindings code never calls with null, and neither should
     // other callers!
     exceptionState.throwTypeError("The node provided is null.");
     return;
   }
 
   Document& oldDocument = ownerDocument();
   bool didMoveDocument = false;
   if (refNode->document() != m_ownerDocument) {
     setDocument(refNode->document());
     didMoveDocument = true;
   }
 
   Node* childNode = checkNodeWOffset(refNode, offset, exceptionState);
   if (exceptionState.hadException())
     return;
 
   m_start.set(refNode, offset, childNode);
 
   if (didMoveDocument || checkForDifferentRootContainer(m_start, m_end)) {
     removeFromSelectionIfInDifferentRoot(oldDocument);
     collapse(true);
     return;
   }
   updateSelectionIfAddedToSelection();
 }
 
-void Range::setEnd(Node* refNode, int offset, ExceptionState& exceptionState) {
+void Range::setEnd(Node* refNode,
+                   unsigned offset,
+                   ExceptionState& exceptionState) {
   if (!refNode) {
     // FIXME: Generated bindings code never calls with null, and neither should
     // other callers!
     exceptionState.throwTypeError("The node provided is null.");
     return;
   }
 
   bool didMoveDocument = false;
   Document& oldDocument = ownerDocument();
   if (refNode->document() != m_ownerDocument) {
@@ skipping 30 matching lines @@
 void Range::collapse(bool toStart) {
   if (toStart)
     m_end = m_start;
   else
     m_start = m_end;
   updateSelectionIfAddedToSelection();
 }
 
 bool Range::isNodeFullyContained(Node& node) const {
   ContainerNode* parentNode = node.parentNode();
-  int nodeIndex = node.nodeIndex();
+  unsigned nodeIndex = node.nodeIndex();
   return isPointInRange(
              parentNode, nodeIndex,
              IGNORE_EXCEPTION_FOR_TESTING)  // starts in the middle of this
                                             // range, or on the boundary points.
          && isPointInRange(
                 parentNode, nodeIndex + 1,
                 IGNORE_EXCEPTION_FOR_TESTING);  // 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,
+                           unsigned 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 (!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,
+                          unsigned 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 (!hasSameRoot(*refNode)) {
     exceptionState.throwDOMException(
         WrongDocumentError,
         "The node provided and the Range are not in the same tree.");
@@ skipping 66 matching lines @@
       return compareBoundaryPoints(m_end, sourceRange->m_end, exceptionState);
     case kEndToStart:
       return compareBoundaryPoints(m_start, sourceRange->m_end, exceptionState);
   }
 
   NOTREACHED();
   return 0;
 }
 
 short Range::compareBoundaryPoints(Node* containerA,
-                                   int offsetA,
+                                   unsigned offsetA,
                                    Node* containerB,
-                                   int offsetB,
+                                   unsigned offsetB,
                                    ExceptionState& exceptionState) {
   bool disconnected = false;
   short result = comparePositionsInDOMTree(containerA, offsetA, containerB,
                                            offsetB, &disconnected);
   if (disconnected) {
     exceptionState.throwDOMException(
         WrongDocumentError, "The two ranges are in separate documents.");
     return 0;
   }
   return result;
@@ skipping 555 matching lines @@
 }
 
 String Range::toString() const {
   StringBuilder builder;
 
   Node* pastLast = pastLastNode();
   for (Node* n = firstNode(); n != pastLast; n = NodeTraversal::next(*n)) {
     Node::NodeType type = n->getNodeType();
     if (type == Node::kTextNode || type == Node::kCdataSectionNode) {
       String data = toCharacterData(n)->data();
-      int length = data.length();
-      int start = (n == m_start.container())
-                      ? std::min(std::max(0, m_start.offset()), length)
-                      : 0;
-      int end = (n == m_end.container())
-                    ? std::min(std::max(start, m_end.offset()), length)
-                    : length;
+      unsigned length = data.length();
+      unsigned start =
+          (n == m_start.container()) ? std::min(m_start.offset(), length) : 0;
+      unsigned end = (n == m_end.container())
+                         ? std::min(std::max(start, m_end.offset()), length)
+                         : length;
       builder.append(data, start, end - start);
     }
   }
 
   return builder.toString();
 }
 
 String Range::text() const {
   DCHECK(!m_ownerDocument->needsLayoutTreeUpdate());
   return plainText(EphemeralRange(this),
@@ skipping 41 matching lines @@
   return blink::createContextualFragment(
       markup, element, AllowScriptingContentAndDoNotMarkAlreadyStarted,
       exceptionState);
 }
 
 void Range::detach() {
   // This is now a no-op as per the DOM specification.
 }
 
 Node* Range::checkNodeWOffset(Node* n,
-                              int offset,
+                              unsigned offset,
                               ExceptionState& exceptionState) {
   switch (n->getNodeType()) {
     case Node::kDocumentTypeNode:
       exceptionState.throwDOMException(
           InvalidNodeTypeError,
           "The node provided is of type '" + n->nodeName() + "'.");
       return nullptr;
     case Node::kCdataSectionNode:
     case Node::kCommentNode:
     case Node::kTextNode:
-      if (static_cast<unsigned>(offset) > toCharacterData(n)->length())
+      if (offset > toCharacterData(n)->length()) {
+        exceptionState.throwDOMException(
+            IndexSizeError, "The offset " + String::number(offset) +
+                                " is larger than the node's length (" +
+                                String::number(toCharacterData(n)->length()) +
+                                ").");
+      }
+      return nullptr;
+    case Node::kProcessingInstructionNode:
+      if (offset > toProcessingInstruction(n)->data().length()) {
         exceptionState.throwDOMException(
             IndexSizeError,
             "The offset " + String::number(offset) +
-                " is larger than or equal to the node's length (" +
-                String::number(toCharacterData(n)->length()) + ").");
-      return nullptr;
-    case Node::kProcessingInstructionNode:
-      if (static_cast<unsigned>(offset) >
-          toProcessingInstruction(n)->data().length())
-        exceptionState.throwDOMException(
-            IndexSizeError,
-            "The offset " + String::number(offset) +
-                " is larger than or equal to than the node's length (" +
+                " is larger than the node's length (" +
                 String::number(toProcessingInstruction(n)->data().length()) +
                 ").");
+      }
       return nullptr;
     case Node::kAttributeNode:
     case Node::kDocumentFragmentNode:
     case Node::kDocumentNode:
     case Node::kElementNode: {
       if (!offset)
         return nullptr;
       Node* childBefore = NodeTraversal::childAt(*n, offset - 1);
-      if (!childBefore)
+      if (!childBefore) {
         exceptionState.throwDOMException(
             IndexSizeError,
             "There is no child at offset " + String::number(offset) + ".");
+      }
       return childBefore;
     }
   }
   NOTREACHED();
   return nullptr;
 }
 
 void Range::checkNodeBA(Node* n, ExceptionState& exceptionState) const {
   if (!n) {
     // FIXME: Generated bindings code never calls with null, and neither should
@@ skipping 340 matching lines @@
   Node* endContainer = m_end.container();
   DCHECK(endContainer);
 
   Node* stopNode = pastLastNode();
   for (Node* node = firstNode(); node != stopNode;
        node = NodeTraversal::next(*node)) {
     LayoutObject* r = node->layoutObject();
     if (!r || !r->isText())
       continue;
     LayoutText* layoutText = toLayoutText(r);
-    int startOffset = node == startContainer ? m_start.offset() : 0;
-    int endOffset =
-        node == endContainer ? m_end.offset() : std::numeric_limits<int>::max();
+    unsigned startOffset = node == startContainer ? m_start.offset() : 0;
+    unsigned endOffset = node == endContainer
+                             ? m_end.offset()
+                             : std::numeric_limits<unsigned>::max();
     layoutText->absoluteRectsForRange(rects, startOffset, endOffset,
                                       useSelectionHeight);
   }
 }
 
 void Range::textQuads(Vector<FloatQuad>& quads, bool useSelectionHeight) const {
   Node* startContainer = m_start.container();
   DCHECK(startContainer);
   Node* endContainer = m_end.container();
   DCHECK(endContainer);
 
   Node* stopNode = pastLastNode();
   for (Node* node = firstNode(); node != stopNode;
        node = NodeTraversal::next(*node)) {
     LayoutObject* r = node->layoutObject();
     if (!r || !r->isText())
       continue;
     LayoutText* layoutText = toLayoutText(r);
-    int startOffset = node == startContainer ? m_start.offset() : 0;
-    int endOffset =
-        node == endContainer ? m_end.offset() : std::numeric_limits<int>::max();
+    unsigned startOffset = node == startContainer ? m_start.offset() : 0;
+    unsigned endOffset = node == endContainer
+                             ? m_end.offset()
+                             : std::numeric_limits<unsigned>::max();
     layoutText->absoluteQuadsForRange(quads, startOffset, endOffset,
                                       useSelectionHeight);
   }
 }
 
 bool areRangesEqual(const Range* a, const Range* b) {
   if (a == b)
     return true;
   if (!a || !b)
     return false;
@@ skipping 96 matching lines @@
   boundaryTextRemoved(m_end, text, offset, length);
 }
 
 static inline void boundaryTextNodesMerged(RangeBoundaryPoint& boundary,
                                            const NodeWithIndex& oldNode,
                                            unsigned offset) {
   if (boundary.container() == oldNode.node())
     boundary.set(oldNode.node().previousSibling(), boundary.offset() + offset,
                  0);
   else if (boundary.container() == oldNode.node().parentNode() &&
-           boundary.offset() == oldNode.index())
+           boundary.offset() == static_cast<unsigned>(oldNode.index()))
     boundary.set(oldNode.node().previousSibling(), offset, 0);
 }
 
 void Range::didMergeTextNodes(const NodeWithIndex& oldNode, unsigned offset) {
   DCHECK_EQ(oldNode.node().document(), m_ownerDocument);
   DCHECK(oldNode.node().parentNode());
   DCHECK(oldNode.node().isTextNode());
   DCHECK(oldNode.node().previousSibling());
   DCHECK(oldNode.node().previousSibling()->isTextNode());
   boundaryTextNodesMerged(m_start, oldNode, offset);
@@ skipping 97 matching lines @@
           Vector<FloatQuad> elementQuads;
           layoutObject->absoluteQuads(elementQuads);
           m_ownerDocument->adjustFloatQuadsForScrollAndAbsoluteZoom(
               elementQuads, *layoutObject);
 
           quads.appendVector(elementQuads);
         }
       }
     } else if (node->isTextNode()) {
       if (LayoutText* layoutText = toText(node)->layoutObject()) {
-        int startOffset = (node == startContainer) ? m_start.offset() : 0;
-        int endOffset = (node == endContainer) ? m_end.offset() : INT_MAX;
+        unsigned startOffset = (node == startContainer) ? m_start.offset() : 0;
+        unsigned endOffset = (node == endContainer)
+                                 ? m_end.offset()
+                                 : std::numeric_limits<unsigned>::max();
 
         Vector<FloatQuad> textQuads;
         layoutText->absoluteQuadsForRange(textQuads, startOffset, endOffset);
         m_ownerDocument->adjustFloatQuadsForScrollAndAbsoluteZoom(textQuads,
                                                                   *layoutText);
 
         quads.appendVector(textQuads);
       }
     }
   }
@@ skipping 63 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