All offset in dom/Range.idl should be unsigned long

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 50 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;
   }
 
   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))
     collapse(true);
 }
 
-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;
   if (refNode->document() != m_ownerDocument) {
     setDocument(refNode->document());
@@ skipping 48 matching lines @@
     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 31 matching lines @@
     exceptionState.throwTypeError("The node provided is null.");
     return false;
   }
   if (!hasSameRoot(*refNode))
     return false;
 
   ContainerNode* parentNode = refNode->parentNode();
   if (!parentNode)
     return true;
 
-  int nodeIndex = refNode->nodeIndex();
+  unsigned nodeIndex = refNode->nodeIndex();
 
   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) >
@@ skipping 499 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 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())
+      if (offset > toProcessingInstruction(n)->data().length())
         exceptionState.throwDOMException(
             IndexSizeError,
             "The offset " + String::number(offset) +
                 " is larger than or equal to than the node's length (" +
                 String::number(toProcessingInstruction(n)->data().length()) +
                 ").");
       return nullptr;
     case Node::kAttributeNode:
     case Node::kDocumentFragmentNode:
     case Node::kDocumentNode:
@@ skipping 498 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 155 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