[InputEvent] Update spec link for StaticRange.idl and use unsigned offset

third_party/WebKit/Source/core/dom/StaticRangeTest.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/dom/StaticRange.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
 #include "core/dom/Element.h"
 #include "core/dom/NodeList.h"
@@ skipping 31 matching lines @@
 HTMLDocument& StaticRangeTest::document() const {
   return *m_document;
 }
 
 TEST_F(StaticRangeTest, SplitTextNodeRangeWithinText) {
   V8TestingScope scope;
   document().body()->setInnerHTML("1234");
   Text* oldText = toText(document().body()->firstChild());
 
   StaticRange* staticRange04 =
-      StaticRange::create(document(), oldText, 0, oldText, 4);
+      StaticRange::create(document(), oldText, 0u, oldText, 4u);
   StaticRange* staticRange02 =
-      StaticRange::create(document(), oldText, 0, oldText, 2);
+      StaticRange::create(document(), oldText, 0u, oldText, 2u);
   StaticRange* staticRange22 =
-      StaticRange::create(document(), oldText, 2, oldText, 2);
+      StaticRange::create(document(), oldText, 2u, oldText, 2u);
   StaticRange* staticRange24 =
-      StaticRange::create(document(), oldText, 2, oldText, 4);
+      StaticRange::create(document(), oldText, 2u, oldText, 4u);
 
   Range* range04 = staticRange04->toRange(ASSERT_NO_EXCEPTION);
   Range* range02 = staticRange02->toRange(ASSERT_NO_EXCEPTION);
   Range* range22 = staticRange22->toRange(ASSERT_NO_EXCEPTION);
   Range* range24 = staticRange24->toRange(ASSERT_NO_EXCEPTION);
 
   oldText->splitText(2, ASSERT_NO_EXCEPTION);
   Text* newText = toText(oldText->nextSibling());
 
   // Range should mutate.
@@ skipping 18 matching lines @@
   EXPECT_EQ(2u, range22->endOffset());
 
   EXPECT_TRUE(range24->boundaryPointsValid());
   EXPECT_EQ(oldText, range24->startContainer());
   EXPECT_EQ(2u, range24->startOffset());
   EXPECT_EQ(newText, range24->endContainer());
   EXPECT_EQ(2u, range24->endOffset());
 
   // StaticRange shouldn't mutate.
   EXPECT_EQ(oldText, staticRange04->startContainer());
-  EXPECT_EQ(0, staticRange04->startOffset());
+  EXPECT_EQ(0u, staticRange04->startOffset());
   EXPECT_EQ(oldText, staticRange04->endContainer());
-  EXPECT_EQ(4, staticRange04->endOffset());
+  EXPECT_EQ(4u, staticRange04->endOffset());
 
   EXPECT_EQ(oldText, staticRange02->startContainer());
-  EXPECT_EQ(0, staticRange02->startOffset());
+  EXPECT_EQ(0u, staticRange02->startOffset());
   EXPECT_EQ(oldText, staticRange02->endContainer());
-  EXPECT_EQ(2, staticRange02->endOffset());
+  EXPECT_EQ(2u, staticRange02->endOffset());
 
   EXPECT_EQ(oldText, staticRange22->startContainer());
-  EXPECT_EQ(2, staticRange22->startOffset());
+  EXPECT_EQ(2u, staticRange22->startOffset());
   EXPECT_EQ(oldText, staticRange22->endContainer());
-  EXPECT_EQ(2, staticRange22->endOffset());
+  EXPECT_EQ(2u, staticRange22->endOffset());
 
   EXPECT_EQ(oldText, staticRange24->startContainer());
-  EXPECT_EQ(2, staticRange24->startOffset());
+  EXPECT_EQ(2u, staticRange24->startOffset());
   EXPECT_EQ(oldText, staticRange24->endContainer());
-  EXPECT_EQ(4, staticRange24->endOffset());
+  EXPECT_EQ(4u, staticRange24->endOffset());
 }
 
 TEST_F(StaticRangeTest, SplitTextNodeRangeOutsideText) {
   V8TestingScope scope;
   document().body()->setInnerHTML(
       "<span id=\"outer\">0<span id=\"inner-left\">1</span>SPLITME<span "
       "id=\"inner-right\">2</span>3</span>");
 
   Element* outer = document().getElementById(AtomicString::fromUTF8("outer"));
   Element* innerLeft =
       document().getElementById(AtomicString::fromUTF8("inner-left"));
   Element* innerRight =
       document().getElementById(AtomicString::fromUTF8("inner-right"));
   Text* oldText = toText(outer->childNodes()->item(2));
 
   StaticRange* staticRangeOuterOutside =
-      StaticRange::create(document(), outer, 0, outer, 5);
+      StaticRange::create(document(), outer, 0u, outer, 5u);
   StaticRange* staticRangeOuterInside =
-      StaticRange::create(document(), outer, 1, outer, 4);
+      StaticRange::create(document(), outer, 1u, outer, 4u);
   StaticRange* staticRangeOuterSurroundingText =
-      StaticRange::create(document(), outer, 2, outer, 3);
+      StaticRange::create(document(), outer, 2u, outer, 3u);
   StaticRange* staticRangeInnerLeft =
-      StaticRange::create(document(), innerLeft, 0, innerLeft, 1);
+      StaticRange::create(document(), innerLeft, 0u, innerLeft, 1u);
   StaticRange* staticRangeInnerRight =
-      StaticRange::create(document(), innerRight, 0, innerRight, 1);
+      StaticRange::create(document(), innerRight, 0u, innerRight, 1u);
   StaticRange* staticRangeFromTextToMiddleOfElement =
-      StaticRange::create(document(), oldText, 6, outer, 3);
+      StaticRange::create(document(), oldText, 6u, outer, 3u);
 
   Range* rangeOuterOutside =
       staticRangeOuterOutside->toRange(ASSERT_NO_EXCEPTION);
   Range* rangeOuterInside =
       staticRangeOuterInside->toRange(ASSERT_NO_EXCEPTION);
   Range* rangeOuterSurroundingText =
       staticRangeOuterSurroundingText->toRange(ASSERT_NO_EXCEPTION);
   Range* rangeInnerLeft = staticRangeInnerLeft->toRange(ASSERT_NO_EXCEPTION);
   Range* rangeInnerRight = staticRangeInnerRight->toRange(ASSERT_NO_EXCEPTION);
   Range* rangeFromTextToMiddleOfElement =
@@ skipping 36 matching lines @@
   EXPECT_EQ(1u, rangeInnerRight->endOffset());
 
   EXPECT_TRUE(rangeFromTextToMiddleOfElement->boundaryPointsValid());
   EXPECT_EQ(newText, rangeFromTextToMiddleOfElement->startContainer());
   EXPECT_EQ(3u, rangeFromTextToMiddleOfElement->startOffset());
   EXPECT_EQ(outer, rangeFromTextToMiddleOfElement->endContainer());
   EXPECT_EQ(4u, rangeFromTextToMiddleOfElement->endOffset());
 
   // StaticRange shouldn't mutate.
   EXPECT_EQ(outer, staticRangeOuterOutside->startContainer());
-  EXPECT_EQ(0, staticRangeOuterOutside->startOffset());
+  EXPECT_EQ(0u, staticRangeOuterOutside->startOffset());
   EXPECT_EQ(outer, staticRangeOuterOutside->endContainer());
-  EXPECT_EQ(5, staticRangeOuterOutside->endOffset());
+  EXPECT_EQ(5u, staticRangeOuterOutside->endOffset());
 
   EXPECT_EQ(outer, staticRangeOuterInside->startContainer());
-  EXPECT_EQ(1, staticRangeOuterInside->startOffset());
+  EXPECT_EQ(1u, staticRangeOuterInside->startOffset());
   EXPECT_EQ(outer, staticRangeOuterInside->endContainer());
-  EXPECT_EQ(4, staticRangeOuterInside->endOffset());
+  EXPECT_EQ(4u, staticRangeOuterInside->endOffset());
 
   EXPECT_EQ(outer, staticRangeOuterSurroundingText->startContainer());
-  EXPECT_EQ(2, staticRangeOuterSurroundingText->startOffset());
+  EXPECT_EQ(2u, staticRangeOuterSurroundingText->startOffset());
   EXPECT_EQ(outer, staticRangeOuterSurroundingText->endContainer());
-  EXPECT_EQ(3, staticRangeOuterSurroundingText->endOffset());
+  EXPECT_EQ(3u, staticRangeOuterSurroundingText->endOffset());
 
   EXPECT_EQ(innerLeft, staticRangeInnerLeft->startContainer());
-  EXPECT_EQ(0, staticRangeInnerLeft->startOffset());
+  EXPECT_EQ(0u, staticRangeInnerLeft->startOffset());
   EXPECT_EQ(innerLeft, staticRangeInnerLeft->endContainer());
-  EXPECT_EQ(1, staticRangeInnerLeft->endOffset());
+  EXPECT_EQ(1u, staticRangeInnerLeft->endOffset());
 
   EXPECT_EQ(innerRight, staticRangeInnerRight->startContainer());
-  EXPECT_EQ(0, staticRangeInnerRight->startOffset());
+  EXPECT_EQ(0u, staticRangeInnerRight->startOffset());
   EXPECT_EQ(innerRight, staticRangeInnerRight->endContainer());
-  EXPECT_EQ(1, staticRangeInnerRight->endOffset());
+  EXPECT_EQ(1u, staticRangeInnerRight->endOffset());
 
   EXPECT_EQ(oldText, staticRangeFromTextToMiddleOfElement->startContainer());
-  EXPECT_EQ(6, staticRangeFromTextToMiddleOfElement->startOffset());
+  EXPECT_EQ(6u, staticRangeFromTextToMiddleOfElement->startOffset());
   EXPECT_EQ(outer, staticRangeFromTextToMiddleOfElement->endContainer());
-  EXPECT_EQ(3, staticRangeFromTextToMiddleOfElement->endOffset());
+  EXPECT_EQ(3u, staticRangeFromTextToMiddleOfElement->endOffset());
 }
 
 TEST_F(StaticRangeTest, InvalidToRange) {
   V8TestingScope scope;
   document().body()->setInnerHTML("1234");
   Text* oldText = toText(document().body()->firstChild());
 
   StaticRange* staticRange04 =
-      StaticRange::create(document(), oldText, 0, oldText, 4);
+      StaticRange::create(document(), oldText, 0u, oldText, 4u);
 
   // Valid StaticRange.
   staticRange04->toRange(ASSERT_NO_EXCEPTION);
 
   oldText->splitText(2, ASSERT_NO_EXCEPTION);
   // StaticRange shouldn't mutate, endOffset() become invalid after splitText().
   EXPECT_EQ(oldText, staticRange04->startContainer());
-  EXPECT_EQ(0, staticRange04->startOffset());
+  EXPECT_EQ(0u, staticRange04->startOffset());
   EXPECT_EQ(oldText, staticRange04->endContainer());
-  EXPECT_EQ(4, staticRange04->endOffset());
+  EXPECT_EQ(4u, staticRange04->endOffset());
 
   // Invalid StaticRange.
   DummyExceptionStateForTesting exceptionState;
   staticRange04->toRange(exceptionState);
   EXPECT_TRUE(exceptionState.hadException());
 }
 
 }  // namespace blink