Introduce blink::String::HexToUIntStrict(), and remove |base| arguments.

The default value of |base| is 10, and only one instance with base=16
exists. This CL adds String::HexToUIntStrict(), and remove |base| arguments of
the following integer parsing functions:

- String::ToIntStrict()
- String::ToUIntStrict()
- String::ToInt64Strict()
- String::ToUInt64Strict()
- StringImpl::ToIntStrict()
- StringImpl::ToUIntStrict()
- StringImpl::ToInt64Strict()
- StringImpl::ToUInt64Strict()
- CharactersToIntStrict()
- CharactersToUIntStrict()
- CharactersToInt64Strict()
- CharactersToUInt64Strict()

Bug: 746157
Change-Id: If269771609e674d9f1baa279c0ed4954a14b7bc6
Reviewed-on: https://chromium-review.googlesource.com/578536
Commit-Queue: Yuta Kitamura <yutak@chromium.org>
Reviewed-by: Yuta Kitamura <yutak@chromium.org>
Cr-Commit-Position: refs/heads/master@{#488167}

third_party/WebKit/Source/core/css/parser/CSSTokenizer.cpp

@@ -620,7 +620,7 @@ UChar32 CSSTokenizer::ConsumeEscape() {
     };
     ConsumeSingleWhitespaceIfNext();
     bool ok = false;
-    UChar32 code_point = hex_chars.ToString().ToUIntStrict(&ok, 16);
+    UChar32 code_point = hex_chars.ToString().HexToUIntStrict(&ok);
     DCHECK(ok);
     if (code_point == 0 || (0xD800 <= code_point && code_point <= 0xDFFF) ||
         code_point > 0x10FFFF)

third_party/WebKit/Source/platform/wtf/text/StringImpl.cpp

@@ -952,28 +952,34 @@ RefPtr<StringImpl> StringImpl::SimplifyWhiteSpace(
       UCharPredicate(is_white_space), strip_behavior);
 }
 
-int StringImpl::ToIntStrict(bool* ok, int base) {
+int StringImpl::ToIntStrict(bool* ok) {
   if (Is8Bit())
-    return CharactersToIntStrict(Characters8(), length_, ok, base);
-  return CharactersToIntStrict(Characters16(), length_, ok, base);
+    return CharactersToIntStrict(Characters8(), length_, ok);
+  return CharactersToIntStrict(Characters16(), length_, ok);
 }
 
-unsigned StringImpl::ToUIntStrict(bool* ok, int base) {
+unsigned StringImpl::ToUIntStrict(bool* ok) {
   if (Is8Bit())
-    return CharactersToUIntStrict(Characters8(), length_, ok, base);
-  return CharactersToUIntStrict(Characters16(), length_, ok, base);
+    return CharactersToUIntStrict(Characters8(), length_, ok);
+  return CharactersToUIntStrict(Characters16(), length_, ok);
 }
 
-int64_t StringImpl::ToInt64Strict(bool* ok, int base) {
+unsigned StringImpl::HexToUIntStrict(bool* ok) {
   if (Is8Bit())
-    return CharactersToInt64Strict(Characters8(), length_, ok, base);
-  return CharactersToInt64Strict(Characters16(), length_, ok, base);
+    return HexCharactersToUIntStrict(Characters8(), length_, ok);
+  return HexCharactersToUIntStrict(Characters16(), length_, ok);
 }
 
-uint64_t StringImpl::ToUInt64Strict(bool* ok, int base) {
+int64_t StringImpl::ToInt64Strict(bool* ok) {
   if (Is8Bit())
-    return CharactersToUInt64Strict(Characters8(), length_, ok, base);
-  return CharactersToUInt64Strict(Characters16(), length_, ok, base);
+    return CharactersToInt64Strict(Characters8(), length_, ok);
+  return CharactersToInt64Strict(Characters16(), length_, ok);
+}
+
+uint64_t StringImpl::ToUInt64Strict(bool* ok) {
+  if (Is8Bit())
+    return CharactersToUInt64Strict(Characters8(), length_, ok);
+  return CharactersToUInt64Strict(Characters16(), length_, ok);
 }
 
 int StringImpl::ToInt(bool* ok) {

third_party/WebKit/Source/platform/wtf/text/StringImpl.h

@@ -306,10 +306,11 @@ class WTF_EXPORT StringImpl {
 
   bool ContainsOnlyWhitespace();
 
-  int ToIntStrict(bool* ok = 0, int base = 10);
-  unsigned ToUIntStrict(bool* ok = 0, int base = 10);
-  int64_t ToInt64Strict(bool* ok = 0, int base = 10);
-  uint64_t ToUInt64Strict(bool* ok = 0, int base = 10);
+  int ToIntStrict(bool* ok = 0);
+  unsigned ToUIntStrict(bool* ok = 0);
+  unsigned HexToUIntStrict(bool* ok);
+  int64_t ToInt64Strict(bool* ok = 0);
+  uint64_t ToUInt64Strict(bool* ok = 0);
 
   int ToInt(bool* ok = 0);          // ignores trailing garbage
   unsigned ToUInt(bool* ok = 0);    // ignores trailing garbage

third_party/WebKit/Source/platform/wtf/text/StringToNumber.cpp

@@ -11,25 +11,23 @@
 
 namespace WTF {
 
-static bool IsCharacterAllowedInBase(UChar c, int base) {
-  if (c > 0x7F)
-    return false;
-  if (IsASCIIDigit(c))
-    return c - '0' < base;
-  if (IsASCIIAlpha(c)) {
-    if (base > 36)
-      base = 36;
-    return (c >= 'a' && c < 'a' + base - 10) ||
-           (c >= 'A' && c < 'A' + base - 10);
-  }
-  return false;
+template <int base>
+bool IsCharacterAllowedInBase(UChar);
+
+template <>
+bool IsCharacterAllowedInBase<10>(UChar c) {
+  return IsASCIIDigit(c);
 }
 
-template <typename IntegralType, typename CharType>
+template <>
+bool IsCharacterAllowedInBase<16>(UChar c) {
+  return IsASCIIHexDigit(c);
+}
+
+template <typename IntegralType, typename CharType, int base>
 static inline IntegralType ToIntegralType(const CharType* data,
                                           size_t length,
-                                          NumberParsingState* parsing_state,
-                                          int base) {
+                                          NumberParsingState* parsing_state) {
   static_assert(std::is_integral<IntegralType>::value,
                 "IntegralType must be an integral type.");
   static constexpr IntegralType kIntegralMax =
@@ -63,10 +61,10 @@ static inline IntegralType ToIntegralType(const CharType* data,
     ++data;
   }
 
-  if (!length || !IsCharacterAllowedInBase(*data, base))
+  if (!length || !IsCharacterAllowedInBase<base>(*data))
     goto bye;
 
-  while (length && IsCharacterAllowedInBase(*data, base)) {
+  while (length && IsCharacterAllowedInBase<base>(*data)) {
     --length;
     IntegralType digit_value;
     CharType c = *data;
@@ -125,14 +123,13 @@ bye:
   return state == NumberParsingState::kSuccess ? value : 0;
 }
 
-template <typename IntegralType, typename CharType>
+template <typename IntegralType, typename CharType, int base>
 static inline IntegralType ToIntegralType(const CharType* data,
                                           size_t length,
-                                          bool* ok,
-                                          int base) {
+                                          bool* ok) {
   NumberParsingState state;
   IntegralType value =
-      ToIntegralType<IntegralType, CharType>(data, length, &state, base);
+      ToIntegralType<IntegralType, CharType, base>(data, length, &state);
   if (ok)
     *ok = state == NumberParsingState::kSuccess;
   return value;
@@ -165,109 +162,93 @@ static unsigned LengthOfCharactersAsInteger(const CharType* data,
 unsigned CharactersToUIntStrict(const LChar* data,
                                 size_t length,
                                 NumberParsingState* state) {
-  return ToIntegralType<unsigned, LChar>(data, length, state, 10);
+  return ToIntegralType<unsigned, LChar, 10>(data, length, state);
 }
 
 unsigned CharactersToUIntStrict(const UChar* data,
                                 size_t length,
                                 NumberParsingState* state) {
-  return ToIntegralType<unsigned, UChar>(data, length, state, 10);
+  return ToIntegralType<unsigned, UChar, 10>(data, length, state);
 }
 
-int CharactersToIntStrict(const LChar* data,
-                          size_t length,
-                          bool* ok,
-                          int base) {
-  return ToIntegralType<int, LChar>(data, length, ok, base);
+int CharactersToIntStrict(const LChar* data, size_t length, bool* ok) {
+  return ToIntegralType<int, LChar, 10>(data, length, ok);
 }
 
-int CharactersToIntStrict(const UChar* data,
-                          size_t length,
-                          bool* ok,
-                          int base) {
-  return ToIntegralType<int, UChar>(data, length, ok, base);
+int CharactersToIntStrict(const UChar* data, size_t length, bool* ok) {
+  return ToIntegralType<int, UChar, 10>(data, length, ok);
 }
 
-unsigned CharactersToUIntStrict(const LChar* data,
-                                size_t length,
-                                bool* ok,
-                                int base) {
-  return ToIntegralType<unsigned, LChar>(data, length, ok, base);
+unsigned CharactersToUIntStrict(const LChar* data, size_t length, bool* ok) {
+  return ToIntegralType<unsigned, LChar, 10>(data, length, ok);
 }
 
-unsigned CharactersToUIntStrict(const UChar* data,
-                                size_t length,
-                                bool* ok,
-                                int base) {
-  return ToIntegralType<unsigned, UChar>(data, length, ok, base);
+unsigned CharactersToUIntStrict(const UChar* data, size_t length, bool* ok) {
+  return ToIntegralType<unsigned, UChar, 10>(data, length, ok);
 }
 
-int64_t CharactersToInt64Strict(const LChar* data,
-                                size_t length,
-                                bool* ok,
-                                int base) {
-  return ToIntegralType<int64_t, LChar>(data, length, ok, base);
+unsigned HexCharactersToUIntStrict(const LChar* data, size_t length, bool* ok) {
+  return ToIntegralType<unsigned, LChar, 16>(data, length, ok);
 }
 
-int64_t CharactersToInt64Strict(const UChar* data,
-                                size_t length,
-                                bool* ok,
-                                int base) {
-  return ToIntegralType<int64_t, UChar>(data, length, ok, base);
+unsigned HexCharactersToUIntStrict(const UChar* data, size_t length, bool* ok) {
+  return ToIntegralType<unsigned, UChar, 16>(data, length, ok);
 }
 
-uint64_t CharactersToUInt64Strict(const LChar* data,
-                                  size_t length,
-                                  bool* ok,
-                                  int base) {
-  return ToIntegralType<uint64_t, LChar>(data, length, ok, base);
+int64_t CharactersToInt64Strict(const LChar* data, size_t length, bool* ok) {
+  return ToIntegralType<int64_t, LChar, 10>(data, length, ok);
 }
 
-uint64_t CharactersToUInt64Strict(const UChar* data,
-                                  size_t length,
-                                  bool* ok,
-                                  int base) {
-  return ToIntegralType<uint64_t, UChar>(data, length, ok, base);
+int64_t CharactersToInt64Strict(const UChar* data, size_t length, bool* ok) {
+  return ToIntegralType<int64_t, UChar, 10>(data, length, ok);
+}
+
+uint64_t CharactersToUInt64Strict(const LChar* data, size_t length, bool* ok) {
+  return ToIntegralType<uint64_t, LChar, 10>(data, length, ok);
+}
+
+uint64_t CharactersToUInt64Strict(const UChar* data, size_t length, bool* ok) {
+  return ToIntegralType<uint64_t, UChar, 10>(data, length, ok);
 }
 
 int CharactersToInt(const LChar* data, size_t length, bool* ok) {
-  return ToIntegralType<int, LChar>(
-      data, LengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
+  return ToIntegralType<int, LChar, 10>(
+      data, LengthOfCharactersAsInteger<LChar>(data, length), ok);
 }
 
 int CharactersToInt(const UChar* data, size_t length, bool* ok) {
-  return ToIntegralType<int, UChar>(
-      data, LengthOfCharactersAsInteger(data, length), ok, 10);
+  return ToIntegralType<int, UChar, 10>(
+      data, LengthOfCharactersAsInteger(data, length), ok);
 }
 
 unsigned CharactersToUInt(const LChar* data, size_t length, bool* ok) {
-  return ToIntegralType<unsigned, LChar>(
-      data, LengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
+  return ToIntegralType<unsigned, LChar, 10>(
+      data, LengthOfCharactersAsInteger<LChar>(data, length), ok);
 }
 
 unsigned CharactersToUInt(const UChar* data, size_t length, bool* ok) {
-  return ToIntegralType<unsigned, UChar>(
-      data, LengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
+  return ToIntegralType<unsigned, UChar, 10>(
+      data, LengthOfCharactersAsInteger<UChar>(data, length), ok);
 }
 
 int64_t CharactersToInt64(const LChar* data, size_t length, bool* ok) {
-  return ToIntegralType<int64_t, LChar>(
-      data, LengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
+  return ToIntegralType<int64_t, LChar, 10>(
+      data, LengthOfCharactersAsInteger<LChar>(data, length), ok);
 }
 
 int64_t CharactersToInt64(const UChar* data, size_t length, bool* ok) {
-  return ToIntegralType<int64_t, UChar>(
-      data, LengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
+  return ToIntegralType<int64_t, UChar, 10>(
+      data, LengthOfCharactersAsInteger<UChar>(data, length), ok);
 }
 
 uint64_t CharactersToUInt64(const LChar* data, size_t length, bool* ok) {
-  return ToIntegralType<uint64_t, LChar>(
-      data, LengthOfCharactersAsInteger<LChar>(data, length), ok, 10);
+  return ToIntegralType<uint64_t, LChar, 10>(
+      data, LengthOfCharactersAsInteger<LChar>(data, length), ok);
 }
 
 uint64_t CharactersToUInt64(const UChar* data, size_t length, bool* ok) {
-  return ToIntegralType<uint64_t, UChar>(
-      data, LengthOfCharactersAsInteger<UChar>(data, length), ok, 10);
+  return ToIntegralType<uint64_t, UChar, 10>(
+      data, LengthOfCharactersAsInteger<UChar>(data, length), ok);
 }
 
 enum TrailingJunkPolicy { kDisallowTrailingJunk, kAllowTrailingJunk };

third_party/WebKit/Source/platform/wtf/text/StringToNumber.h

@@ -11,14 +11,8 @@
 namespace WTF {
 
 // string -> int.
-WTF_EXPORT int CharactersToIntStrict(const LChar*,
-                                     size_t,
-                                     bool* ok = 0,
-                                     int base = 10);
-WTF_EXPORT int CharactersToIntStrict(const UChar*,
-                                     size_t,
-                                     bool* ok = 0,
-                                     int base = 10);
+WTF_EXPORT int CharactersToIntStrict(const LChar*, size_t, bool* ok = 0);
+WTF_EXPORT int CharactersToIntStrict(const UChar*, size_t, bool* ok = 0);
 WTF_EXPORT int CharactersToInt(const LChar*,
                                size_t,
                                bool* ok = 0);  // ignores trailing garbage
@@ -38,14 +32,10 @@ enum class NumberParsingState {
 
 // string -> unsigned.
 // These functions do not accept "-0".
-WTF_EXPORT unsigned CharactersToUIntStrict(const LChar*,
-                                           size_t,
-                                           bool* ok = 0,
-                                           int base = 10);
-WTF_EXPORT unsigned CharactersToUIntStrict(const UChar*,
-                                           size_t,
-                                           bool* ok = 0,
-                                           int base = 10);
+WTF_EXPORT unsigned CharactersToUIntStrict(const LChar*, size_t, bool* ok = 0);
+WTF_EXPORT unsigned CharactersToUIntStrict(const UChar*, size_t, bool* ok = 0);
+WTF_EXPORT unsigned HexCharactersToUIntStrict(const LChar*, size_t, bool* ok);
+WTF_EXPORT unsigned HexCharactersToUIntStrict(const UChar*, size_t, bool* ok);
 WTF_EXPORT unsigned CharactersToUInt(const LChar*,
                                      size_t,
                                      bool* ok = 0);  // ignores trailing garbage
@@ -63,14 +53,8 @@ WTF_EXPORT unsigned CharactersToUIntStrict(const UChar*,
                                            NumberParsingState*);
 
 // string -> int64_t.
-WTF_EXPORT int64_t CharactersToInt64Strict(const LChar*,
-                                           size_t,
-                                           bool* ok = 0,
-                                           int base = 10);
-WTF_EXPORT int64_t CharactersToInt64Strict(const UChar*,
-                                           size_t,
-                                           bool* ok = 0,
-                                           int base = 10);
+WTF_EXPORT int64_t CharactersToInt64Strict(const LChar*, size_t, bool* ok = 0);
+WTF_EXPORT int64_t CharactersToInt64Strict(const UChar*, size_t, bool* ok = 0);
 WTF_EXPORT int64_t CharactersToInt64(const LChar*,
                                      size_t,
                                      bool* ok = 0);  // ignores trailing garbage
@@ -82,12 +66,10 @@ WTF_EXPORT int64_t CharactersToInt64(const UChar*,
 // These functions do not accept "-0".
 WTF_EXPORT uint64_t CharactersToUInt64Strict(const LChar*,
                                              size_t,
-                                             bool* ok = 0,
-                                             int base = 10);
+                                             bool* ok = 0);
 WTF_EXPORT uint64_t CharactersToUInt64Strict(const UChar*,
                                              size_t,
-                                             bool* ok = 0,
-                                             int base = 10);
+                                             bool* ok = 0);
 WTF_EXPORT uint64_t
 CharactersToUInt64(const LChar*,
                    size_t,

third_party/WebKit/Source/platform/wtf/text/WTFString.cpp

@@ -420,40 +420,49 @@ String String::NumberToStringFixedWidth(double number,
   return String(NumberToFixedWidthString(number, decimal_places, buffer));
 }
 
-int String::ToIntStrict(bool* ok, int base) const {
+int String::ToIntStrict(bool* ok) const {
   if (!impl_) {
     if (ok)
       *ok = false;
     return 0;
   }
-  return impl_->ToIntStrict(ok, base);
+  return impl_->ToIntStrict(ok);
 }
 
-unsigned String::ToUIntStrict(bool* ok, int base) const {
+unsigned String::ToUIntStrict(bool* ok) const {
   if (!impl_) {
     if (ok)
       *ok = false;
     return 0;
   }
-  return impl_->ToUIntStrict(ok, base);
+  return impl_->ToUIntStrict(ok);
 }
 
-int64_t String::ToInt64Strict(bool* ok, int base) const {
+unsigned String::HexToUIntStrict(bool* ok) const {
   if (!impl_) {
     if (ok)
       *ok = false;
     return 0;
   }
-  return impl_->ToInt64Strict(ok, base);
+  return impl_->HexToUIntStrict(ok);
 }
 
-uint64_t String::ToUInt64Strict(bool* ok, int base) const {
+int64_t String::ToInt64Strict(bool* ok) const {
   if (!impl_) {
     if (ok)
       *ok = false;
     return 0;
   }
-  return impl_->ToUInt64Strict(ok, base);
+  return impl_->ToInt64Strict(ok);
+}
+
+uint64_t String::ToUInt64Strict(bool* ok) const {
+  if (!impl_) {
+    if (ok)
+      *ok = false;
+    return 0;
+  }
+  return impl_->ToUInt64Strict(ok);
 }
 
 int String::ToInt(bool* ok) const {

third_party/WebKit/Source/platform/wtf/text/WTFString.h

@@ -373,10 +373,11 @@ class WTF_EXPORT String {
 
   // Convert the string into a number.
 
-  int ToIntStrict(bool* ok = 0, int base = 10) const;
-  unsigned ToUIntStrict(bool* ok = 0, int base = 10) const;
-  int64_t ToInt64Strict(bool* ok = 0, int base = 10) const;
-  uint64_t ToUInt64Strict(bool* ok = 0, int base = 10) const;
+  int ToIntStrict(bool* ok = 0) const;
+  unsigned ToUIntStrict(bool* ok = 0) const;
+  unsigned HexToUIntStrict(bool* ok) const;
+  int64_t ToInt64Strict(bool* ok = 0) const;
+  uint64_t ToUInt64Strict(bool* ok = 0) const;
 
   int ToInt(bool* ok = 0) const;
   unsigned ToUInt(bool* ok = 0) const;