Adopt absl::string_view in rtc_base/string_to_number.*

Bug: webrtc:13579
Change-Id: I7e1a8ad6c493c9c0ac20c493d2467f0a2eda26d9
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/256720
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Niels Moller <nisse@webrtc.org>
Commit-Queue: Ali Tofigh <alito@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36340}

rtc_base/string_to_number.cc

@@ -20,30 +20,41 @@
 namespace rtc {
 namespace string_to_number_internal {
 
-absl::optional<signed_type> ParseSigned(const char* str, int base) {
-  RTC_DCHECK(str);
+absl::optional<signed_type> ParseSigned(absl::string_view str, int base) {
+  if (str.empty())
+    return absl::nullopt;
+
   if (isdigit(str[0]) || str[0] == '-') {
+    std::string str_str = std::string(str);
     char* end = nullptr;
     errno = 0;
-    const signed_type value = std::strtoll(str, &end, base);
-    if (end && *end == '\0' && errno == 0) {
+    const signed_type value = std::strtoll(str_str.c_str(), &end, base);
+    // Check for errors and also make sure that there were no embedded nuls in
+    // the input string.
+    if (end == str_str.c_str() + str_str.size() && errno == 0) {
       return value;
     }
   }
   return absl::nullopt;
 }
 
-absl::optional<unsigned_type> ParseUnsigned(const char* str, int base) {
-  RTC_DCHECK(str);
+absl::optional<unsigned_type> ParseUnsigned(absl::string_view str, int base) {
+  if (str.empty())
+    return absl::nullopt;
+
   if (isdigit(str[0]) || str[0] == '-') {
+    std::string str_str = std::string(str);
     // Explicitly discard negative values. std::strtoull parsing causes unsigned
     // wraparound. We cannot just reject values that start with -, though, since
     // -0 is perfectly fine, as is -0000000000000000000000000000000.
     const bool is_negative = str[0] == '-';
     char* end = nullptr;
     errno = 0;
-    const unsigned_type value = std::strtoull(str, &end, base);
-    if (end && *end == '\0' && errno == 0 && (value == 0 || !is_negative)) {
+    const unsigned_type value = std::strtoull(str_str.c_str(), &end, base);
+    // Check for errors and also make sure that there were no embedded nuls in
+    // the input string.
+    if (end == str_str.c_str() + str_str.size() && errno == 0 &&
+        (value == 0 || !is_negative)) {
       return value;
     }
   }
@@ -69,22 +80,25 @@ inline long double StrToT(const char* str, char** str_end) {
 }
 
 template <typename T>
-absl::optional<T> ParseFloatingPoint(const char* str) {
-  RTC_DCHECK(str);
-  if (*str == '\0')
+absl::optional<T> ParseFloatingPoint(absl::string_view str) {
+  if (str.empty())
     return absl::nullopt;
+
+  if (str[0] == '\0')
+    return absl::nullopt;
+  std::string str_str = std::string(str);
   char* end = nullptr;
   errno = 0;
-  const T value = StrToT<T>(str, &end);
-  if (end && *end == '\0' && errno == 0) {
+  const T value = StrToT<T>(str_str.c_str(), &end);
+  if (end == str_str.c_str() + str_str.size() && errno == 0) {
     return value;
   }
   return absl::nullopt;
 }
 
-template absl::optional<float> ParseFloatingPoint(const char* str);
-template absl::optional<double> ParseFloatingPoint(const char* str);
-template absl::optional<long double> ParseFloatingPoint(const char* str);
+template absl::optional<float> ParseFloatingPoint(absl::string_view str);
+template absl::optional<double> ParseFloatingPoint(absl::string_view str);
+template absl::optional<long double> ParseFloatingPoint(absl::string_view str);
 
 }  // namespace string_to_number_internal
 }  // namespace rtc

rtc_base/string_to_number.h

@@ -15,6 +15,7 @@
 #include <string>
 #include <type_traits>
 
+#include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
 namespace rtc {
@@ -25,10 +26,9 @@ namespace rtc {
 // functions (std::stoi, etc.) indicate errors by throwing exceptions, which
 // are disabled in WebRTC.
 //
-// Integers are parsed using one of the following functions:
-//   absl::optional<int-type> StringToNumber(const char* str, int base = 10);
-//   absl::optional<int-type> StringToNumber(const std::string& str,
-//                                          int base = 10);
+// Integers are parsed using:
+//   absl::optional<int-type> StringToNumber(absl::string_view str,
+//                                           int base = 10);
 //
 // These functions parse a value from the beginning of a string into one of the
 // fundamental integer types, or returns an empty Optional if parsing
@@ -38,26 +38,23 @@ namespace rtc {
 // By setting base to 0, one of octal, decimal or hexadecimal will be
 // detected from the string's prefix (0, nothing or 0x, respectively).
 // If non-zero, base can be set to a value between 2 and 36 inclusively.
-//
-// If desired, this interface could be extended with support for floating-point
-// types.
 
 namespace string_to_number_internal {
 // These must be (unsigned) long long, to match the signature of strto(u)ll.
 using unsigned_type = unsigned long long;  // NOLINT(runtime/int)
 using signed_type = long long;             // NOLINT(runtime/int)
 
-absl::optional<signed_type> ParseSigned(const char* str, int base);
-absl::optional<unsigned_type> ParseUnsigned(const char* str, int base);
+absl::optional<signed_type> ParseSigned(absl::string_view str, int base);
+absl::optional<unsigned_type> ParseUnsigned(absl::string_view str, int base);
 
 template <typename T>
-absl::optional<T> ParseFloatingPoint(const char* str);
+absl::optional<T> ParseFloatingPoint(absl::string_view str);
 }  // namespace string_to_number_internal
 
 template <typename T>
 typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value,
                         absl::optional<T>>::type
-StringToNumber(const char* str, int base = 10) {
+StringToNumber(absl::string_view str, int base = 10) {
   using string_to_number_internal::signed_type;
   static_assert(
       std::numeric_limits<T>::max() <=
@@ -78,7 +75,7 @@ template <typename T>
 typename std::enable_if<std::is_integral<T>::value &&
                             std::is_unsigned<T>::value,
                         absl::optional<T>>::type
-StringToNumber(const char* str, int base = 10) {
+StringToNumber(absl::string_view str, int base = 10) {
   using string_to_number_internal::unsigned_type;
   static_assert(std::numeric_limits<T>::max() <=
                     std::numeric_limits<unsigned_type>::max(),
@@ -95,7 +92,7 @@ StringToNumber(const char* str, int base = 10) {
 template <typename T>
 typename std::enable_if<std::is_floating_point<T>::value,
                         absl::optional<T>>::type
-StringToNumber(const char* str, int base = 10) {
+StringToNumber(absl::string_view str, int base = 10) {
   static_assert(
       std::numeric_limits<T>::max() <= std::numeric_limits<long double>::max(),
       "StringToNumber only supports floating-point numbers as large "
@@ -103,14 +100,6 @@ StringToNumber(const char* str, int base = 10) {
   return string_to_number_internal::ParseFloatingPoint<T>(str);
 }
 
-// The std::string overloads only exists if there is a matching const char*
-// version.
-template <typename T>
-auto StringToNumber(const std::string& str, int base = 10)
-    -> decltype(StringToNumber<T>(str.c_str(), base)) {
-  return StringToNumber<T>(str.c_str(), base);
-}
-
 }  // namespace rtc
 
 #endif  // RTC_BASE_STRING_TO_NUMBER_H_

rtc_base/string_to_number_unittest.cc

@@ -15,6 +15,8 @@
 #include <limits>
 #include <string>
 
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 #include "test/gtest.h"
 
 namespace rtc {
@@ -80,6 +82,10 @@ TYPED_TEST_P(BasicNumberTest, TestInvalidInputs) {
   const char kInvalidCharArray[] = "Invalid string containing 47";
   const char kPlusMinusCharArray[] = "+-100";
   const char kNumberFollowedByCruft[] = "640x480";
+  const char kEmbeddedNul[] = {'1', '2', '\0', '3', '4'};
+  const char kBeginningEmbeddedNul[] = {'\0', '1', '2', '3', '4'};
+  const char kTrailingEmbeddedNul[] = {'1', '2', '3', '4', '\0'};
+
   EXPECT_EQ(absl::nullopt, StringToNumber<T>(kInvalidCharArray));
   EXPECT_EQ(absl::nullopt, StringToNumber<T>(std::string(kInvalidCharArray)));
   EXPECT_EQ(absl::nullopt, StringToNumber<T>(kPlusMinusCharArray));
@@ -92,6 +98,23 @@ TYPED_TEST_P(BasicNumberTest, TestInvalidInputs) {
   EXPECT_EQ(absl::nullopt, StringToNumber<T>("- 5"));
   EXPECT_EQ(absl::nullopt, StringToNumber<T>(" -5"));
   EXPECT_EQ(absl::nullopt, StringToNumber<T>("5 "));
+  // Test various types of empty inputs
+  EXPECT_EQ(absl::nullopt, StringToNumber<T>(nullptr));
+  EXPECT_EQ(absl::nullopt, StringToNumber<T>(""));
+  EXPECT_EQ(absl::nullopt, StringToNumber<T>(std::string()));
+  EXPECT_EQ(absl::nullopt, StringToNumber<T>(std::string("")));
+  EXPECT_EQ(absl::nullopt, StringToNumber<T>(absl::string_view()));
+  EXPECT_EQ(absl::nullopt, StringToNumber<T>(absl::string_view(nullptr)));
+  EXPECT_EQ(absl::nullopt, StringToNumber<T>(absl::string_view("")));
+  // Test strings with embedded nuls.
+  EXPECT_EQ(absl::nullopt, StringToNumber<T>(absl::string_view(
+                               kEmbeddedNul, sizeof(kEmbeddedNul))));
+  EXPECT_EQ(absl::nullopt,
+            StringToNumber<T>(absl::string_view(
+                kBeginningEmbeddedNul, sizeof(kBeginningEmbeddedNul))));
+  EXPECT_EQ(absl::nullopt,
+            StringToNumber<T>(absl::string_view(kTrailingEmbeddedNul,
+                                                sizeof(kTrailingEmbeddedNul))));
 }
 
 REGISTER_TYPED_TEST_SUITE_P(BasicNumberTest,