@fails-components/webtransport 0.0.1 → 0.0.2

package/third_party/googleurl/base/strings/string_number_conversions_internal.h

@@ -252,7 +252,7 @@ StringT DoubleToStringT(double value) {
   char buffer[32];
   double_conversion::StringBuilder builder(buffer, sizeof(buffer));
   GetDoubleToStringConverter()->ToShortest(value, &builder);
-  return ToString<StringT>(buffer, builder.position());
+  return ToString<StringT>(buffer, static_cast<size_t>(builder.position()));
 }
 
 template <typename STRING, typename CHAR>
@@ -263,8 +263,8 @@ bool StringToDoubleImpl(STRING input, const CHAR* data, double& output) {
       0.0, 0, nullptr, nullptr);
 
   int processed_characters_count;
-  output =
-      converter.StringToDouble(data, input.size(), &processed_characters_count);
+  output = converter.StringToDouble(data, checked_cast<int>(input.size()),
+                                    &processed_characters_count);
 
   // Cases to return false:
   //  - If the input string is empty, there was nothing to parse.
@@ -278,7 +278,7 @@ bool StringToDoubleImpl(STRING input, const CHAR* data, double& output) {
          !IsUnicodeWhitespace(input[0]);
 }
 
-template <typename OutIter>
+template <typename Char, typename OutIter>
 static bool HexStringToByteContainer(StringPiece input, OutIter output) {
   size_t count = input.size();
   if (count == 0 || (count % 2) != 0)
@@ -291,7 +291,7 @@ static bool HexStringToByteContainer(StringPiece input, OutIter output) {
     if (!msb || !lsb) {
       return false;
     }
-    *(output++) = (*msb << 4) | *lsb;
+    *(output++) = static_cast<Char>((*msb << 4) | *lsb);
   }
   return true;
 }

package/third_party/googleurl/base/strings/string_piece.h

@@ -607,10 +607,10 @@ struct StringPieceHashImpl {
   // This is a custom hash function. We don't use the ones already defined for
   // string and std::u16string directly because it would require the string
   // constructors to be called, which we don't want.
-  std::size_t operator()(StringPieceType sp) const {
-    std::size_t result = 0;
+  size_t operator()(StringPieceType sp) const {
+    size_t result = 0;
     for (auto c : sp)
-      result = (result * 131) + c;
+      result = (result * 131) + static_cast<size_t>(c);
     return result;
   }
 };

package/third_party/googleurl/base/strings/string_util.cc

@@ -90,16 +90,6 @@ int CompareCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b) {
   return internal::CompareCaseInsensitiveASCIIT(a, b);
 }
 
-bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b) {
-  return a.size() == b.size() &&
-         internal::CompareCaseInsensitiveASCIIT(a, b) == 0;
-}
-
-bool EqualsCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b) {
-  return a.size() == b.size() &&
-         internal::CompareCaseInsensitiveASCIIT(a, b) == 0;
-}
-
 const std::string& EmptyString() {
   static const gurl_base::NoDestructor<std::string> s;
   return *s;
@@ -185,8 +175,7 @@ void TruncateUTF8ToByteSize(const std::string& input,
     int32_t prev = char_index;
     base_icu::UChar32 code_point = 0;
     CBU8_NEXT(data, char_index, truncation_length, code_point);
-    if (!IsValidCharacter(code_point) ||
-        !IsValidCodepoint(code_point)) {
+    if (!IsValidCharacter(code_point)) {
       char_index = prev - 1;
     } else {
       break;
@@ -301,24 +290,12 @@ bool EndsWith(StringPiece16 str,
   return internal::EndsWithT(str, search_for, case_sensitivity);
 }
 
-char HexDigitToInt(wchar_t c) {
+char HexDigitToInt(char c) {
   GURL_DCHECK(IsHexDigit(c));
   if (c >= '0' && c <= '9')
     return static_cast<char>(c - '0');
-  if (c >= 'A' && c <= 'F')
-    return static_cast<char>(c - 'A' + 10);
-  if (c >= 'a' && c <= 'f')
-    return static_cast<char>(c - 'a' + 10);
-  return 0;
-}
-
-bool IsUnicodeWhitespace(wchar_t c) {
-  // kWhitespaceWide is a NULL-terminated string
-  for (const wchar_t* cur = kWhitespaceWide; *cur; ++cur) {
-    if (*cur == c)
-      return true;
-  }
-  return false;
+  return (c >= 'A' && c <= 'F') ? static_cast<char>(c - 'A' + 10)
+                                : static_cast<char>(c - 'a' + 10);
 }
 
 static const char* const kByteStringsUnlocalized[] = {

package/third_party/googleurl/base/strings/string_util.h

@@ -12,6 +12,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <algorithm>
 #include <initializer_list>
 #include <string>
 #include <type_traits>
@@ -122,7 +123,7 @@ CharT ToLowerASCII(CharT c) {
 template <typename CharT,
           typename = std::enable_if_t<std::is_integral<CharT>::value>>
 CharT ToUpperASCII(CharT c) {
-  return (c >= 'a' && c <= 'z') ? (c + ('A' - 'a')) : c;
+  return (c >= 'a' && c <= 'z') ? static_cast<CharT>(c + 'A' - 'a') : c;
 }
 
 // Converts the given string to it's ASCII-lowercase equivalent.
@@ -153,16 +154,37 @@ template<typename Char> struct CaseInsensitiveCompareASCII {
 //    0  (a == b)
 //    1  (a > b)
 // (unlike strcasecmp which can return values greater or less than 1/-1). For
-// full Unicode support, use gurl_base::i18n::ToLower or gurl_base::i18h::FoldCase
+// full Unicode support, use gurl_base::i18n::ToLower or gurl_base::i18n::FoldCase
 // and then just call the normal string operators on the result.
 BASE_EXPORT int CompareCaseInsensitiveASCII(StringPiece a, StringPiece b);
 BASE_EXPORT int CompareCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b);
 
+namespace internal {
+template <typename CharT, typename CharU>
+inline bool EqualsCaseInsensitiveASCIIT(BasicStringPiece<CharT> a,
+                                        BasicStringPiece<CharU> b) {
+  return std::equal(a.begin(), a.end(), b.begin(), b.end(),
+                    [](auto lhs, auto rhs) {
+                      return ToLowerASCII(lhs) == ToLowerASCII(rhs);
+                    });
+}
+}  // namespace internal
+
 // Equality for ASCII case-insensitive comparisons. For full Unicode support,
-// use gurl_base::i18n::ToLower or gurl_base::i18h::FoldCase and then compare with either
+// use gurl_base::i18n::ToLower or gurl_base::i18n::FoldCase and then compare with either
 // == or !=.
-BASE_EXPORT bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b);
-BASE_EXPORT bool EqualsCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b);
+inline bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b) {
+  return internal::EqualsCaseInsensitiveASCIIT(a, b);
+}
+inline bool EqualsCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b) {
+  return internal::EqualsCaseInsensitiveASCIIT(a, b);
+}
+inline bool EqualsCaseInsensitiveASCII(StringPiece16 a, StringPiece b) {
+  return internal::EqualsCaseInsensitiveASCIIT(a, b);
+}
+inline bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece16 b) {
+  return internal::EqualsCaseInsensitiveASCIIT(a, b);
+}
 
 // These threadsafe functions return references to globally unique empty
 // strings.
@@ -395,11 +417,24 @@ inline bool IsHexDigit(Char c) {
 //    '4' -> 4
 //    'a' -> 10
 //    'B' -> 11
-// Assumes the input is a valid hex character. DCHECKs in debug builds if not.
-BASE_EXPORT char HexDigitToInt(wchar_t c);
+// Assumes the input is a valid hex character.
+BASE_EXPORT char HexDigitToInt(char c);
+inline char HexDigitToInt(char16_t c) {
+  GURL_DCHECK(IsHexDigit(c));
+  return HexDigitToInt(static_cast<char>(c));
+}
 
 // Returns true if it's a Unicode whitespace character.
-BASE_EXPORT bool IsUnicodeWhitespace(wchar_t c);
+template <typename Char>
+inline bool IsUnicodeWhitespace(Char c) {
+  // kWhitespaceWide is a NUL-terminated string
+  for (const auto* cur = kWhitespaceWide; *cur; ++cur) {
+    if (static_cast<typename std::make_unsigned_t<wchar_t>>(*cur) ==
+        static_cast<typename std::make_unsigned_t<Char>>(c))
+      return true;
+  }
+  return false;
+};
 
 // Return a byte string in human-readable format with a unit suffix. Not
 // appropriate for use in any UI; use of FormatBytes and friends in ui/base is

package/third_party/googleurl/base/strings/string_util_internal.h

@@ -26,7 +26,7 @@ struct ReplacementOffset {
       : parameter(parameter), offset(offset) {}
 
   // Index of the parameter.
-  uintptr_t parameter;
+  size_t parameter;
 
   // Starting position in the string.
   size_t offset;
@@ -147,7 +147,7 @@ std::basic_string<CharT> CollapseWhitespaceT(
   bool in_whitespace = true;
   bool already_trimmed = true;
 
-  int chars_written = 0;
+  size_t chars_written = 0;
   for (auto c : text) {
     if (IsUnicodeWhitespace(c)) {
       if (!in_whitespace) {
@@ -196,7 +196,7 @@ bool DoIsStringASCII(const Char* characters, size_t length) {
 
   // Prologue: align the input.
   while (!IsMachineWordAligned(characters) && characters < end)
-    all_char_bits |= *characters++;
+    all_char_bits |= static_cast<MachineWord>(*characters++);
   if (all_char_bits & non_ascii_bit_mask)
     return false;
 
@@ -222,19 +222,19 @@ bool DoIsStringASCII(const Char* characters, size_t length) {
 
   // Process the remaining bytes.
   while (characters < end)
-    all_char_bits |= *characters++;
+    all_char_bits |= static_cast<MachineWord>(*characters++);
 
   return !(all_char_bits & non_ascii_bit_mask);
 }
 
-template <bool (*Validator)(uint32_t)>
+template <bool (*Validator)(base_icu::UChar32)>
 inline bool DoIsStringUTF8(StringPiece str) {
-  const char* src = str.data();
-  int32_t src_len = static_cast<int32_t>(str.length());
-  int32_t char_index = 0;
+  const uint8_t* src = reinterpret_cast<const uint8_t*>(str.data());
+  size_t src_len = str.length();
+  size_t char_index = 0;
 
   while (char_index < src_len) {
-    int32_t code_point;
+    base_icu::UChar32 code_point;
     CBU8_NEXT(src, char_index, src_len, code_point);
     if (!Validator(code_point))
       return false;
@@ -583,10 +583,9 @@ std::basic_string<CharT> DoReplaceStringPlaceholders(
             GURL_DLOG(ERROR) << "Invalid placeholder: $" << *i;
             continue;
           }
-          uintptr_t index = *i - '1';
+          size_t index = static_cast<size_t>(*i - '1');
           if (offsets) {
-            ReplacementOffset r_offset(index,
-                                       static_cast<int>(formatted.size()));
+            ReplacementOffset r_offset(index, formatted.size());
             r_offsets.insert(
                 ranges::upper_bound(r_offsets, r_offset, &CompareParameter),
                 r_offset);

package/third_party/googleurl/base/strings/string_util_unittest.cc

@@ -1472,6 +1472,39 @@ TEST(StringUtilTest, EqualsCaseInsensitiveASCII) {
   EXPECT_TRUE(EqualsCaseInsensitiveASCII("Asdf", "aSDF"));
   EXPECT_FALSE(EqualsCaseInsensitiveASCII("bsdf", "aSDF"));
   EXPECT_FALSE(EqualsCaseInsensitiveASCII("Asdf", "aSDFz"));
+
+  EXPECT_TRUE(EqualsCaseInsensitiveASCII(u"", u""));
+  EXPECT_TRUE(EqualsCaseInsensitiveASCII(u"Asdf", u"aSDF"));
+  EXPECT_FALSE(EqualsCaseInsensitiveASCII(u"bsdf", u"aSDF"));
+  EXPECT_FALSE(EqualsCaseInsensitiveASCII(u"Asdf", u"aSDFz"));
+
+  EXPECT_TRUE(EqualsCaseInsensitiveASCII(u"", ""));
+  EXPECT_TRUE(EqualsCaseInsensitiveASCII(u"Asdf", "aSDF"));
+  EXPECT_FALSE(EqualsCaseInsensitiveASCII(u"bsdf", "aSDF"));
+  EXPECT_FALSE(EqualsCaseInsensitiveASCII(u"Asdf", "aSDFz"));
+
+  EXPECT_TRUE(EqualsCaseInsensitiveASCII("", u""));
+  EXPECT_TRUE(EqualsCaseInsensitiveASCII("Asdf", u"aSDF"));
+  EXPECT_FALSE(EqualsCaseInsensitiveASCII("bsdf", u"aSDF"));
+  EXPECT_FALSE(EqualsCaseInsensitiveASCII("Asdf", u"aSDFz"));
+
+  // The `WStringPiece` overloads are only defined on Windows.
+#if BUILDFLAG(IS_WIN)
+  EXPECT_TRUE(EqualsCaseInsensitiveASCII(L"", L""));
+  EXPECT_TRUE(EqualsCaseInsensitiveASCII(L"Asdf", L"aSDF"));
+  EXPECT_FALSE(EqualsCaseInsensitiveASCII(L"bsdf", L"aSDF"));
+  EXPECT_FALSE(EqualsCaseInsensitiveASCII(L"Asdf", L"aSDFz"));
+
+  EXPECT_TRUE(EqualsCaseInsensitiveASCII(L"", ""));
+  EXPECT_TRUE(EqualsCaseInsensitiveASCII(L"Asdf", "aSDF"));
+  EXPECT_FALSE(EqualsCaseInsensitiveASCII(L"bsdf", "aSDF"));
+  EXPECT_FALSE(EqualsCaseInsensitiveASCII(L"Asdf", "aSDFz"));
+
+  EXPECT_TRUE(EqualsCaseInsensitiveASCII("", L""));
+  EXPECT_TRUE(EqualsCaseInsensitiveASCII("Asdf", L"aSDF"));
+  EXPECT_FALSE(EqualsCaseInsensitiveASCII("bsdf", L"aSDF"));
+  EXPECT_FALSE(EqualsCaseInsensitiveASCII("Asdf", L"aSDFz"));
+#endif
 }
 
 TEST(StringUtilTest, IsUnicodeWhitespace) {

package/third_party/googleurl/base/strings/string_util_win.cc

@@ -24,11 +24,6 @@ int CompareCaseInsensitiveASCII(WStringPiece a, WStringPiece b) {
   return internal::CompareCaseInsensitiveASCIIT(a, b);
 }
 
-bool EqualsCaseInsensitiveASCII(WStringPiece a, WStringPiece b) {
-  return a.size() == b.size() &&
-         internal::CompareCaseInsensitiveASCIIT(a, b) == 0;
-}
-
 bool RemoveChars(WStringPiece input,
                  WStringPiece remove_chars,
                  std::wstring* output) {

package/third_party/googleurl/base/strings/string_util_win.h

@@ -117,7 +117,15 @@ BASE_EXPORT std::wstring ToUpperASCII(WStringPiece str);
 
 BASE_EXPORT int CompareCaseInsensitiveASCII(WStringPiece a, WStringPiece b);
 
-BASE_EXPORT bool EqualsCaseInsensitiveASCII(WStringPiece a, WStringPiece b);
+inline bool EqualsCaseInsensitiveASCII(WStringPiece a, WStringPiece b) {
+  return internal::EqualsCaseInsensitiveASCIIT(a, b);
+}
+inline bool EqualsCaseInsensitiveASCII(WStringPiece a, StringPiece b) {
+  return internal::EqualsCaseInsensitiveASCIIT(a, b);
+}
+inline bool EqualsCaseInsensitiveASCII(StringPiece a, WStringPiece b) {
+  return internal::EqualsCaseInsensitiveASCIIT(a, b);
+}
 
 BASE_EXPORT bool RemoveChars(WStringPiece input,
                              WStringPiece remove_chars,

package/third_party/googleurl/base/strings/utf_offset_string_conversions.cc

@@ -192,7 +192,7 @@ bool ConvertUnicode(const SrcChar* src,
   bool success = true;
   int32_t src_len32 = static_cast<int32_t>(src_len);
   for (int32_t i = 0; i < src_len32; i++) {
-    uint32_t code_point;
+    base_icu::UChar32 code_point;
     size_t original_i = i;
     size_t chars_written = 0;
     if (ReadUnicodeCharacter(src, src_len32, &i, &code_point)) {

package/third_party/googleurl/base/strings/utf_string_conversion_utils.cc

@@ -14,13 +14,10 @@ namespace gurl_base {
 bool ReadUnicodeCharacter(const char* src,
                           int32_t src_len,
                           int32_t* char_index,
-                          uint32_t* code_point_out) {
-  // U8_NEXT expects to be able to use -1 to signal an error, so we must
-  // use a signed type for code_point.  But this function returns false
-  // on error anyway, so code_point_out is unsigned.
-  int32_t code_point;
+                          base_icu::UChar32* code_point_out) {
+  base_icu::UChar32 code_point;
   CBU8_NEXT(src, *char_index, src_len, code_point);
-  *code_point_out = static_cast<uint32_t>(code_point);
+  *code_point_out = code_point;
 
   // The ICU macro above moves to the next char, we want to point to the last
   // char consumed.
@@ -33,7 +30,7 @@ bool ReadUnicodeCharacter(const char* src,
 bool ReadUnicodeCharacter(const char16_t* src,
                           int32_t src_len,
                           int32_t* char_index,
-                          uint32_t* code_point) {
+                          base_icu::UChar32* code_point) {
   if (CBU16_IS_SURROGATE(src[*char_index])) {
     if (!CBU16_IS_SURROGATE_LEAD(src[*char_index]) ||
         *char_index + 1 >= src_len ||
@@ -58,7 +55,7 @@ bool ReadUnicodeCharacter(const char16_t* src,
 bool ReadUnicodeCharacter(const wchar_t* src,
                           int32_t src_len,
                           int32_t* char_index,
-                          uint32_t* code_point) {
+                          base_icu::UChar32* code_point) {
   // Conversion is easy since the source is 32-bit.
   *code_point = src[*char_index];
 

package/third_party/googleurl/base/strings/utf_string_conversion_utils.h

@@ -14,26 +14,29 @@
 #include <string>
 
 #include "polyfills/base/base_export.h"
+#include "base/third_party/icu/icu_utf.h"
+#include "build/build_config.h"
 
 namespace gurl_base {
 
-inline bool IsValidCodepoint(uint32_t code_point) {
+inline bool IsValidCodepoint(base_icu::UChar32 code_point) {
   // Excludes code points that are not Unicode scalar values, i.e.
   // surrogate code points ([0xD800, 0xDFFF]). Additionally, excludes
   // code points larger than 0x10FFFF (the highest codepoint allowed).
   // Non-characters and unassigned code points are allowed.
   // https://unicode.org/glossary/#unicode_scalar_value
-  return code_point < 0xD800u ||
-         (code_point >= 0xE000u && code_point <= 0x10FFFFu);
+  return (code_point >= 0 && code_point < 0xD800) ||
+         (code_point >= 0xE000 && code_point <= 0x10FFFF);
 }
 
-inline bool IsValidCharacter(uint32_t code_point) {
+inline bool IsValidCharacter(base_icu::UChar32 code_point) {
   // Excludes non-characters (U+FDD0..U+FDEF, and all code points
   // ending in 0xFFFE or 0xFFFF) from the set of valid code points.
   // https://unicode.org/faq/private_use.html#nonchar1
-  return code_point < 0xD800u || (code_point >= 0xE000u &&
-      code_point < 0xFDD0u) || (code_point > 0xFDEFu &&
-      code_point <= 0x10FFFFu && (code_point & 0xFFFEu) != 0xFFFEu);
+  return (code_point >= 0 && code_point < 0xD800) ||
+         (code_point >= 0xE000 && code_point < 0xFDD0) ||
+         (code_point > 0xFDEF && code_point <= 0x10FFFF &&
+          (code_point & 0xFFFE) != 0xFFFE);
 }
 
 // ReadUnicodeCharacter --------------------------------------------------------
@@ -48,20 +51,20 @@ inline bool IsValidCharacter(uint32_t code_point) {
 BASE_EXPORT bool ReadUnicodeCharacter(const char* src,
                                       int32_t src_len,
                                       int32_t* char_index,
-                                      uint32_t* code_point_out);
+                                      base_icu::UChar32* code_point_out);
 
 // Reads a UTF-16 character. The usage is the same as the 8-bit version above.
 BASE_EXPORT bool ReadUnicodeCharacter(const char16_t* src,
                                       int32_t src_len,
                                       int32_t* char_index,
-                                      uint32_t* code_point);
+                                      base_icu::UChar32* code_point);
 
 #if defined(WCHAR_T_IS_UTF32)
 // Reads UTF-32 character. The usage is the same as the 8-bit version above.
 BASE_EXPORT bool ReadUnicodeCharacter(const wchar_t* src,
                                       int32_t src_len,
                                       int32_t* char_index,
-                                      uint32_t* code_point);
+                                      base_icu::UChar32* code_point);
 #endif  // defined(WCHAR_T_IS_UTF32)
 
 // WriteUnicodeCharacter -------------------------------------------------------

package/third_party/googleurl/base/strings/utf_string_conversions.cc

@@ -20,7 +20,7 @@ namespace gurl_base {
 
 namespace {
 
-constexpr int32_t kErrorCodePoint = 0xFFFD;
+constexpr base_icu::UChar32 kErrorCodePoint = 0xFFFD;
 
 // Size coefficient ----------------------------------------------------------
 // The maximum number of codeunits in the destination encoding corresponding to
@@ -71,17 +71,23 @@ using EnableIfBitsAre = std::enable_if_t<std::is_integral<Char>::value &&
                                          bool>;
 
 template <typename Char, EnableIfBitsAre<Char, 8> = true>
-void UnicodeAppendUnsafe(Char* out, int32_t* size, uint32_t code_point) {
-  CBU8_APPEND_UNSAFE(out, *size, code_point);
+void UnicodeAppendUnsafe(Char* out,
+                         size_t* size,
+                         base_icu::UChar32 code_point) {
+  CBU8_APPEND_UNSAFE(reinterpret_cast<uint8_t*>(out), *size, code_point);
 }
 
 template <typename Char, EnableIfBitsAre<Char, 16> = true>
-void UnicodeAppendUnsafe(Char* out, int32_t* size, uint32_t code_point) {
+void UnicodeAppendUnsafe(Char* out,
+                         size_t* size,
+                         base_icu::UChar32 code_point) {
   CBU16_APPEND_UNSAFE(out, *size, code_point);
 }
 
 template <typename Char, EnableIfBitsAre<Char, 32> = true>
-void UnicodeAppendUnsafe(Char* out, int32_t* size, uint32_t code_point) {
+void UnicodeAppendUnsafe(Char* out,
+                         size_t* size,
+                         base_icu::UChar32 code_point) {
   out[(*size)++] = code_point;
 }
 
@@ -91,14 +97,14 @@ void UnicodeAppendUnsafe(Char* out, int32_t* size, uint32_t code_point) {
 
 template <typename DestChar>
 bool DoUTFConversion(const char* src,
-                     int32_t src_len,
+                     size_t src_len,
                      DestChar* dest,
-                     int32_t* dest_len) {
+                     size_t* dest_len) {
   bool success = true;
 
-  for (int32_t i = 0; i < src_len;) {
-    int32_t code_point;
-    CBU8_NEXT(src, i, src_len, code_point);
+  for (size_t i = 0; i < src_len;) {
+    base_icu::UChar32 code_point;
+    CBU8_NEXT(reinterpret_cast<const uint8_t*>(src), i, src_len, code_point);
 
     if (!IsValidCodepoint(code_point)) {
       success = false;
@@ -113,12 +119,12 @@ bool DoUTFConversion(const char* src,
 
 template <typename DestChar>
 bool DoUTFConversion(const char16_t* src,
-                     int32_t src_len,
+                     size_t src_len,
                      DestChar* dest,
-                     int32_t* dest_len) {
+                     size_t* dest_len) {
   bool success = true;
 
-  auto ConvertSingleChar = [&success](char16_t in) -> int32_t {
+  auto ConvertSingleChar = [&success](char16_t in) -> base_icu::UChar32 {
     if (!CBU16_IS_SINGLE(in) || !IsValidCodepoint(in)) {
       success = false;
       return kErrorCodePoint;
@@ -126,12 +132,12 @@ bool DoUTFConversion(const char16_t* src,
     return in;
   };
 
-  int32_t i = 0;
+  size_t i = 0;
 
   // Always have another symbol in order to avoid checking boundaries in the
   // middle of the surrogate pair.
-  while (i < src_len - 1) {
-    int32_t code_point;
+  while (i + 1 < src_len) {
+    base_icu::UChar32 code_point;
 
     if (CBU16_IS_LEAD(src[i]) && CBU16_IS_TRAIL(src[i + 1])) {
       code_point = CBU16_GET_SUPPLEMENTARY(src[i], src[i + 1]);
@@ -148,8 +154,9 @@ bool DoUTFConversion(const char16_t* src,
     UnicodeAppendUnsafe(dest, dest_len, code_point);
   }
 
-  if (i < src_len)
+  if (i < src_len) {
     UnicodeAppendUnsafe(dest, dest_len, ConvertSingleChar(src[i]));
+  }
 
   return success;
 }
@@ -158,13 +165,13 @@ bool DoUTFConversion(const char16_t* src,
 
 template <typename DestChar>
 bool DoUTFConversion(const wchar_t* src,
-                     int32_t src_len,
+                     size_t src_len,
                      DestChar* dest,
-                     int32_t* dest_len) {
+                     size_t* dest_len) {
   bool success = true;
 
-  for (int32_t i = 0; i < src_len; ++i) {
-    int32_t code_point = src[i];
+  for (size_t i = 0; i < src_len; ++i) {
+    base_icu::UChar32 code_point = src[i];
 
     if (!IsValidCodepoint(code_point)) {
       success = false;
@@ -197,12 +204,12 @@ bool UTFConversion(const InputString& src_str, DestString* dest_str) {
   auto* dest = &(*dest_str)[0];
 
   // ICU requires 32 bit numbers.
-  int32_t src_len32 = static_cast<int32_t>(src_str.length());
-  int32_t dest_len32 = 0;
+  size_t src_len = src_str.length();
+  size_t dest_len = 0;
 
-  bool res = DoUTFConversion(src_str.data(), src_len32, dest, &dest_len32);
+  bool res = DoUTFConversion(src_str.data(), src_len, dest, &dest_len);
 
-  dest_str->resize(dest_len32);
+  dest_str->resize(dest_len);
   dest_str->shrink_to_fit();
 
   return res;

package/third_party/googleurl/base/template_util.h

@@ -6,6 +6,7 @@
 #define BASE_TEMPLATE_UTIL_H_
 
 #include <stddef.h>
+
 #include <iosfwd>
 #include <iterator>
 #include <type_traits>
@@ -15,10 +16,6 @@
 
 namespace gurl_base {
 
-template <class T> struct is_non_const_reference : std::false_type {};
-template <class T> struct is_non_const_reference<T&> : std::true_type {};
-template <class T> struct is_non_const_reference<const T&> : std::false_type {};
-
 namespace internal {
 
 // Uses expression SFINAE to detect whether using operator<< would work.
@@ -59,35 +56,6 @@ struct priority_tag<0> {};
 
 }  // namespace internal
 
-// gurl_base::in_place_t is an implementation of std::in_place_t from
-// C++17. A tag type used to request in-place construction in template vararg
-// constructors.
-
-// Specification:
-// https://en.cppreference.com/w/cpp/utility/in_place
-struct in_place_t {};
-constexpr in_place_t in_place = {};
-
-// gurl_base::in_place_type_t is an implementation of std::in_place_type_t from
-// C++17. A tag type used for in-place construction when the type to construct
-// needs to be specified, such as with gurl_base::unique_any, designed to be a
-// drop-in replacement.
-
-// Specification:
-// http://en.cppreference.com/w/cpp/utility/in_place
-template <typename T>
-struct in_place_type_t {};
-
-template <typename T>
-struct is_in_place_type_t {
-  static constexpr bool value = false;
-};
-
-template <typename... Ts>
-struct is_in_place_type_t<in_place_type_t<Ts...>> {
-  static constexpr bool value = true;
-};
-
 namespace internal {
 
 // The indirection with std::is_enum<T> is required, because instantiating
@@ -145,8 +113,28 @@ constexpr bool is_constant_evaluated() noexcept {
 //
 // Reference: https://wg21.link/readable.traits#2
 template <typename Iter>
-using iter_value_t =
-    typename std::iterator_traits<remove_cvref_t<Iter>>::value_type;
+struct IterValueImpl {
+  using value_type = typename std::iterator_traits<Iter>::value_type;
+};
+
+template <typename T, bool Cond = false>
+struct IterValuePointerImpl {
+  // The `iterator_traits<T*>::value_type` member is not defined if T is not an
+  // object in C++20.
+};
+template <typename T>
+struct IterValuePointerImpl<T*, true> {
+  using value_type = typename std::iterator_traits<T*>::value_type;
+};
+
+template <typename T>
+struct IterValueImpl<T*> {
+  using value_type =
+      typename IterValuePointerImpl<T*, std::is_object_v<T>>::value_type;
+};
+
+template <typename Iter>
+using iter_value_t = typename IterValueImpl<remove_cvref_t<Iter>>::value_type;
 
 // Simplified implementation of C++20's std::iter_reference_t.
 // As opposed to std::iter_reference_t, this implementation does not restrict