Selection attributes changes from long to unsigned long

Source/core/editing/DOMSelection.cpp

 /*
  * Copyright (C) 2007, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 89 matching lines @@
 }
 
 Node* DOMSelection::anchorNode() const
 {
     if (!m_frame)
         return 0;
 
     return shadowAdjustedNode(anchorPosition(visibleSelection()));
 }
 
-int DOMSelection::anchorOffset() const
+unsigned DOMSelection::anchorOffset() const
 {
     if (!m_frame)
         return 0;
 
     return shadowAdjustedOffset(anchorPosition(visibleSelection()));
 }
 
 Node* DOMSelection::focusNode() const
 {
     if (!m_frame)
         return 0;
 
     return shadowAdjustedNode(focusPosition(visibleSelection()));
 }
 
-int DOMSelection::focusOffset() const
+unsigned DOMSelection::focusOffset() const
 {
     if (!m_frame)
         return 0;
 
     return shadowAdjustedOffset(focusPosition(visibleSelection()));
 }
 
 Node* DOMSelection::baseNode() const
 {
     if (!m_frame)
         return 0;
 
     return shadowAdjustedNode(basePosition(visibleSelection()));
 }
 
-int DOMSelection::baseOffset() const
+unsigned DOMSelection::baseOffset() const
 {
     if (!m_frame)
         return 0;
 
     return shadowAdjustedOffset(basePosition(visibleSelection()));
 }
 
 Node* DOMSelection::extentNode() const
 {
     if (!m_frame)
         return 0;
 
     return shadowAdjustedNode(extentPosition(visibleSelection()));
 }
 
-int DOMSelection::extentOffset() const
+unsigned DOMSelection::extentOffset() const
 {
     if (!m_frame)
         return 0;
 
     return shadowAdjustedOffset(extentPosition(visibleSelection()));
 }
 
 bool DOMSelection::isCollapsed() const
 {
     if (!m_frame || selectionShadowAncestor(m_frame))
@@ skipping 11 matching lines @@
     // This is a WebKit DOM extension, incompatible with an IE extension
     // IE has this same attribute, but returns "none", "text" and "control"
     // http://msdn.microsoft.com/en-us/library/ms534692(VS.85).aspx
     if (selection.isNone())
         return "None";
     if (selection.isCaret())
         return "Caret";
     return "Range";
 }
 
-int DOMSelection::rangeCount() const
+unsigned DOMSelection::rangeCount() const
 {
     if (!m_frame)
         return 0;
     return m_frame->selection().isNone() ? 0 : 1;
 }
 
-void DOMSelection::collapse(Node* node, int offset, ExceptionState& exceptionState)
+void DOMSelection::collapse(Node* node, unsigned offset, ExceptionState& exceptionState)
 {
     if (!m_frame)
         return;
 
     if (!node) {
         m_frame->selection().clear();
         return;
     }
 
-    if (offset < 0) {
-        exceptionState.throwDOMException(IndexSizeError, String::number(offset) + " is not a valid offset.");
+    if (static_cast<int>(offset) < 0) {

[philipj_slow, 2015/08/10 13:46:40]

This is really quite strange, and is strange in the spec as well:
https://github.com/w3c/selection-api/issues/33

Every |if (x < 0)| that has now been replaced by |if (static_cast<int>(x) < 0)|
ought to simply be removed I think. If the value is later cast to int such that
the case here tested matters, the change has to go deeper. If that's too
complicated, then we probably shouldn't make the change at all.

+        exceptionState.throwDOMException(IndexSizeError, String::number(static_cast<int>(offset)) + " is not a valid offset.");
         return;
     }
 
     if (!isValidForPosition(node))
         return;
     RefPtrWillBeRawPtr<Range> range = Range::create(node->document());
     range->setStart(node, offset, exceptionState);
     if (exceptionState.hadException())
         return;
     range->setEnd(node, offset, exceptionState);
@@ skipping 32 matching lines @@
     m_frame->selection().moveTo(VisiblePosition(selection.start(), DOWNSTREAM));
 }
 
 void DOMSelection::empty()
 {
     if (!m_frame)
         return;
     m_frame->selection().clear();
 }
 
-void DOMSelection::setBaseAndExtent(Node* baseNode, int baseOffset, Node* extentNode, int extentOffset, ExceptionState& exceptionState)
+void DOMSelection::setBaseAndExtent(Node* baseNode, unsigned baseOffset, Node* extentNode, unsigned extentOffset, ExceptionState& exceptionState)
 {
     if (!m_frame)
         return;
 
-    if (baseOffset < 0) {
-        exceptionState.throwDOMException(IndexSizeError, String::number(baseOffset) + " is not a valid base offset.");
+    if (static_cast<int>(baseOffset) < 0) {
+        exceptionState.throwDOMException(IndexSizeError, String::number(static_cast<int>(baseOffset)) + " is not a valid base offset.");
         return;
     }
 
-    if (extentOffset < 0) {
-        exceptionState.throwDOMException(IndexSizeError, String::number(extentOffset) + " is not a valid extent offset.");
+    if (static_cast<int>(extentOffset) < 0) {
+        exceptionState.throwDOMException(IndexSizeError, String::number(static_cast<int>(extentOffset)) + " is not a valid extent offset.");
         return;
     }
 
     if (!isValidForPosition(baseNode) || !isValidForPosition(extentNode))
         return;
 
     VisiblePosition visibleBase = VisiblePosition(Position(baseNode, baseOffset), DOWNSTREAM);
     VisiblePosition visibleExtent = VisiblePosition(Position(extentNode, extentOffset), DOWNSTREAM);
 
     m_frame->selection().moveTo(visibleBase, visibleExtent);
@@ skipping 42 matching lines @@
     else if (equalIgnoringCase(granularityString, "paragraphboundary"))
         granularity = ParagraphBoundary;
     else if (equalIgnoringCase(granularityString, "documentboundary"))
         granularity = DocumentBoundary;
     else
         return;
 
     m_frame->selection().modify(alter, direction, granularity);
 }
 
-void DOMSelection::extend(Node* node, int offset, ExceptionState& exceptionState)
+void DOMSelection::extend(Node* node, unsigned offset, ExceptionState& exceptionState)
 {
     ASSERT(node);
 
     if (!m_frame)
         return;
 
-    if (offset < 0) {
-        exceptionState.throwDOMException(IndexSizeError, String::number(offset) + " is not a valid offset.");
+    if (static_cast<int>(offset) < 0) {
+        exceptionState.throwDOMException(IndexSizeError, String::number(static_cast<int>(offset)) + " is not a valid offset.");
         return;
     }
-    if (static_cast<unsigned>(offset) > node->lengthOfContents()) {
-        exceptionState.throwDOMException(IndexSizeError, String::number(offset) + " is larger than the given node's length.");
+    if (offset > node->lengthOfContents()) {
+        exceptionState.throwDOMException(IndexSizeError, String::number(offset)  + " is larger than the given node's length.");
         return;
     }
 
     if (!isValidForPosition(node))
         return;
 
     m_frame->selection().setExtent(VisiblePosition(Position(node, offset), DOWNSTREAM));
 }
 
-PassRefPtrWillBeRawPtr<Range> DOMSelection::getRangeAt(int index, ExceptionState& exceptionState)
+PassRefPtrWillBeRawPtr<Range> DOMSelection::getRangeAt(unsigned index, ExceptionState& exceptionState)
 {
     if (!m_frame)
         return nullptr;
 
-    if (index < 0 || index >= rangeCount()) {
-        exceptionState.throwDOMException(IndexSizeError, String::number(index) + " is not a valid index.");
+    if (static_cast<int>(index) < 0 || index >= rangeCount()) {
+        exceptionState.throwDOMException(IndexSizeError, String::number(static_cast<int>(index)) + " is not a valid index.");
         return nullptr;
     }
 
     // If you're hitting this, you've added broken multi-range selection support
     ASSERT(rangeCount() == 1);
 
     Position anchor = anchorPosition(visibleSelection());
     if (!anchor.anchorNode()->isInShadowTree())
         return m_frame->selection().firstRange();
 
@@ skipping 144 matching lines @@
     if (!adjustedNode)
         return 0;
 
     if (containerNode == adjustedNode)
         return containerNode;
 
     ASSERT(!adjustedNode->isShadowRoot());
     return adjustedNode->parentOrShadowHostNode();
 }
 
-int DOMSelection::shadowAdjustedOffset(const Position& position) const
+unsigned DOMSelection::shadowAdjustedOffset(const Position& position) const
 {
     if (position.isNull())
         return 0;
 
     Node* containerNode = position.computeContainerNode();
     Node* adjustedNode = m_treeScope->ancestorInThisScope(containerNode);
 
     if (!adjustedNode)
         return 0;
 
@@ skipping 17 matching lines @@
         m_treeScope->document().addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message));
 }
 
 DEFINE_TRACE(DOMSelection)
 {
     visitor->trace(m_treeScope);
     DOMWindowProperty::trace(visitor);
 }
 
 } // namespace blink