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 (offset > node->lengthOfContents()) {
+        exceptionState.throwDOMException(IndexSizeError, String::number(offset) + " is larger than the given node's length.");
         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 (baseNode && baseOffset > baseNode->lengthOfContents()) {
+        exceptionState.throwDOMException(IndexSizeError, String::number(baseOffset) + " is larger than the base node's length.");

[yoichio, 2015/07/13 02:29:45]

Raising exception when offset is over content length is not speced.
How about other browsers?

[philipj_slow, 2015/07/13 07:13:49]

The spec has different variable names, but it actually does throw an exception
here:
http://w3c.github.io/selection-api/#widl-Selection-setBaseAndExtent-void-Node...

Note that the spec is also confused about signed/unsigned:
https://github.com/w3c/selection-api/issues/33

This is tricky, because previously passing -1 for the second argument would
throw an exception, but to preserve that behavior we'd have to do something
weird like if (static_cast<int>(baseOffset) < 0) throw().

Where is the current handling for when offset is too large?

[Habib Virji, 2015/08/05 09:33:44]

@philipj: As far as I can see no error. If it exceeds UINT_MAX it gives an error
with negative value. 

To comply with previous code I have added as per your suggestion. 

[Habib Virji, 2015/08/05 09:33:44]

Actually spec says to throw an error for both the scenarios...

"If anchorOffset is negative or longer than anchorNode's length or if
focusOffset is negative or longer than focusNode's length, throw an
IndexSizeError exception and abort these steps."

Firefox uses int and not unsigned and thus have same error as the current
chromium and thus exceeding length error is not shown.

         return;
     }
 
-    if (extentOffset < 0) {
-        exceptionState.throwDOMException(IndexSizeError, String::number(extentOffset) + " is not a valid extent offset.");
+    if (extentNode && baseNode && extentOffset > (baseNode->lengthOfContents() + extentNode->lengthOfContents())) {
+        exceptionState.throwDOMException(IndexSizeError, String::number(extentOffset) + " is larger than the extent node's length.");
         return;
     }
 
     if (!isValidForPosition(baseNode) || !isValidForPosition(extentNode))
         return;
 
     // FIXME: Eliminate legacy editing positions
     VisiblePosition visibleBase = VisiblePosition(createLegacyEditingPosition(baseNode, baseOffset), DOWNSTREAM);
     VisiblePosition visibleExtent = VisiblePosition(createLegacyEditingPosition(extentNode, extentOffset), DOWNSTREAM);
 
@@ skipping 43 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.");
-        return;
-    }
-    if (static_cast<unsigned>(offset) > node->lengthOfContents()) {
+    if (offset > node->lengthOfContents()) {
         exceptionState.throwDOMException(IndexSizeError, String::number(offset) + " is larger than the given node's length.");
         return;
     }
 
     if (!isValidForPosition(node))
         return;
 
     // FIXME: Eliminate legacy editing positions
     m_frame->selection().setExtent(VisiblePosition(createLegacyEditingPosition(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()) {
+    if (index >= rangeCount()) {
         exceptionState.throwDOMException(IndexSizeError, String::number(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 145 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.containerNode();
     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