[base] Add wide string to number conversions

As a follow-up to r775075 this change introduces a Windows version of
string_number_conversions.h, which contains wide string overloads that
are only exposed on Windows. In order to facilitate code sharing with the
regular string number conversions, this change also adds
string_number_conversions_internal.h.

Furthermore, it performs some small clean-ups to simplify the template
logic and rely on more automatic type deductions.

Bug: 911896
Change-Id: I0ed8f8b73b8b78ccbe3a762b04a021c7b2a60ec2
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2231142
Commit-Queue: Jan Wilken Dörrie <jdoerrie@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#780735}

base/BUILD.gn

@@ -553,6 +553,7 @@ jumbo_component("base") {
     "strings/string16.h",
     "strings/string_number_conversions.cc",
     "strings/string_number_conversions.h",
+    "strings/string_number_conversions_internal.h",
     "strings/string_piece.cc",
     "strings/string_piece.h",
     "strings/string_piece_forward.h",
@@ -937,6 +938,8 @@ jumbo_component("base") {
       "scoped_clear_last_error_win.cc",
       "strings/strcat_win.cc",
       "strings/strcat_win.h",
+      "strings/string_number_conversions_win.cc",
+      "strings/string_number_conversions_win.h",
       "strings/string_split_win.cc",
       "strings/string_split_win.h",
       "strings/string_util_win.cc",

base/strings/string_number_conversions.h

@@ -20,10 +20,6 @@
 // ----------------------------------------------------------------------------
 // IMPORTANT MESSAGE FROM YOUR SPONSOR
 //
-// This file contains no "wstring" variants. New code should use string16. If
-// you need to make old code work, use the UTF8 version and convert. Please do
-// not add wstring variants.
-//
 // Please do not add "convenience" functions for converting strings to integers
 // that return the value and ignore success/failure. That encourages people to
 // write code that doesn't properly handle the error conditions.
@@ -154,4 +150,8 @@ BASE_EXPORT bool HexStringToSpan(StringPiece input, base::span<uint8_t> output);
 
 }  // namespace base
 
+#if defined(OS_WIN)
+#include "base/strings/string_number_conversions_win.h"
+#endif
+
 #endif  // BASE_STRINGS_STRING_NUMBER_CONVERSIONS_H_

base/strings/string_number_conversions_internal.h

+// Copyright 2020 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.
+
+#ifndef BASE_STRINGS_STRING_NUMBER_CONVERSIONS_INTERNAL_H_
+#define BASE_STRINGS_STRING_NUMBER_CONVERSIONS_INTERNAL_H_
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <wctype.h>
+
+#include <limits>
+
+#include "base/check_op.h"
+#include "base/logging.h"
+#include "base/no_destructor.h"
+#include "base/numerics/safe_math.h"
+#include "base/strings/string_util.h"
+#include "base/third_party/double_conversion/double-conversion/double-conversion.h"
+
+namespace base {
+
+namespace internal {
+
+template <typename STR, typename INT>
+static STR IntToStringT(INT value) {
+  // log10(2) ~= 0.3 bytes needed per bit or per byte log10(2**8) ~= 2.4.
+  // So round up to allocate 3 output characters per byte, plus 1 for '-'.
+  const size_t kOutputBufSize =
+      3 * sizeof(INT) + std::numeric_limits<INT>::is_signed;
+
+  // Create the string in a temporary buffer, write it back to front, and
+  // then return the substr of what we ended up using.
+  using CHR = typename STR::value_type;
+  CHR outbuf[kOutputBufSize];
+
+  // The ValueOrDie call below can never fail, because UnsignedAbs is valid
+  // for all valid inputs.
+  std::make_unsigned_t<INT> res =
+      CheckedNumeric<INT>(value).UnsignedAbs().ValueOrDie();
+
+  CHR* end = outbuf + kOutputBufSize;
+  CHR* i = end;
+  do {
+    --i;
+    DCHECK(i != outbuf);
+    *i = static_cast<CHR>((res % 10) + '0');
+    res /= 10;
+  } while (res != 0);
+  if (IsValueNegative(value)) {
+    --i;
+    DCHECK(i != outbuf);
+    *i = static_cast<CHR>('-');
+  }
+  return STR(i, end);
+}
+
+// Utility to convert a character to a digit in a given base
+template <int BASE, typename CHAR>
+Optional<uint8_t> CharToDigit(CHAR c) {
+  static_assert(1 <= BASE && BASE <= 36, "BASE needs to be in [1, 36]");
+  if (c >= '0' && c < '0' + std::min(BASE, 10))
+    return c - '0';
+
+  if (c >= 'a' && c < 'a' + BASE - 10)
+    return c - 'a' + 10;
+
+  if (c >= 'A' && c < 'A' + BASE - 10)
+    return c - 'A' + 10;
+
+  return base::nullopt;
+}
+
+// There is an IsUnicodeWhitespace for wchars defined in string_util.h, but it
+// is locale independent, whereas the functions we are replacing were
+// locale-dependent. TBD what is desired, but for the moment let's not
+// introduce a change in behaviour.
+template <typename CHAR>
+class WhitespaceHelper {};
+
+template <>
+class WhitespaceHelper<char> {
+ public:
+  static bool Invoke(char c) {
+    return 0 != isspace(static_cast<unsigned char>(c));
+  }
+};
+
+template <>
+class WhitespaceHelper<char16> {
+ public:
+  static bool Invoke(char16 c) { return 0 != iswspace(c); }
+};
+
+template <typename CHAR>
+bool LocalIsWhitespace(CHAR c) {
+  return WhitespaceHelper<CHAR>::Invoke(c);
+}
+
+template <typename Number, int kBase>
+class StringToNumberParser {
+ public:
+  struct Result {
+    Number value = 0;
+    bool valid = false;
+  };
+
+  static constexpr Number kMin = std::numeric_limits<Number>::min();
+  static constexpr Number kMax = std::numeric_limits<Number>::max();
+
+  // Sign provides:
+  //  - a static function, CheckBounds, that determines whether the next digit
+  //    causes an overflow/underflow
+  //  - a static function, Increment, that appends the next digit appropriately
+  //    according to the sign of the number being parsed.
+  template <typename Sign>
+  class Base {
+   public:
+    template <typename Iter>
+    static Result Invoke(Iter begin, Iter end) {
+      Number value = 0;
+
+      if (begin == end) {
+        return {value, false};
+      }
+
+      // Note: no performance difference was found when using template
+      // specialization to remove this check in bases other than 16
+      if (kBase == 16 && end - begin > 2 && *begin == '0' &&
+          (*(begin + 1) == 'x' || *(begin + 1) == 'X')) {
+        begin += 2;
+      }
+
+      for (Iter current = begin; current != end; ++current) {
+        Optional<uint8_t> new_digit = CharToDigit<kBase>(*current);
+
+        if (!new_digit) {
+          return {value, false};
+        }
+
+        if (current != begin) {
+          Result result = Sign::CheckBounds(value, *new_digit);
+          if (!result.valid)
+            return result;
+
+          value *= kBase;
+        }
+
+        value = Sign::Increment(value, *new_digit);
+      }
+      return {value, true};
+    }
+  };
+
+  class Positive : public Base<Positive> {
+   public:
+    static Result CheckBounds(Number value, uint8_t new_digit) {
+      if (value > static_cast<Number>(kMax / kBase) ||
+          (value == static_cast<Number>(kMax / kBase) &&
+           new_digit > kMax % kBase)) {
+        return {kMax, false};
+      }
+      return {value, true};
+    }
+    static Number Increment(Number lhs, uint8_t rhs) { return lhs + rhs; }
+  };
+
+  class Negative : public Base<Negative> {
+   public:
+    static Result CheckBounds(Number value, uint8_t new_digit) {
+      if (value < kMin / kBase ||
+          (value == kMin / kBase && new_digit > 0 - kMin % kBase)) {
+        return {kMin, false};
+      }
+      return {value, true};
+    }
+    static Number Increment(Number lhs, uint8_t rhs) { return lhs - rhs; }
+  };
+};
+
+template <typename Number, int kBase, typename Str>
+auto StringToNumber(BasicStringPiece<Str> input) {
+  using Parser = StringToNumberParser<Number, kBase>;
+  using Result = typename Parser::Result;
+
+  bool has_leading_whitespace = false;
+  auto begin = input.begin();
+  auto end = input.end();
+
+  while (begin != end && LocalIsWhitespace(*begin)) {
+    has_leading_whitespace = true;
+    ++begin;
+  }
+
+  if (begin != end && *begin == '-') {
+    if (!std::numeric_limits<Number>::is_signed) {
+      return Result{0, false};
+    }
+
+    Result result = Parser::Negative::Invoke(begin + 1, end);
+    result.valid &= !has_leading_whitespace;
+    return result;
+  }
+
+  if (begin != end && *begin == '+') {
+    ++begin;
+  }
+
+  Result result = Parser::Positive::Invoke(begin, end);
+  result.valid &= !has_leading_whitespace;
+  return result;
+}
+
+template <typename STR, typename VALUE>
+bool StringToIntImpl(BasicStringPiece<STR> input, VALUE& output) {
+  auto result = StringToNumber<VALUE, 10>(input);
+  output = result.value;
+  return result.valid;
+}
+
+template <typename STR, typename VALUE>
+bool HexStringToIntImpl(BasicStringPiece<STR> input, VALUE& output) {
+  auto result = StringToNumber<VALUE, 16>(input);
+  output = result.value;
+  return result.valid;
+}
+
+static const double_conversion::DoubleToStringConverter*
+GetDoubleToStringConverter() {
+  static NoDestructor<double_conversion::DoubleToStringConverter> converter(
+      double_conversion::DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN,
+      nullptr, nullptr, 'e', -6, 12, 0, 0);
+  return converter.get();
+}
+
+// Converts a given (data, size) pair to a desired string type. For
+// performance reasons, this dispatches to a different constructor if the
+// passed-in data matches the string's value_type.
+template <typename StringT>
+StringT ToString(const typename StringT::value_type* data, size_t size) {
+  return StringT(data, size);
+}
+
+template <typename StringT, typename CharT>
+StringT ToString(const CharT* data, size_t size) {
+  return StringT(data, data + size);
+}
+
+template <typename StringT>
+StringT DoubleToStringT(double value) {
+  char buffer[32];
+  double_conversion::StringBuilder builder(buffer, sizeof(buffer));
+  GetDoubleToStringConverter()->ToShortest(value, &builder);
+  return ToString<StringT>(buffer, builder.position());
+}
+
+template <typename STRING, typename CHAR>
+bool StringToDoubleImpl(STRING input, const CHAR* data, double& output) {
+  static NoDestructor<double_conversion::StringToDoubleConverter> converter(
+      double_conversion::StringToDoubleConverter::ALLOW_LEADING_SPACES |
+          double_conversion::StringToDoubleConverter::ALLOW_TRAILING_JUNK,
+      0.0, 0, nullptr, nullptr);
+
+  int processed_characters_count;
+  output = converter->StringToDouble(data, input.size(),
+                                     &processed_characters_count);
+
+  // Cases to return false:
+  //  - If the input string is empty, there was nothing to parse.
+  //  - If the value saturated to HUGE_VAL.
+  //  - If the entire string was not processed, there are either characters
+  //    remaining in the string after a parsed number, or the string does not
+  //    begin with a parseable number.
+  //  - If the first character is a space, there was leading whitespace
+  return !input.empty() && output != HUGE_VAL && output != -HUGE_VAL &&
+         static_cast<size_t>(processed_characters_count) == input.size() &&
+         !IsUnicodeWhitespace(input[0]);
+}
+
+template <typename OutIter>
+static bool HexStringToByteContainer(StringPiece input, OutIter output) {
+  size_t count = input.size();
+  if (count == 0 || (count % 2) != 0)
+    return false;
+  for (uintptr_t i = 0; i < count / 2; ++i) {
+    // most significant 4 bits
+    Optional<uint8_t> msb = CharToDigit<16>(input[i * 2]);
+    // least significant 4 bits
+    Optional<uint8_t> lsb = CharToDigit<16>(input[i * 2 + 1]);
+    if (!msb || !lsb) {
+      return false;
+    }
+    *(output++) = (*msb << 4) | *lsb;
+  }
+  return true;
+}
+
+}  // namespace internal
+
+}  // namespace base
+
+#endif  // BASE_STRINGS_STRING_NUMBER_CONVERSIONS_INTERNAL_H_

base/strings/string_number_conversions_win.cc

+// Copyright 2020 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 "base/strings/string_number_conversions_win.h"
+
+#include <string>
+
+#include "base/strings/string_number_conversions_internal.h"
+#include "base/strings/string_piece.h"
+
+namespace base {
+
+std::wstring NumberToWString(int value) {
+  return internal::IntToStringT<std::wstring>(value);
+}
+
+std::wstring NumberToWString(unsigned value) {
+  return internal::IntToStringT<std::wstring>(value);
+}
+
+std::wstring NumberToWString(long value) {
+  return internal::IntToStringT<std::wstring>(value);
+}
+
+std::wstring NumberToWString(unsigned long value) {
+  return internal::IntToStringT<std::wstring>(value);
+}
+
+std::wstring NumberToWString(long long value) {
+  return internal::IntToStringT<std::wstring>(value);
+}
+
+std::wstring NumberToWString(unsigned long long value) {
+  return internal::IntToStringT<std::wstring>(value);
+}
+
+std::wstring NumberToWString(double value) {
+  return internal::DoubleToStringT<std::wstring>(value);
+}
+
+#if defined(BASE_STRING16_IS_STD_U16STRING)
+namespace internal {
+
+template <>
+class WhitespaceHelper<wchar_t> {
+ public:
+  static bool Invoke(wchar_t c) { return 0 != iswspace(c); }
+};
+
+}  // namespace internal
+
+bool StringToInt(WStringPiece input, int* output) {
+  return internal::StringToIntImpl(input, *output);
+}
+
+bool StringToUint(WStringPiece input, unsigned* output) {
+  return internal::StringToIntImpl(input, *output);
+}
+
+bool StringToInt64(WStringPiece input, int64_t* output) {
+  return internal::StringToIntImpl(input, *output);
+}
+
+bool StringToUint64(WStringPiece input, uint64_t* output) {
+  return internal::StringToIntImpl(input, *output);
+}
+
+bool StringToSizeT(WStringPiece input, size_t* output) {
+  return internal::StringToIntImpl(input, *output);
+}
+
+bool StringToDouble(WStringPiece input, double* output) {
+  return internal::StringToDoubleImpl(
+      input, reinterpret_cast<const uint16_t*>(input.data()), *output);
+}
+#endif  // defined(BASE_STRING16_IS_STD_U16STRING)
+
+}  // namespace base

base/strings/string_number_conversions_win.h

+// Copyright 2020 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.
+
+#ifndef BASE_STRINGS_STRING_NUMBER_CONVERSIONS_WIN_H_
+#define BASE_STRINGS_STRING_NUMBER_CONVERSIONS_WIN_H_
+
+#include <string>
+
+#include "base/base_export.h"
+#include "base/strings/string_piece.h"
+
+namespace base {
+
+BASE_EXPORT std::wstring NumberToWString(int value);
+BASE_EXPORT std::wstring NumberToWString(unsigned int value);
+BASE_EXPORT std::wstring NumberToWString(long value);
+BASE_EXPORT std::wstring NumberToWString(unsigned long value);
+BASE_EXPORT std::wstring NumberToWString(long long value);
+BASE_EXPORT std::wstring NumberToWString(unsigned long long value);
+BASE_EXPORT std::wstring NumberToWString(double value);
+
+// The following section contains overloads of the cross-platform APIs for
+// std::wstring and base::WStringPiece. These are only enabled if std::wstring
+// and base::string16 are distinct types, as otherwise this would result in an
+// ODR violation.
+// TODO(crbug.com/911896): Remove those guards once base::string16 is
+// std::u16string.
+#if defined(BASE_STRING16_IS_STD_U16STRING)
+BASE_EXPORT bool StringToInt(WStringPiece input, int* output);
+BASE_EXPORT bool StringToUint(WStringPiece input, unsigned* output);
+BASE_EXPORT bool StringToInt64(WStringPiece input, int64_t* output);
+BASE_EXPORT bool StringToUint64(WStringPiece input, uint64_t* output);
+BASE_EXPORT bool StringToSizeT(WStringPiece input, size_t* output);
+BASE_EXPORT bool StringToDouble(WStringPiece input, double* output);
+#endif  // defined(BASE_STRING16_IS_STD_U16STRING)
+
+}  // namespace base
+
+#endif  // BASE_STRINGS_STRING_NUMBER_CONVERSIONS_WIN_H_