diff --git a/AUTHORS b/AUTHORS
index 6714ac1..2ae5e98 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -30,18 +30,22 @@
 Adam Bujalski <abujalski@gmail.com>
 Adam Kallai <kadam@inf.u-szeged.hu>
 Adam Labuda <a.labuda@samsung.com>
+Anguluri Aravind Kumar <ar.kumar@samsung.com>
 Adam Roben <adam@github.com>
 Adam Treat <adam.treat@samsung.com>
 Adam Yi <i@adamyi.com>
 Addanki Gandhi Kishor <kishor.ag@samsung.com>
 Adenilson Cavalcanti <a.cavalcanti@samsung.com>
 Aditi Singh <a20.singh@samsung.com>
+Aditya Agarwal <ad.agarwal@samsung.com>
 Aditya Bhargava <heuristicist@gmail.com>
+Aditya Sharma <a2.sharma@samsung.com>
 Adrian Belgun <adrian.belgun@intel.com>
 Adrian Ratiu <adrian.ratiu@collabora.corp-partner.google.com>
 Adrià Vilanova Martínez <me@avm99963.com>
 Ahmed Elwasefi <a.m.elwasefi@gmail.com>
 Ahmet Emir Ercin <ahmetemiremir@gmail.com>
+Aidarbek Suleimenov <suleimenov.aidarbek@gmail.com>
 Aiden Grossman <aidengrossmanpso@gmail.com>
 Ajay Berwal <a.berwal@samsung.com>
 Ajay Berwal <ajay.berwal@samsung.com>
@@ -323,6 +327,7 @@
 Debadree Chatterjee <debadree333@gmail.com>
 Debashish Samantaray <d.samantaray@samsung.com>
 Debug Wang <debugwang@tencent.com>
+Deep Shah <deep.shah@samsung.com>
 Deepak Dilip Borade <deepak.db@samsung.com>
 Deepak Mittal <deepak.m1@samsung.com>
 Deepak Mohan <hop2deep@gmail.com>
@@ -359,6 +364,7 @@
 Donna Wu <donna.wu@intel.com>
 Douglas F. Turner <doug.turner@gmail.com>
 Drew Blaisdell <drew.blaisdell@gmail.com>
+Dushyant Kant Sharma <dush.sharma@samsung.com>
 Dustin Doloff <doloffd@amazon.com>
 Ebrahim Byagowi <ebrahim@gnu.org>
 Ebrahim Byagowi <ebraminio@gmail.com>
@@ -441,6 +447,7 @@
 Girish Kumar M <mck.giri@samsung.com>
 Gitanshu Mehndiratta <g.mehndiratt@samsung.com>
 Giuseppe Iuculano <giuseppe@iuculano.it>
+Gloam <gaoqingguang@kuaishou.com>
 Gnanasekar Somanathan <gnanasekar.s@samsung.com>
 Gordana Cmiljanovic <gordana.cmiljanovic@imgtec.com>
 Goutham Jagannatha <wrm364@motorola.com>
@@ -471,12 +478,14 @@
 Harshit Pal <harshitp12345@gmail.com>
 Hassan Salehe Matar <hassansalehe@gmail.com>
 Hautio Kari <khautio@gmail.com>
+He Qi <heqi899@gmail.com>
 Heejin R. Chung <heejin.r.chung@samsung.com>
 Heeyoun Lee <heeyoun.lee@samsung.com>
 Henrique de Carvalho <decarv.henrique@gmail.com>
 Henrique Limas <henrique.ramos.limas@gmail.com>
 Henry Lim <henry@limhenry.xyz>
 Hikari Fujimoto <hikari.p.fujimoto@gmail.com>
+Himadri Agrawal <h2.agrawal@samsung.com>
 Himanshu Joshi <h.joshi@samsung.com>
 Himanshu Nayak <himanshu.nayak@amd.corp-partner.google.com>
 Hiroki Oshima <hiroki.oshima@gmail.com>
@@ -547,6 +556,7 @@
 Jaewon Choi <jaewon.james.choi@gmail.com>
 Jaewon Jung <jw.jung@navercorp.com>
 Jaeyong Bae <jdragon.bae@gmail.com>
+Jagadesh P <jagadeshjai1999@gmail.com>
 Jagdish Chourasia <jagdish.c@samsung.com>
 Jaime Soriano Pastor <jsorianopastor@gmail.com>
 Jake Helfert <jake@helfert.us>
@@ -772,6 +782,7 @@
 Lauri Oherd <lauri.oherd@gmail.com>
 Lavar Askew <open.hyperion@gmail.com>
 Le Hoang Quyen <le.hoang.q@gmail.com>
+Leena Kaushik <l1.kaushik@samsung.com>
 Legend Lee <guanxian.li@intel.com>
 Leith Bade <leith@leithalweapon.geek.nz>
 Lei Gao <leigao@huawei.com>
@@ -874,6 +885,7 @@
 Matthias Reitinger <reimarvin@gmail.com>
 Matthieu Rigolot <matthieu.rigolot@gmail.com>
 Matthieu Vlad Hauglustaine <matt.hauglustaine@gmail.com>
+Max Coplan <mchcopl@gmail.com>
 Max Karolinskiy <max@brave.com>
 Max Perepelitsyn <pph34r@gmail.com>
 Max Schmitt <max@schmitt.mx>
@@ -945,6 +957,7 @@
 Nagarjuna Atluri <nagarjuna.a@samsung.com>
 Naiem Shaik <naiem.shaik@gmail.com>
 Naman Kumar Narula <namankumarnarula@gmail.com>
+Naman Yadav <naman.yadav@samsung.com>
 Naoki Takano <takano.naoki@gmail.com>
 Naoto Ono <onoto1998@gmail.com>
 Nathan Mitchell <nathaniel.v.mitchell@gmail.com>
@@ -980,6 +993,7 @@
 Olivier Tilloy <olivier+chromium@tilloy.net>
 Olli Raula (Old name Olli Syrjälä) <olli.raula@intel.com>
 Omar Sandoval <osandov@osandov.com>
+Orko Garai <orko.garai@gmail.com>
 Owen Shaw <owenpshaw@gmail.com>
 Owen Yuwono <owenyuwono@gmail.com>
 Palash Verma <palashverma47@gmail.com>
@@ -1047,6 +1061,7 @@
 Preeti Nayak <preeti.nayak@samsung.com>
 Pritam Nikam <pritam.nikam@samsung.com>
 Puttaraju R <puttaraju.r@samsung.com>
+Punith Nayak <npunith125@gmail.com>
 Qi Tiezheng <qitiezheng@360.cn>
 Qi Yang <qi1988.yang@samsung.com>
 Qiang Zeng <zengqiang1@huawei.com>
@@ -1074,6 +1089,7 @@
 Ravi Nanjundappa <nravi.n@samsung.com>
 Ravi Phaneendra Kasibhatla <r.kasibhatla@samsung.com>
 Ravi Phaneendra Kasibhatla <ravi.kasibhatla@motorola.com>
+Ravindra Kumar <ravindra.k2@samsung.com>
 Raviraj Sitaram <raviraj.p.sitaram@intel.com>
 Rebecca Chang Swee Fun <rebecca.chang@starfivetech.com>
 Reda Tawfik <redatawfik@noogler.google.com>
@@ -1130,6 +1146,7 @@
 Saikrishna Arcot <saiarcot895@gmail.com>
 Sajal Khandelwal <skhandelwa22@bloomberg.net>
 Sajeesh Sidharthan <sajeesh.sidharthan@amd.corp-partner.google.com>
+Sakib Shabir <s1.tantray@samsung.com>
 Saksham Mittal <gotlouemail@gmail.com>
 Salvatore Iovene <salvatore.iovene@intel.com>
 Sam James <sam@gentoo.org>
@@ -1203,10 +1220,12 @@
 Shirish S <shirish.s@amd.com>
 Shiva Kumar <shiva.k1@samsung.com>
 Shivakumar JM <shiva.jm@samsung.com>
+Shiyi Zou <shiyi.zou@intel.com>
 Shobhit Goel <shobhit.goel@samsung.com>
 Shouqun Liu <liushouqun@xiaomi.com>
 Shouqun Liu <shouqun.liu@intel.com>
 Shreeram Kushwaha <shreeram.k@samsung.com>
+Shrey Patel <shrey1patel2@gmail.com>
 Shreyas Gopal <shreyas.g@samsung.com>
 Shreyas VA <v.a.shreyas@gmail.com>
 Shubham Agrawal <shubag@amazon.com>
@@ -1217,10 +1236,12 @@
 Siddharth Shankar <funkysidd@gmail.com>
 Simeon Kuran <simeon.kuran@gmail.com>
 Simon Arlott <simon.arlott@gmail.com>
+Simon Cadman <simon@cadman.uk>
 Simon Jackson <simon.jackson@sonocent.com>
 Simon La Macchia <smacchia@amazon.com>
 Siva Kumar Gunturi <siva.gunturi@samsung.com>
 Slava Aseev <nullptrnine@gmail.com>
+Smriti Singh <s01.singh@samsung.com>
 Sohom Datta <sohom.datta@learner.manipal.edu>
 Sohom Datta <dattasohom1@gmail.com>
 Song Fangzhen <songfangzhen@bytedance.com>
@@ -1576,5 +1597,6 @@
 Whist Technologies <*@whist.com>
 Xperi Corporation <*@xperi.com>
 Yandex LLC <*@yandex-team.ru>
+Zoho Corporation <*@zohocorp.com>
 # Please DO NOT APPEND here. See comments at the top of the file.
 # END organizations section.
diff --git a/base/compiler_specific.h b/base/compiler_specific.h
index e85da5c..5f7c31e 100644
--- a/base/compiler_specific.h
+++ b/base/compiler_specific.h
@@ -374,6 +374,20 @@
 #define TRIVIAL_ABI
 #endif
 
+// Detect whether a type is trivially relocatable, ie. a move-and-destroy
+// sequence can replaced with memmove(). This can be used to optimise the
+// implementation of containers. This is automatically true for types that were
+// defined with TRIVIAL_ABI such as scoped_refptr.
+//
+// See also:
+//   https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p1144r8.html
+//   https://clang.llvm.org/docs/LanguageExtensions.html#:~:text=__is_trivially_relocatable
+#if defined(__clang__) && HAS_BUILTIN(__is_trivially_relocatable)
+#define IS_TRIVIALLY_RELOCATABLE(t) __is_trivially_relocatable(t)
+#else
+#define IS_TRIVIALLY_RELOCATABLE(t) false
+#endif
+
 // Marks a member function as reinitializing a moved-from variable.
 // See also
 // https://clang.llvm.org/extra/clang-tidy/checks/bugprone-use-after-move.html#reinitialization
diff --git a/base/containers/contiguous_iterator.h b/base/containers/contiguous_iterator.h
index 7f06432..8311b50 100644
--- a/base/containers/contiguous_iterator.h
+++ b/base/containers/contiguous_iterator.h
@@ -40,8 +40,13 @@
 // `static_assert(is_trivial_v<value_type>)` inside libc++'s std::basic_string.
 template <typename T>
 struct IsStringIter
-    : std::conjunction<std::is_trivial<iter_value_t<T>>, IsStringIterImpl<T>> {
-};
+    : std::conjunction<
+          std::disjunction<std::is_same<iter_value_t<T>, char>,
+                           std::is_same<iter_value_t<T>, wchar_t>,
+
+                           std::is_same<iter_value_t<T>, char16_t>,
+                           std::is_same<iter_value_t<T>, char32_t>>,
+          IsStringIterImpl<T>> {};
 
 // An iterator to std::array is contiguous.
 // Reference: https://wg21.link/array.overview#1
diff --git a/base/containers/span.h b/base/containers/span.h
index 83069d6..09f6b6f 100644
--- a/base/containers/span.h
+++ b/base/containers/span.h
@@ -27,7 +27,9 @@
 // [views.constants]
 constexpr size_t dynamic_extent = std::numeric_limits<size_t>::max();
 
-template <typename T, size_t Extent = dynamic_extent>
+template <typename T,
+          size_t Extent = dynamic_extent,
+          typename InternalPtrType = T*>
 class span;
 
 namespace internal {
@@ -233,7 +235,7 @@
 // appropriate make_span() utility functions are provided.
 
 // [span], class template span
-template <typename T, size_t Extent>
+template <typename T, size_t Extent, typename InternalPtrType>
 class GSL_POINTER span : public internal::ExtentStorage<Extent> {
  private:
   using ExtentStorage = internal::ExtentStorage<Extent>;
@@ -434,11 +436,11 @@
 
   // [span.iter], span iterator support
   constexpr iterator begin() const noexcept {
-    return iterator(data_, data_ + size());
+    return iterator(data(), data() + size());
   }
 
   constexpr iterator end() const noexcept {
-    return iterator(data_, data_ + size(), data_ + size());
+    return iterator(data(), data() + size(), data() + size());
   }
 
   constexpr reverse_iterator rbegin() const noexcept {
@@ -452,13 +454,38 @@
  private:
   // This field is not a raw_ptr<> because it was filtered by the rewriter
   // for: #constexpr-ctor-field-initializer, #global-scope, #union
-  RAW_PTR_EXCLUSION T* data_;
+  InternalPtrType data_;
 };
 
 // span<T, Extent>::extent can not be declared inline prior to C++17, hence this
 // definition is required.
-template <class T, size_t Extent>
-constexpr size_t span<T, Extent>::extent;
+template <class T, size_t Extent, typename InternalPtrType>
+constexpr size_t span<T, Extent, InternalPtrType>::extent;
+
+template <typename It,
+          typename T = std::remove_reference_t<iter_reference_t<It>>>
+span(It, StrictNumeric<size_t>) -> span<T>;
+
+template <typename It,
+          typename End,
+          typename = std::enable_if_t<!std::is_convertible_v<End, size_t>>,
+          typename T = std::remove_reference_t<iter_reference_t<It>>>
+span(It, End) -> span<T>;
+
+template <typename T, size_t N>
+span(T (&)[N]) -> span<T, N>;
+
+template <typename T, size_t N>
+span(std::array<T, N>&) -> span<T, N>;
+
+template <typename T, size_t N>
+span(const std::array<T, N>&) -> span<const T, N>;
+
+template <typename Container,
+          typename T = std::remove_pointer_t<
+              decltype(std::data(std::declval<Container>()))>,
+          size_t X = internal::Extent<Container>::value>
+span(Container&&) -> span<T, X>;
 
 // [span.objectrep], views of object representation
 template <typename T, size_t X>
diff --git a/base/memory/raw_ptr_exclusion.h b/base/memory/raw_ptr_exclusion.h
index 3ce1d60..e4d355d 100644
--- a/base/memory/raw_ptr_exclusion.h
+++ b/base/memory/raw_ptr_exclusion.h
@@ -8,6 +8,6 @@
 // Although `raw_ptr` is part of the standalone PA distribution, it is
 // easier to use the shorter path in `//base/memory`. We retain this
 // facade header for ease of typing.
-#include "base/allocator/partition_allocator/pointers/raw_ptr_exclusion.h"  // IWYU pragma: export
+#include "base/allocator/partition_allocator/src/partition_alloc/pointers/raw_ptr_exclusion.h"  // IWYU pragma: export
 
 #endif  // BASE_MEMORY_RAW_PTR_EXCLUSION_H_
diff --git a/base/numerics/safe_conversions.h b/base/numerics/safe_conversions.h
index 3e04bf4..7f12916 100644
--- a/base/numerics/safe_conversions.h
+++ b/base/numerics/safe_conversions.h
@@ -357,8 +357,18 @@
 using SizeT = StrictNumeric<size_t>;
 
 // floating -> integral conversions that saturate and thus can actually return
-// an integral type.  In most cases, these should be preferred over the std::
-// versions.
+// an integral type.
+//
+// Generally, what you want is saturated_cast<Dst>(std::nearbyint(x)), which
+// rounds correctly according to IEEE-754 (round to nearest, ties go to nearest
+// even number; this avoids bias). If your code is performance-critical
+// and you are sure that you will never overflow, you can use std::lrint()
+// or std::llrint(), which return a long or long long directly.
+//
+// Below are convenience functions around similar patterns, except that
+// they round in nonstandard directions and will generally be slower.
+
+// Rounds towards negative infinity (i.e., down).
 template <typename Dst = int,
           typename Src,
           typename = std::enable_if_t<std::is_integral<Dst>::value &&
@@ -366,6 +376,8 @@
 Dst ClampFloor(Src value) {
   return saturated_cast<Dst>(std::floor(value));
 }
+
+// Rounds towards positive infinity (i.e., up).
 template <typename Dst = int,
           typename Src,
           typename = std::enable_if_t<std::is_integral<Dst>::value &&
@@ -373,13 +385,22 @@
 Dst ClampCeil(Src value) {
   return saturated_cast<Dst>(std::ceil(value));
 }
+
+// Rounds towards nearest integer, with ties away from zero.
+// This means that 0.5 will be rounded to 1 and 1.5 will be rounded to 2.
+// Similarly, -0.5 will be rounded to -1 and -1.5 will be rounded to -2.
+//
+// This is normally not what you want accuracy-wise (it introduces a small bias
+// away from zero), and it is not the fastest option, but it is frequently what
+// existing code expects. Compare with saturated_cast<Dst>(std::nearbyint(x))
+// or std::lrint(x), which would round 0.5 and -0.5 to 0 but 1.5 to 2 and
+// -1.5 to -2.
 template <typename Dst = int,
           typename Src,
           typename = std::enable_if_t<std::is_integral<Dst>::value &&
                                       std::is_floating_point<Src>::value>>
 Dst ClampRound(Src value) {
-  const Src rounded =
-      (value >= 0.0f) ? std::floor(value + 0.5f) : std::ceil(value - 0.5f);
+  const Src rounded = std::round(value);
   return saturated_cast<Dst>(rounded);
 }
 
diff --git a/base/strings/safe_sprintf_unittest.cc b/base/strings/safe_sprintf_unittest.cc
index af52d1c..9086e52 100644
--- a/base/strings/safe_sprintf_unittest.cc
+++ b/base/strings/safe_sprintf_unittest.cc
@@ -12,7 +12,7 @@
 #include <limits>
 #include <memory>
 
-
+#include "base/allocator/partition_allocator/src/partition_alloc/partition_alloc_config.h"
 #include "polyfills/base/check_op.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
diff --git a/base/strings/string_piece_unittest.cc b/base/strings/string_piece_unittest.cc
index a6fcbbb..30819bb 100644
--- a/base/strings/string_piece_unittest.cc
+++ b/base/strings/string_piece_unittest.cc
@@ -684,7 +684,14 @@
   }
 }
 
-#if defined(_LIBCPP_ENABLE_ASSERTIONS)
+// Chromium development assumes StringPiece (which is std::string_view) is
+// implemented with an STL that enables hardening checks. We treat bugs that
+// trigger one of these conditions as functional rather than security bugs. If
+// this test fails on some embedder, it should not be disabled. Instead, the
+// embedder should fix their STL or build configuration to enable corresponding
+// hardening checks.
+//
+// See https://chromium.googlesource.com/chromium/src/+/main/docs/security/faq.md#indexing-a-container-out-of-bounds-hits-a-libcpp_verbose_abort_is-this-a-security-bug
 TEST(StringPieceTest, OutOfBoundsDeath) {
   {
     constexpr StringPiece piece;
@@ -726,7 +733,6 @@
   int length = -1;
   ASSERT_DEATH_IF_SUPPORTED({ StringPiece piece("hello", length); }, "");
 }
-#endif  // defined(_LIBCPP_ENABLE_ASSERTIONS)
 
 TEST(StringPieceTest, ConstexprData) {
   {
diff --git a/base/strings/stringprintf.cc b/base/strings/stringprintf.cc
index 1913fdc..6720744 100644
--- a/base/strings/stringprintf.cc
+++ b/base/strings/stringprintf.cc
@@ -16,100 +16,6 @@
 
 namespace gurl_base {
 
-namespace {
-
-// Overloaded wrappers around vsnprintf and vswprintf. The buf_size parameter
-// is the size of the buffer. These return the number of characters in the
-// formatted string excluding the NUL terminator. If the buffer is not
-// large enough to accommodate the formatted string without truncation, they
-// return the number of characters that would be in the fully-formatted string
-// (vsnprintf, and vswprintf on Windows), or -1 (vswprintf on POSIX platforms).
-inline int vsnprintfT(char* buffer,
-                      size_t buf_size,
-                      const char* format,
-                      va_list argptr) {
-  return gurl_base::vsnprintf(buffer, buf_size, format, argptr);
-}
-
-#if BUILDFLAG(IS_WIN)
-inline int vsnprintfT(wchar_t* buffer,
-                      size_t buf_size,
-                      const wchar_t* format,
-                      va_list argptr) {
-  return gurl_base::vswprintf(buffer, buf_size, format, argptr);
-}
-#endif
-
-// Templatized backend for StringPrintF/StringAppendF. This does not finalize
-// the va_list, the caller is expected to do that.
-template <class CharT>
-static void StringAppendVT(std::basic_string<CharT>* dst,
-                           const CharT* format,
-                           va_list ap) {
-  // First try with a small fixed size buffer.
-  // This buffer size should be kept in sync with StringUtilTest.GrowBoundary
-  // and StringUtilTest.StringPrintfBounds.
-  CharT stack_buf[1024];
-
-  va_list ap_copy;
-  va_copy(ap_copy, ap);
-
-  gurl_base::ScopedClearLastError last_error;
-  int result = vsnprintfT(stack_buf, std::size(stack_buf), format, ap_copy);
-  va_end(ap_copy);
-
-  if (result >= 0 && static_cast<size_t>(result) < std::size(stack_buf)) {
-    // It fit.
-    dst->append(stack_buf, static_cast<size_t>(result));
-    return;
-  }
-
-  // Repeatedly increase buffer size until it fits.
-  size_t mem_length = std::size(stack_buf);
-  while (true) {
-    if (result < 0) {
-#if BUILDFLAG(IS_WIN)
-      // On Windows, vsnprintfT always returns the number of characters in a
-      // fully-formatted string, so if we reach this point, something else is
-      // wrong and no amount of buffer-doubling is going to fix it.
-      return;
-#else
-      if (errno != 0 && errno != EOVERFLOW)
-        return;
-      // Try doubling the buffer size.
-      mem_length *= 2;
-#endif
-    } else {
-      // We need exactly "result + 1" characters.
-      mem_length = static_cast<size_t>(result) + 1;
-    }
-
-    if (mem_length > 32 * 1024 * 1024) {
-      // That should be plenty, don't try anything larger.  This protects
-      // against huge allocations when using vsnprintfT implementations that
-      // return -1 for reasons other than overflow without setting errno.
-      GURL_DLOG(WARNING) << "Unable to printf the requested string due to size.";
-      return;
-    }
-
-    std::vector<CharT> mem_buf(mem_length);
-
-    // NOTE: You can only use a va_list once.  Since we're in a while loop, we
-    // need to make a new copy each time so we don't use up the original.
-    va_copy(ap_copy, ap);
-    result = vsnprintfT(&mem_buf[0], mem_length, format, ap_copy);
-    va_end(ap_copy);
-
-    if ((result >= 0) && (static_cast<size_t>(result) < mem_length)) {
-      // It fit.
-      dst->append(&mem_buf[0], static_cast<size_t>(result));
-      return;
-    }
-  }
-}
-
-}  // namespace
-
 std::string StringPrintf(const char* format, ...) {
   va_list ap;
   va_start(ap, format);
@@ -119,17 +25,6 @@
   return result;
 }
 
-#if BUILDFLAG(IS_WIN)
-std::wstring StringPrintf(const wchar_t* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  std::wstring result;
-  StringAppendV(&result, format, ap);
-  va_end(ap);
-  return result;
-}
-#endif
-
 std::string StringPrintV(const char* format, va_list ap) {
   std::string result;
   StringAppendV(&result, format, ap);
@@ -143,23 +38,68 @@
   va_end(ap);
 }
 
-#if BUILDFLAG(IS_WIN)
-void StringAppendF(std::wstring* dst, const wchar_t* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  StringAppendV(dst, format, ap);
-  va_end(ap);
-}
-#endif
-
 void StringAppendV(std::string* dst, const char* format, va_list ap) {
-  StringAppendVT(dst, format, ap);
-}
+  // First try with a small fixed size buffer.
+  // This buffer size should be kept in sync with StringUtilTest.GrowBoundary
+  // and StringUtilTest.StringPrintfBounds.
+  char stack_buf[1024];
 
+  va_list ap_copy;
+  va_copy(ap_copy, ap);
+
+  gurl_base::ScopedClearLastError last_error;
+  int result = vsnprintf(stack_buf, std::size(stack_buf), format, ap_copy);
+  va_end(ap_copy);
+
+  if (result >= 0 && static_cast<size_t>(result) < std::size(stack_buf)) {
+    // It fit.
+    dst->append(stack_buf, static_cast<size_t>(result));
+    return;
+  }
+
+  // Repeatedly increase buffer size until it fits.
+  size_t mem_length = std::size(stack_buf);
+  while (true) {
+    if (result < 0) {
 #if BUILDFLAG(IS_WIN)
-void StringAppendV(std::wstring* dst, const wchar_t* format, va_list ap) {
-  StringAppendVT(dst, format, ap);
-}
+      // On Windows, vsnprintf always returns the number of characters in a
+      // fully-formatted string, so if we reach this point, something else is
+      // wrong and no amount of buffer-doubling is going to fix it.
+      return;
+#else
+      if (errno != 0 && errno != EOVERFLOW) {
+        return;
+      }
+      // Try doubling the buffer size.
+      mem_length *= 2;
 #endif
+    } else {
+      // We need exactly "result + 1" characters.
+      mem_length = static_cast<size_t>(result) + 1;
+    }
+
+    if (mem_length > 32 * 1024 * 1024) {
+      // That should be plenty, don't try anything larger.  This protects
+      // against huge allocations when using vsnprintf implementations that
+      // return -1 for reasons other than overflow without setting errno.
+      GURL_DLOG(WARNING) << "Unable to printf the requested string due to size.";
+      return;
+    }
+
+    std::vector<char> mem_buf(mem_length);
+
+    // NOTE: You can only use a va_list once.  Since we're in a while loop, we
+    // need to make a new copy each time so we don't use up the original.
+    va_copy(ap_copy, ap);
+    result = vsnprintf(&mem_buf[0], mem_length, format, ap_copy);
+    va_end(ap_copy);
+
+    if ((result >= 0) && (static_cast<size_t>(result) < mem_length)) {
+      // It fit.
+      dst->append(&mem_buf[0], static_cast<size_t>(result));
+      return;
+    }
+  }
+}
 
 }  // namespace base
diff --git a/base/strings/stringprintf.h b/base/strings/stringprintf.h
index 5266a13..99d04e8 100644
--- a/base/strings/stringprintf.h
+++ b/base/strings/stringprintf.h
@@ -11,20 +11,12 @@
 
 #include "polyfills/base/base_export.h"
 #include "base/compiler_specific.h"
-#include "build/build_config.h"
 
 namespace gurl_base {
 
 // Return a C++ string given printf-like input.
 [[nodiscard]] BASE_EXPORT std::string StringPrintf(const char* format, ...)
     PRINTF_FORMAT(1, 2);
-#if BUILDFLAG(IS_WIN)
-// Note: Unfortunately compile time checking of the format string for UTF-16
-// strings is not supported by any compiler, thus these functions should be used
-// carefully and sparingly. Also applies to StringAppendV below.
-[[nodiscard]] BASE_EXPORT std::wstring StringPrintf(const wchar_t* format, ...)
-    WPRINTF_FORMAT(1, 2);
-#endif
 
 // Return a C++ string given vprintf-like input.
 [[nodiscard]] BASE_EXPORT std::string StringPrintV(const char* format,
@@ -34,20 +26,11 @@
 // Append result to a supplied string.
 BASE_EXPORT void StringAppendF(std::string* dst, const char* format, ...)
     PRINTF_FORMAT(2, 3);
-#if BUILDFLAG(IS_WIN)
-BASE_EXPORT void StringAppendF(std::wstring* dst, const wchar_t* format, ...)
-    WPRINTF_FORMAT(2, 3);
-#endif
 
 // Lower-level routine that takes a va_list and appends to a specified
 // string.  All other routines are just convenience wrappers around it.
 BASE_EXPORT void StringAppendV(std::string* dst, const char* format, va_list ap)
     PRINTF_FORMAT(2, 0);
-#if BUILDFLAG(IS_WIN)
-BASE_EXPORT void StringAppendV(std::wstring* dst,
-                               const wchar_t* format,
-                               va_list ap) WPRINTF_FORMAT(2, 0);
-#endif
 
 }  // namespace base
 
diff --git a/base/strings/stringprintf_unittest.cc b/base/strings/stringprintf_unittest.cc
index 45fa9c6..981c45c 100644
--- a/base/strings/stringprintf_unittest.cc
+++ b/base/strings/stringprintf_unittest.cc
@@ -35,45 +35,24 @@
 
 TEST(StringPrintfTest, StringPrintfMisc) {
   EXPECT_EQ("123hello w", StringPrintf("%3d%2s %1c", 123, "hello", 'w'));
-#if BUILDFLAG(IS_WIN)
-  EXPECT_EQ(L"123hello w", StringPrintf(L"%3d%2ls %1lc", 123, L"hello", 'w'));
-#endif
 }
 
 TEST(StringPrintfTest, StringAppendfEmptyString) {
   std::string value("Hello");
   StringAppendF(&value, "%s", "");
   EXPECT_EQ("Hello", value);
-
-#if BUILDFLAG(IS_WIN)
-  std::wstring valuew(L"Hello");
-  StringAppendF(&valuew, L"%ls", L"");
-  EXPECT_EQ(L"Hello", valuew);
-#endif
 }
 
 TEST(StringPrintfTest, StringAppendfString) {
   std::string value("Hello");
   StringAppendF(&value, " %s", "World");
   EXPECT_EQ("Hello World", value);
-
-#if BUILDFLAG(IS_WIN)
-  std::wstring valuew(L"Hello");
-  StringAppendF(&valuew, L" %ls", L"World");
-  EXPECT_EQ(L"Hello World", valuew);
-#endif
 }
 
 TEST(StringPrintfTest, StringAppendfInt) {
   std::string value("Hello");
   StringAppendF(&value, " %d", 123);
   EXPECT_EQ("Hello 123", value);
-
-#if BUILDFLAG(IS_WIN)
-  std::wstring valuew(L"Hello");
-  StringAppendF(&valuew, L" %d", 123);
-  EXPECT_EQ(L"Hello 123", valuew);
-#endif
 }
 
 // Make sure that lengths exactly around the initial buffer size are handled
@@ -93,11 +72,6 @@
     src[kSrcLen - i] = 0;
     std::string out;
     EXPECT_EQ(src, StringPrintf("%s", src));
-
-#if BUILDFLAG(IS_WIN)
-    srcw[kSrcLen - i] = 0;
-    EXPECT_EQ(srcw, StringPrintf(L"%ls", srcw));
-#endif
   }
 }
 
@@ -126,12 +100,6 @@
   std::string out;
   StringAppendVTestHelper(&out, "%d foo %s", 1, "bar");
   EXPECT_EQ("1 foo bar", out);
-
-#if BUILDFLAG(IS_WIN)
-  std::wstring outw;
-  StringAppendVTestHelper(&outw, L"%d foo %ls", 1, L"bar");
-  EXPECT_EQ(L"1 foo bar", outw);
-#endif
 }
 
 // Test the boundary condition for the size of the string_util's
@@ -150,16 +118,6 @@
   EXPECT_EQ(src, StringPrintf("%s", src));
 }
 
-#if BUILDFLAG(IS_WIN)
-TEST(StringPrintfTest, Invalid) {
-  wchar_t invalid[2];
-  invalid[0] = 0xffff;
-  invalid[1] = 0;
-
-  EXPECT_EQ(invalid, StringPrintf(L"%ls", invalid));
-}
-#endif
-
 // Test that StringPrintf and StringAppendV do not change errno.
 TEST(StringPrintfTest, StringPrintfErrno) {
   errno = 1;
diff --git a/base/strings/sys_string_conversions_unittest.cc b/base/strings/sys_string_conversions_unittest.cc
index 0e3dfa1..5d898aa 100644
--- a/base/strings/sys_string_conversions_unittest.cc
+++ b/base/strings/sys_string_conversions_unittest.cc
@@ -25,7 +25,8 @@
   EXPECT_EQ("Hello, world", SysWideToUTF8(L"Hello, world"));
   EXPECT_EQ("\xe4\xbd\xa0\xe5\xa5\xbd", SysWideToUTF8(L"\x4f60\x597d"));
 
-  // >16 bits
+  // A value outside of the BMP and therefore not representable with one UTF-16
+  // code unit.
   EXPECT_EQ("\xF0\x90\x8C\x80", SysWideToUTF8(kSysWideOldItalicLetterA));
 
   // Error case. When Windows finds a UTF-16 character going off the end of
@@ -52,7 +53,9 @@
 TEST(SysStrings, SysUTF8ToWide) {
   EXPECT_EQ(L"Hello, world", SysUTF8ToWide("Hello, world"));
   EXPECT_EQ(L"\x4f60\x597d", SysUTF8ToWide("\xe4\xbd\xa0\xe5\xa5\xbd"));
-  // >16 bits
+
+  // A value outside of the BMP and therefore not representable with one UTF-16
+  // code unit.
   EXPECT_EQ(kSysWideOldItalicLetterA, SysUTF8ToWide("\xF0\x90\x8C\x80"));
 
   // Error case. When Windows finds an invalid UTF-8 character, it just skips
@@ -83,7 +86,8 @@
   EXPECT_EQ("Hello, world", SysWideToNativeMB(L"Hello, world"));
   EXPECT_EQ("\xe4\xbd\xa0\xe5\xa5\xbd", SysWideToNativeMB(L"\x4f60\x597d"));
 
-  // >16 bits
+  // A value outside of the BMP and therefore not representable with one UTF-16
+  // code unit.
   EXPECT_EQ("\xF0\x90\x8C\x80", SysWideToNativeMB(kSysWideOldItalicLetterA));
 
   // Error case. When Windows finds a UTF-16 character going off the end of
@@ -114,7 +118,9 @@
 #endif
   EXPECT_EQ(L"Hello, world", SysNativeMBToWide("Hello, world"));
   EXPECT_EQ(L"\x4f60\x597d", SysNativeMBToWide("\xe4\xbd\xa0\xe5\xa5\xbd"));
-  // >16 bits
+
+  // A value outside of the BMP and therefore not representable with one UTF-16
+  // code unit.
   EXPECT_EQ(kSysWideOldItalicLetterA, SysNativeMBToWide("\xF0\x90\x8C\x80"));
 
   // Error case. When Windows finds an invalid UTF-8 character, it just skips
diff --git a/base/strings/utf_string_conversion_utils.cc b/base/strings/utf_string_conversion_utils.cc
index 149a6ee..d7bbe62 100644
--- a/base/strings/utf_string_conversion_utils.cc
+++ b/base/strings/utf_string_conversion_utils.cc
@@ -11,13 +11,13 @@
 
 // CountUnicodeCharacters ------------------------------------------------------
 
-absl::optional<size_t> CountUnicodeCharacters(const char16_t* src,
-                                              size_t src_len,
+absl::optional<size_t> CountUnicodeCharacters(std::string_view text,
                                               size_t limit) {
   base_icu::UChar32 unused = 0;
   size_t count = 0;
-  for (size_t index = 0; count < limit && index < src_len; ++count, ++index) {
-    if (!ReadUnicodeCharacter(src, src_len, &index, &unused)) {
+  for (size_t index = 0; count < limit && index < text.size();
+       ++count, ++index) {
+    if (!ReadUnicodeCharacter(text.data(), text.size(), &index, &unused)) {
       return absl::nullopt;
     }
   }
diff --git a/base/strings/utf_string_conversion_utils.h b/base/strings/utf_string_conversion_utils.h
index 638a59f..183a7a6 100644
--- a/base/strings/utf_string_conversion_utils.h
+++ b/base/strings/utf_string_conversion_utils.h
@@ -11,7 +11,9 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <limits>
 #include <string>
+#include <string_view>
 
 #include "polyfills/base/base_export.h"
 #include "base/third_party/icu/icu_utf.h"
@@ -43,10 +45,9 @@
 // CountUnicodeCharacters ------------------------------------------------------
 
 // Returns the number of Unicode characters in `text`, up to the supplied
-// `limit`, if `text` contains valid UTF-16. Returns `nullopt` otherwise.
+// `limit`, if `text` contains valid UTF-8. Returns `nullopt` otherwise.
 BASE_EXPORT absl::optional<size_t> CountUnicodeCharacters(
-    const char16_t* src,
-    size_t src_len,
+    std::string_view text,
     size_t limit = std::numeric_limits<size_t>::max());
 
 // ReadUnicodeCharacter --------------------------------------------------------
diff --git a/base/strings/utf_string_conversion_utils_unittest.cc b/base/strings/utf_string_conversion_utils_unittest.cc
index 4e700dc..10f9201 100644
--- a/base/strings/utf_string_conversion_utils_unittest.cc
+++ b/base/strings/utf_string_conversion_utils_unittest.cc
@@ -12,19 +12,24 @@
 namespace gurl_base {
 
 TEST(UtfStringConversionUtilsTest, CountUnicodeCharacters) {
-  struct TestCase {
-    std::u16string value;
+  const struct TestCase {
+    std::string value;
     size_t limit;
     absl::optional<size_t> count;
   } test_cases[] = {
-      {u"", 0, 0},           {u"abc", 1, 1},
-      {u"abc", 3, 3},        {u"abc", 0, 0},
-      {u"abc", 4, 3},        {u"abc\U0001F4A9", 4, 4},
-      {u"\U0001F4A9", 1, 1}, {{1, 0xD801u}, 5, absl::nullopt},
+      {"", 0, 0},
+      {"abc", 1, 1},
+      {"abc", 3, 3},
+      {"abc", 0, 0},
+      {"abc", 4, 3},
+      // The casts and u8 string literals are needed here so that we don't
+      // trigger linter errors about invalid ascii values.
+      {reinterpret_cast<const char*>(u8"abc\U0001F4A9"), 4, 4},
+      {reinterpret_cast<const char*>(u8"\U0001F4A9"), 1, 1},
+      {{1, static_cast<char>(-1)}, 5, absl::nullopt},
   };
   for (const auto& test_case : test_cases) {
-    EXPECT_EQ(CountUnicodeCharacters(test_case.value.data(),
-                                     test_case.value.length(), test_case.limit),
+    EXPECT_EQ(CountUnicodeCharacters(test_case.value, test_case.limit),
               test_case.count);
   }
 }
diff --git a/base/strings/utf_string_conversions.h b/base/strings/utf_string_conversions.h
index 1ee702c..d7f1ce7 100644
--- a/base/strings/utf_string_conversions.h
+++ b/base/strings/utf_string_conversions.h
@@ -67,27 +67,24 @@
 
 // The conversion functions in this file should not be used to convert string
 // literals. Instead, the corresponding prefixes (e.g. u"" for UTF16 or L"" for
-// Wide) should be used. Deleting the overloads here catches these cases at
-// compile time.
+// Wide) should be used. Catch those cases with overloads that assert at compile
+// time.
 template <size_t N>
-std::u16string WideToUTF16(const wchar_t (&str)[N]) {
+[[noreturn]] std::u16string WideToUTF16(const wchar_t (&str)[N]) {
   static_assert(AlwaysFalse<decltype(N)>,
-                "Error: Use the u\"...\" prefix instead.");
-  return std::u16string();
+                "Error: Use u\"...\" to create a std::u16string literal.");
 }
 
 template <size_t N>
-std::u16string UTF8ToUTF16(const char (&str)[N]) {
+[[noreturn]] std::u16string UTF8ToUTF16(const char (&str)[N]) {
   static_assert(AlwaysFalse<decltype(N)>,
-                "Error: Use the u\"...\" prefix instead.");
-  return std::u16string();
+                "Error: Use u\"...\" to create a std::u16string literal.");
 }
 
 template <size_t N>
-std::u16string ASCIIToUTF16(const char (&str)[N]) {
+[[noreturn]] std::u16string ASCIIToUTF16(const char (&str)[N]) {
   static_assert(AlwaysFalse<decltype(N)>,
-                "Error: Use the u\"...\" prefix instead.");
-  return std::u16string();
+                "Error: Use u\"...\" to create a std::u16string literal.");
 }
 
 // Mutable character arrays are usually only populated during runtime. Continue
diff --git a/copy.bara.sky b/copy.bara.sky
index 72fde7e..45c9192 100644
--- a/copy.bara.sky
+++ b/copy.bara.sky
@@ -113,7 +113,9 @@
     core.replace("base/trace_event/base_tracing.h", "polyfills/third_party/perfetto/include/perfetto/tracing/traced_value.h"),
     core.replace("base/trace_event/base_tracing_forward.h", "polyfills/third_party/perfetto/include/perfetto/tracing/traced_value.h"),
     core.replace("#include \"base/strings/string_number_conversions_win.h\"", ""),
-    core.replace("#include \"base/allocator/partition_allocator/partition_alloc_config.h\"", ""),
+    # Patch out C++20 feature use
+    core.replace("                           std::is_same<iter_value_t<T>, char8_t>,", ""),
+    #core.replace("#include \"base/allocator/partition_allocator/partition_alloc_config.h\"", ""),
 
     # Use system ICU.
     core.replace(
diff --git a/url/gurl.cc b/url/gurl.cc
index dea8c7a..f905498 100644
--- a/url/gurl.cc
+++ b/url/gurl.cc
@@ -9,12 +9,12 @@
 #include <algorithm>
 #include <memory>
 #include <ostream>
+#include <string_view>
 #include <utility>
 
 #include "polyfills/base/check_op.h"
 #include "base/no_destructor.h"
 #include "polyfills/base/notreached.h"
-#include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "polyfills/third_party/perfetto/include/perfetto/tracing/traced_value.h"
 #include "polyfills/base/trace_event/memory_usage_estimator.h"
@@ -43,11 +43,11 @@
   other.parsed_ = url::Parsed();
 }
 
-GURL::GURL(gurl_base::StringPiece url_string) {
+GURL::GURL(std::string_view url_string) {
   InitCanonical(url_string, true);
 }
 
-GURL::GURL(gurl_base::StringPiece16 url_string) {
+GURL::GURL(std::u16string_view url_string) {
   InitCanonical(url_string, true);
 }
 
@@ -174,7 +174,7 @@
 }
 
 // Note: code duplicated below (it's inconvenient to use a template here).
-GURL GURL::Resolve(gurl_base::StringPiece relative) const {
+GURL GURL::Resolve(std::string_view relative) const {
   // Not allowed for invalid URLs.
   if (!is_valid_)
     return GURL();
@@ -200,7 +200,7 @@
 }
 
 // Note: code duplicated above (it's inconvenient to use a template here).
-GURL GURL::Resolve(gurl_base::StringPiece16 relative) const {
+GURL GURL::Resolve(std::u16string_view relative) const {
   // Not allowed for invalid URLs.
   if (!is_valid_)
     return GURL();
@@ -355,7 +355,7 @@
   return IsAboutUrl(url::kAboutSrcdocPath);
 }
 
-bool GURL::SchemeIs(gurl_base::StringPiece lower_ascii_scheme) const {
+bool GURL::SchemeIs(std::string_view lower_ascii_scheme) const {
   GURL_DCHECK(gurl_base::IsStringASCII(lower_ascii_scheme));
   GURL_DCHECK(gurl_base::ToLowerASCII(lower_ascii_scheme) == lower_ascii_scheme);
 
@@ -378,7 +378,7 @@
   return SchemeIsCryptographic(scheme_piece());
 }
 
-bool GURL::SchemeIsCryptographic(gurl_base::StringPiece lower_ascii_scheme) {
+bool GURL::SchemeIsCryptographic(std::string_view lower_ascii_scheme) {
   GURL_DCHECK(gurl_base::IsStringASCII(lower_ascii_scheme));
   GURL_DCHECK(gurl_base::ToLowerASCII(lower_ascii_scheme) == lower_ascii_scheme);
 
@@ -413,13 +413,13 @@
   return ComponentString(file_component);
 }
 
-gurl_base::StringPiece GURL::PathForRequestPiece() const {
+std::string_view GURL::PathForRequestPiece() const {
   GURL_DCHECK(parsed_.path.is_nonempty())
       << "Canonical path for requests should be non-empty";
   if (parsed_.ref.is_valid()) {
     // Clip off the reference when it exists. The reference starts after the
     // #-sign, so we have to subtract one to also remove it.
-    return gurl_base::StringPiece(spec_).substr(
+    return std::string_view(spec_).substr(
         parsed_.path.begin, parsed_.ref.begin - parsed_.path.begin - 1);
   }
   // Compute the actual path length, rather than depending on the spec's
@@ -429,7 +429,7 @@
   if (parsed_.query.is_valid())
     path_len = parsed_.query.end() - parsed_.path.begin;
 
-  return gurl_base::StringPiece(spec_).substr(parsed_.path.begin, path_len);
+  return std::string_view(spec_).substr(parsed_.path.begin, path_len);
 }
 
 std::string GURL::PathForRequest() const {
@@ -440,7 +440,7 @@
   return std::string(HostNoBracketsPiece());
 }
 
-gurl_base::StringPiece GURL::HostNoBracketsPiece() const {
+std::string_view GURL::HostNoBracketsPiece() const {
   // If host looks like an IPv6 literal, strip the square brackets.
   url::Component h(parsed_.host);
   if (h.len >= 2 && spec_[h.begin] == '[' && spec_[h.end() - 1] == ']') {
@@ -454,9 +454,9 @@
   return std::string(GetContentPiece());
 }
 
-gurl_base::StringPiece GURL::GetContentPiece() const {
+std::string_view GURL::GetContentPiece() const {
   if (!is_valid_)
-    return gurl_base::StringPiece();
+    return std::string_view();
   url::Component content_component = parsed_.GetContent();
   if (!SchemeIs(url::kJavaScriptScheme) && parsed_.ref.is_valid())
     content_component.len -= parsed_.ref.len + 1;
@@ -472,7 +472,7 @@
   return *empty_gurl;
 }
 
-bool GURL::DomainIs(gurl_base::StringPiece canonical_domain) const {
+bool GURL::DomainIs(std::string_view canonical_domain) const {
   if (!is_valid_)
     return false;
 
@@ -486,8 +486,8 @@
   int ref_position = parsed_.CountCharactersBefore(url::Parsed::REF, true);
   int ref_position_other =
       other.parsed_.CountCharactersBefore(url::Parsed::REF, true);
-  return gurl_base::StringPiece(spec_).substr(0, ref_position) ==
-         gurl_base::StringPiece(other.spec_).substr(0, ref_position_other);
+  return std::string_view(spec_).substr(0, ref_position) ==
+         std::string_view(other.spec_).substr(0, ref_position_other);
 }
 
 void GURL::Swap(GURL* other) {
@@ -503,7 +503,7 @@
          (parsed_.inner_parsed() ? sizeof(url::Parsed) : 0);
 }
 
-bool GURL::IsAboutUrl(gurl_base::StringPiece allowed_path) const {
+bool GURL::IsAboutUrl(std::string_view allowed_path) const {
   if (!SchemeIs(url::kAboutScheme))
     return false;
 
@@ -514,8 +514,8 @@
 }
 
 // static
-bool GURL::IsAboutPath(gurl_base::StringPiece actual_path,
-                       gurl_base::StringPiece allowed_path) {
+bool GURL::IsAboutPath(std::string_view actual_path,
+                       std::string_view allowed_path) {
   if (!gurl_base::StartsWith(actual_path, allowed_path))
     return false;
 
@@ -549,22 +549,22 @@
   return !(x == y);
 }
 
-bool operator==(const GURL& x, const gurl_base::StringPiece& spec) {
+bool operator==(const GURL& x, std::string_view spec) {
   GURL_DCHECK_EQ(GURL(spec).possibly_invalid_spec(), spec)
       << "Comparisons of GURLs and strings must ensure as a precondition that "
          "the string is fully canonicalized.";
   return x.possibly_invalid_spec() == spec;
 }
 
-bool operator==(const gurl_base::StringPiece& spec, const GURL& x) {
+bool operator==(std::string_view spec, const GURL& x) {
   return x == spec;
 }
 
-bool operator!=(const GURL& x, const gurl_base::StringPiece& spec) {
+bool operator!=(const GURL& x, std::string_view spec) {
   return !(x == spec);
 }
 
-bool operator!=(const gurl_base::StringPiece& spec, const GURL& x) {
+bool operator!=(std::string_view spec, const GURL& x) {
   return !(x == spec);
 }
 
diff --git a/url/gurl.h b/url/gurl.h
index 1b29989..931c803 100644
--- a/url/gurl.h
+++ b/url/gurl.h
@@ -10,11 +10,11 @@
 #include <iosfwd>
 #include <memory>
 #include <string>
+#include <string_view>
 
 #include "polyfills/base/component_export.h"
 #include "polyfills/base/debug/alias.h"
 #include "base/debug/crash_logging.h"
-#include "base/strings/string_piece.h"
 #include "polyfills/third_party/perfetto/include/perfetto/tracing/traced_value.h"
 #include "url/third_party/mozilla/url_parse.h"
 #include "url/url_canon.h"
@@ -46,8 +46,8 @@
 // will know to escape this and produce the desired result.
 class COMPONENT_EXPORT(URL) GURL {
  public:
-  typedef url::StringPieceReplacements<char> Replacements;
-  typedef url::StringPieceReplacements<char16_t> ReplacementsW;
+  using Replacements = url::StringViewReplacements<char>;
+  using ReplacementsW = url::StringViewReplacements<char16_t>;
 
   // Creates an empty, invalid URL.
   GURL();
@@ -57,9 +57,9 @@
   GURL(const GURL& other);
   GURL(GURL&& other) noexcept;
 
-  // The strings to this contructor should be UTF-8 / UTF-16.
-  explicit GURL(gurl_base::StringPiece url_string);
-  explicit GURL(gurl_base::StringPiece16 url_string);
+  // The strings to this constructor should be UTF-8 / UTF-16.
+  explicit GURL(std::string_view url_string);
+  explicit GURL(std::u16string_view url_string);
 
   // Constructor for URLs that have already been parsed and canonicalized. This
   // is used for conversions from KURL, for example. The caller must supply all
@@ -152,8 +152,8 @@
   //
   // It is an error to resolve a URL relative to an invalid URL. The result
   // will be the empty URL.
-  GURL Resolve(gurl_base::StringPiece relative) const;
-  GURL Resolve(gurl_base::StringPiece16 relative) const;
+  GURL Resolve(std::string_view relative) const;
+  GURL Resolve(std::u16string_view relative) const;
 
   // Creates a new GURL by replacing the current URL's components with the
   // supplied versions. See the Replacements class in url_canon.h for more.
@@ -238,7 +238,7 @@
   // Returns true if the given parameter (should be lower-case ASCII to match
   // the canonicalized scheme) is the scheme for this URL. Do not include a
   // colon.
-  bool SchemeIs(gurl_base::StringPiece lower_ascii_scheme) const;
+  bool SchemeIs(std::string_view lower_ascii_scheme) const;
 
   // Returns true if the scheme is "http" or "https".
   bool SchemeIsHTTPOrHTTPS() const;
@@ -267,7 +267,7 @@
   bool SchemeIsCryptographic() const;
 
   // As above, but static. Parameter should be lower-case ASCII.
-  static bool SchemeIsCryptographic(gurl_base::StringPiece lower_ascii_scheme);
+  static bool SchemeIsCryptographic(std::string_view lower_ascii_scheme);
 
   // Returns true if the scheme is "blob".
   bool SchemeIsBlob() const {
@@ -286,7 +286,7 @@
   // It is an error to get the content of an invalid URL: the result will be an
   // empty string.
   std::string GetContent() const;
-  gurl_base::StringPiece GetContentPiece() const;
+  std::string_view GetContentPiece() const;
 
   // Returns true if the hostname is an IP address. Note: this function isn't
   // as cheap as a simple getter because it re-parses the hostname to verify.
@@ -297,7 +297,7 @@
   std::string scheme() const {
     return ComponentString(parsed_.scheme);
   }
-  gurl_base::StringPiece scheme_piece() const {
+  std::string_view scheme_piece() const {
     return ComponentStringPiece(parsed_.scheme);
   }
 
@@ -305,7 +305,7 @@
   std::string username() const {
     return ComponentString(parsed_.username);
   }
-  gurl_base::StringPiece username_piece() const {
+  std::string_view username_piece() const {
     return ComponentStringPiece(parsed_.username);
   }
 
@@ -313,7 +313,7 @@
   std::string password() const {
     return ComponentString(parsed_.password);
   }
-  gurl_base::StringPiece password_piece() const {
+  std::string_view password_piece() const {
     return ComponentStringPiece(parsed_.password);
   }
 
@@ -327,7 +327,7 @@
   std::string host() const {
     return ComponentString(parsed_.host);
   }
-  gurl_base::StringPiece host_piece() const {
+  std::string_view host_piece() const {
     return ComponentStringPiece(parsed_.host);
   }
 
@@ -338,7 +338,7 @@
   std::string port() const {
     return ComponentString(parsed_.port);
   }
-  gurl_base::StringPiece port_piece() const {
+  std::string_view port_piece() const {
     return ComponentStringPiece(parsed_.port);
   }
 
@@ -348,7 +348,7 @@
   std::string path() const {
     return ComponentString(parsed_.path);
   }
-  gurl_base::StringPiece path_piece() const {
+  std::string_view path_piece() const {
     return ComponentStringPiece(parsed_.path);
   }
 
@@ -357,7 +357,7 @@
   std::string query() const {
     return ComponentString(parsed_.query);
   }
-  gurl_base::StringPiece query_piece() const {
+  std::string_view query_piece() const {
     return ComponentStringPiece(parsed_.query);
   }
 
@@ -367,7 +367,7 @@
   std::string ref() const {
     return ComponentString(parsed_.ref);
   }
-  gurl_base::StringPiece ref_piece() const {
+  std::string_view ref_piece() const {
     return ComponentStringPiece(parsed_.ref);
   }
 
@@ -389,14 +389,14 @@
   std::string PathForRequest() const;
 
   // Returns the same characters as PathForRequest(), avoiding a copy.
-  gurl_base::StringPiece PathForRequestPiece() const;
+  std::string_view PathForRequestPiece() const;
 
   // Returns the host, excluding the square brackets surrounding IPv6 address
   // literals. This can be useful for passing to getaddrinfo().
   std::string HostNoBrackets() const;
 
   // Returns the same characters as HostNoBrackets(), avoiding a copy.
-  gurl_base::StringPiece HostNoBracketsPiece() const;
+  std::string_view HostNoBracketsPiece() const;
 
   // Returns true if this URL's host matches or is in the same domain as
   // the given input string. For example, if the hostname of the URL is
@@ -409,7 +409,7 @@
   // This call is more efficient than getting the host and checking whether the
   // host has the specific domain or not because no copies or object
   // constructions are done.
-  bool DomainIs(gurl_base::StringPiece canonical_domain) const;
+  bool DomainIs(std::string_view canonical_domain) const;
 
   // Checks whether or not two URLs differ only in the ref (the part after
   // the # character).
@@ -440,8 +440,8 @@
   size_t EstimateMemoryUsage() const;
 
   // Helper used by GURL::IsAboutUrl and KURL::IsAboutURL.
-  static bool IsAboutPath(gurl_base::StringPiece actual_path,
-                          gurl_base::StringPiece allowed_path);
+  static bool IsAboutPath(std::string_view actual_path,
+                          std::string_view allowed_path);
 
   void WriteIntoTrace(perfetto::TracedValue context) const;
 
@@ -460,17 +460,17 @@
   void InitializeFromCanonicalSpec();
 
   // Helper used by IsAboutBlank and IsAboutSrcdoc.
-  bool IsAboutUrl(gurl_base::StringPiece allowed_path) const;
+  bool IsAboutUrl(std::string_view allowed_path) const;
 
   // Returns the substring of the input identified by the given component.
   std::string ComponentString(const url::Component& comp) const {
     return std::string(ComponentStringPiece(comp));
   }
-  gurl_base::StringPiece ComponentStringPiece(const url::Component& comp) const {
+  std::string_view ComponentStringPiece(const url::Component& comp) const {
     if (comp.is_empty())
-      return gurl_base::StringPiece();
-    return gurl_base::StringPiece(spec_).substr(static_cast<size_t>(comp.begin),
-                                           static_cast<size_t>(comp.len));
+      return std::string_view();
+    return std::string_view(spec_).substr(static_cast<size_t>(comp.begin),
+                                          static_cast<size_t>(comp.len));
   }
 
   void ProcessFileSystemURLAfterReplaceComponents();
@@ -501,13 +501,13 @@
 // url == GURL(spec) where |spec| is known (i.e. constants). This is to prevent
 // needlessly re-parsing |spec| into a temporary GURL.
 COMPONENT_EXPORT(URL)
-bool operator==(const GURL& x, const gurl_base::StringPiece& spec);
+bool operator==(const GURL& x, std::string_view spec);
 COMPONENT_EXPORT(URL)
-bool operator==(const gurl_base::StringPiece& spec, const GURL& x);
+bool operator==(std::string_view spec, const GURL& x);
 COMPONENT_EXPORT(URL)
-bool operator!=(const GURL& x, const gurl_base::StringPiece& spec);
+bool operator!=(const GURL& x, std::string_view spec);
 COMPONENT_EXPORT(URL)
-bool operator!=(const gurl_base::StringPiece& spec, const GURL& x);
+bool operator!=(std::string_view spec, const GURL& x);
 
 // DEBUG_ALIAS_FOR_GURL(var_name, url) copies |url| into a new stack-allocated
 // variable named |<var_name>|.  This helps ensure that the value of |url| gets
diff --git a/url/gurl_abstract_tests.h b/url/gurl_abstract_tests.h
index d787d3e..6ef976c 100644
--- a/url/gurl_abstract_tests.h
+++ b/url/gurl_abstract_tests.h
@@ -11,7 +11,7 @@
 // by parametrizing the tests with a class that has to expose the following
 // members:
 //   using UrlType = ...;
-//   static UrlType CreateUrlFromString(gurl_base::StringPiece s);
+//   static UrlType CreateUrlFromString(std::string_view s);
 //   static bool IsAboutBlank(const UrlType& url);
 //   static bool IsAboutSrcdoc(const UrlType& url);
 template <typename TUrlTraits>
@@ -23,7 +23,7 @@
   // avoid hitting: explicit qualification required to use member 'IsAboutBlank'
   // from dependent base class.
   using UrlType = typename TUrlTraits::UrlType;
-  UrlType CreateUrlFromString(gurl_base::StringPiece s) {
+  UrlType CreateUrlFromString(std::string_view s) {
     return TUrlTraits::CreateUrlFromString(s);
   }
   bool IsAboutBlank(const UrlType& url) {
diff --git a/url/gurl_unittest.cc b/url/gurl_unittest.cc
index c6be656..36dd969 100644
--- a/url/gurl_unittest.cc
+++ b/url/gurl_unittest.cc
@@ -838,8 +838,8 @@
 
   GURL url_with_escape_chars("https://www.,.test");
   EXPECT_TRUE(url_with_escape_chars.is_valid());
-  EXPECT_EQ(url_with_escape_chars.host(), "www.%2C.test");
-  EXPECT_TRUE(url_with_escape_chars.DomainIs("%2C.test"));
+  EXPECT_EQ(url_with_escape_chars.host(), "www.,.test");
+  EXPECT_TRUE(url_with_escape_chars.DomainIs(",.test"));
 }
 
 TEST(GURLTest, DomainIsTerminatingDotBehavior) {
@@ -1167,7 +1167,7 @@
  public:
   using UrlType = GURL;
 
-  static UrlType CreateUrlFromString(gurl_base::StringPiece s) { return GURL(s); }
+  static UrlType CreateUrlFromString(std::string_view s) { return GURL(s); }
   static bool IsAboutBlank(const UrlType& url) { return url.IsAboutBlank(); }
   static bool IsAboutSrcdoc(const UrlType& url) { return url.IsAboutSrcdoc(); }
 
diff --git a/url/origin.cc b/url/origin.cc
index 0274f34..45017ea 100644
--- a/url/origin.cc
+++ b/url/origin.cc
@@ -9,6 +9,7 @@
 #include <algorithm>
 #include <ostream>
 #include <string>
+#include <string_view>
 #include <tuple>
 #include <utility>
 
@@ -20,7 +21,6 @@
 #include "base/debug/crash_logging.h"
 #include "base/pickle.h"
 #include "base/strings/strcat.h"
-#include "base/strings/string_piece.h"
 #include "polyfills/third_party/perfetto/include/perfetto/tracing/traced_value.h"
 #include "polyfills/base/trace_event/memory_usage_estimator.h"
 #include "base/unguessable_token.h"
@@ -79,8 +79,8 @@
 
 // static
 absl::optional<Origin> Origin::UnsafelyCreateTupleOriginWithoutNormalization(
-    gurl_base::StringPiece scheme,
-    gurl_base::StringPiece host,
+    std::string_view scheme,
+    std::string_view host,
     uint16_t port) {
   SchemeHostPort tuple(std::string(scheme), std::string(host), port,
                        SchemeHostPort::CHECK_CANONICALIZATION);
@@ -91,8 +91,8 @@
 
 // static
 absl::optional<Origin> Origin::UnsafelyCreateOpaqueOriginWithoutNormalization(
-    gurl_base::StringPiece precursor_scheme,
-    gurl_base::StringPiece precursor_host,
+    std::string_view precursor_scheme,
+    std::string_view precursor_host,
     uint16_t precursor_port,
     const Origin::Nonce& nonce) {
   SchemeHostPort precursor(std::string(precursor_scheme),
@@ -249,7 +249,7 @@
   return url.scheme() == tuple_.scheme();
 }
 
-bool Origin::DomainIs(gurl_base::StringPiece canonical_domain) const {
+bool Origin::DomainIs(std::string_view canonical_domain) const {
   return !opaque() && url::DomainIs(tuple_.host(), canonical_domain);
 }
 
diff --git a/url/origin.h b/url/origin.h
index a49cbca..d364454 100644
--- a/url/origin.h
+++ b/url/origin.h
@@ -9,32 +9,24 @@
 
 #include <memory>
 #include <string>
+#include <string_view>
 
 #include "polyfills/base/component_export.h"
 #include "polyfills/base/debug/alias.h"
 #include "base/debug/crash_logging.h"
 #include "base/gtest_prod_util.h"
-#include "base/strings/string_piece_forward.h"
 #include "base/strings/string_util.h"
 #include "polyfills/third_party/perfetto/include/perfetto/tracing/traced_value.h"
 #include "base/unguessable_token.h"
 #include "build/build_config.h"
 #include "build/buildflag.h"
+#include "build/robolectric_buildflags.h"
 #include "absl/types/optional.h"
 #include "url/scheme_host_port.h"
 
-#if BUILDFLAG(IS_ANDROID)
-#include <jni.h>
-
-namespace gurl_base {
-namespace android {
-template <typename>
-class ScopedJavaLocalRef;
-template <typename>
-class JavaRef;
-}  // namespace android
-}  // namespace base
-#endif  // BUILDFLAG(IS_ANDROID)
+#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_ROBOLECTRIC)
+#include "base/android/jni_android.h"
+#endif
 
 class GURL;
 
@@ -199,8 +191,8 @@
   // dangerous recanonicalization); other potential callers should prefer the
   // 'GURL'-based constructor.
   static absl::optional<Origin> UnsafelyCreateTupleOriginWithoutNormalization(
-      gurl_base::StringPiece scheme,
-      gurl_base::StringPiece host,
+      std::string_view scheme,
+      std::string_view host,
       uint16_t port);
 
   // Creates an origin without sanity checking that the host is canonicalized.
@@ -285,7 +277,7 @@
   GURL GetURL() const;
 
   // Same as GURL::DomainIs. If |this| origin is opaque, then returns false.
-  bool DomainIs(gurl_base::StringPiece canonical_domain) const;
+  bool DomainIs(std::string_view canonical_domain) const;
 
   // Allows Origin to be used as a key in STL (for example, a std::set or
   // std::map).
@@ -314,8 +306,8 @@
   // and precursor information.
   std::string GetDebugString(bool include_nonce = true) const;
 
-#if BUILDFLAG(IS_ANDROID)
-  gurl_base::android::ScopedJavaLocalRef<jobject> CreateJavaObject() const;
+#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_ROBOLECTRIC)
+  gurl_base::android::ScopedJavaLocalRef<jobject> ToJavaObject() const;
   static Origin FromJavaObject(
       const gurl_base::android::JavaRef<jobject>& java_origin);
   static jlong CreateNative(JNIEnv* env,
@@ -334,6 +326,13 @@
   size_t EstimateMemoryUsage() const;
 
  private:
+#if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_ROBOLECTRIC)
+  friend Origin CreateOpaqueOriginForAndroid(
+      const std::string& scheme,
+      const std::string& host,
+      uint16_t port,
+      const gurl_base::UnguessableToken& nonce_token);
+#endif
   friend class blink::SecurityOrigin;
   friend class blink::SecurityOriginTest;
   friend class blink::StorageKey;
@@ -419,8 +418,8 @@
   // back and forth over IPC (as transitioning through GURL would risk
   // potentially dangerous recanonicalization).
   static absl::optional<Origin> UnsafelyCreateOpaqueOriginWithoutNormalization(
-      gurl_base::StringPiece precursor_scheme,
-      gurl_base::StringPiece precursor_host,
+      std::string_view precursor_scheme,
+      std::string_view precursor_host,
       uint16_t precursor_port,
       const Nonce& nonce);
 
diff --git a/url/origin_abstract_tests.cc b/url/origin_abstract_tests.cc
index d48a9f5..175abff 100644
--- a/url/origin_abstract_tests.cc
+++ b/url/origin_abstract_tests.cc
@@ -29,7 +29,7 @@
 }
 
 // static
-Origin UrlOriginTestTraits::CreateOriginFromString(gurl_base::StringPiece s) {
+Origin UrlOriginTestTraits::CreateOriginFromString(std::string_view s) {
   return Origin::Create(GURL(s));
 }
 
@@ -40,7 +40,7 @@
 
 // static
 Origin UrlOriginTestTraits::CreateWithReferenceOrigin(
-    gurl_base::StringPiece url,
+    std::string_view url,
     const Origin& reference_origin) {
   return Origin::Resolve(GURL(url), reference_origin);
 }
@@ -94,7 +94,7 @@
 }
 
 // static
-bool UrlOriginTestTraits::IsValidUrl(gurl_base::StringPiece str) {
+bool UrlOriginTestTraits::IsValidUrl(std::string_view str) {
   return GURL(str).is_valid();
 }
 
diff --git a/url/origin_abstract_tests.h b/url/origin_abstract_tests.h
index b89f63f..78483bf 100644
--- a/url/origin_abstract_tests.h
+++ b/url/origin_abstract_tests.h
@@ -6,10 +6,10 @@
 #define URL_ORIGIN_ABSTRACT_TESTS_H_
 
 #include <string>
+#include <string_view>
 #include <type_traits>
 
 #include "base/containers/contains.h"
-#include "base/strings/string_piece.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
@@ -28,10 +28,10 @@
   using OriginType = Origin;
 
   // Constructing an origin.
-  static OriginType CreateOriginFromString(gurl_base::StringPiece s);
+  static OriginType CreateOriginFromString(std::string_view s);
   static OriginType CreateUniqueOpaqueOrigin();
   static OriginType CreateWithReferenceOrigin(
-      gurl_base::StringPiece url,
+      std::string_view url,
       const OriginType& reference_origin);
   static OriginType DeriveNewOpaqueOrigin(const OriginType& reference_origin);
 
@@ -51,7 +51,7 @@
   //
   // TODO(lukasza): Consider merging together OriginTraitsBase here and
   // UrlTraitsBase in //url/gurl_abstract_tests.h.
-  static bool IsValidUrl(gurl_base::StringPiece str);
+  static bool IsValidUrl(std::string_view str);
 
   // Only static members = no constructors are needed.
   UrlOriginTestTraits() = delete;
@@ -95,13 +95,13 @@
   // avoid hitting: explicit qualification required to use member 'IsOpaque'
   // from dependent base class.
   using OriginType = typename TOriginTraits::OriginType;
-  OriginType CreateOriginFromString(gurl_base::StringPiece s) {
+  OriginType CreateOriginFromString(std::string_view s) {
     return TOriginTraits::CreateOriginFromString(s);
   }
   OriginType CreateUniqueOpaqueOrigin() {
     return TOriginTraits::CreateUniqueOpaqueOrigin();
   }
-  OriginType CreateWithReferenceOrigin(gurl_base::StringPiece url,
+  OriginType CreateWithReferenceOrigin(std::string_view url,
                                        const OriginType& reference_origin) {
     return TOriginTraits::CreateWithReferenceOrigin(url, reference_origin);
   }
@@ -132,7 +132,7 @@
   std::string Serialize(const OriginType& origin) {
     return TOriginTraits::Serialize(origin);
   }
-  bool IsValidUrl(gurl_base::StringPiece str) {
+  bool IsValidUrl(std::string_view str) {
     return TOriginTraits::IsValidUrl(str);
   }
 
@@ -213,7 +213,7 @@
     VerifyOriginInvariants(origin);
   }
 
-  void TestUniqueOpaqueOrigin(gurl_base::StringPiece test_input) {
+  void TestUniqueOpaqueOrigin(std::string_view test_input) {
     auto origin = this->CreateOriginFromString(test_input);
     this->VerifyUniqueOpaqueOriginInvariants(origin);
 
diff --git a/url/origin_unittest.cc b/url/origin_unittest.cc
index 5f28acc..ead042a 100644
--- a/url/origin_unittest.cc
+++ b/url/origin_unittest.cc
@@ -76,8 +76,8 @@
   // Wrappers around url::Origin methods to expose it to tests.
 
   absl::optional<Origin> UnsafelyCreateOpaqueOriginWithoutNormalization(
-      gurl_base::StringPiece precursor_scheme,
-      gurl_base::StringPiece precursor_host,
+      std::string_view precursor_scheme,
+      std::string_view precursor_host,
       uint16_t precursor_port,
       const Origin::Nonce& nonce) {
     return Origin::UnsafelyCreateOpaqueOriginWithoutNormalization(
@@ -371,8 +371,8 @@
 
 TEST_F(OriginTest, UnsafelyCreateUniqueViaEmbeddedNulls) {
   struct TestCases {
-    gurl_base::StringPiece scheme;
-    gurl_base::StringPiece host;
+    std::string_view scheme;
+    std::string_view host;
     uint16_t port = 80;
   } cases[] = {{{"http\0more", 9}, {"example.com", 11}},
                {{"http\0", 5}, {"example.com", 11}},
diff --git a/url/scheme_host_port.cc b/url/scheme_host_port.cc
index 2db80a8..0b5e867 100644
--- a/url/scheme_host_port.cc
+++ b/url/scheme_host_port.cc
@@ -8,6 +8,7 @@
 #include <string.h>
 
 #include <ostream>
+#include <string_view>
 #include <tuple>
 
 #include "polyfills/base/check_op.h"
@@ -15,7 +16,6 @@
 #include "polyfills/base/notreached.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/strings/string_piece.h"
 #include "polyfills/base/trace_event/memory_usage_estimator.h"
 #include "url/gurl.h"
 #include "url/third_party/mozilla/url_parse.h"
@@ -28,7 +28,7 @@
 
 namespace {
 
-bool IsCanonicalHost(const gurl_base::StringPiece& host) {
+bool IsCanonicalHost(const std::string_view& host) {
   std::string canon_host;
 
   // Try to canonicalize the host (copy/pasted from net/base. :( ).
@@ -56,8 +56,8 @@
 // ShouldTreatAsOpaqueOrigin in Blink (there might be existing differences in
 // behavior between these 2 layers, but we should avoid introducing new
 // differences).
-bool IsValidInput(const gurl_base::StringPiece& scheme,
-                  const gurl_base::StringPiece& host,
+bool IsValidInput(const std::string_view& scheme,
+                  const std::string_view& host,
                   uint16_t port,
                   SchemeHostPort::ConstructPolicy policy) {
   // Empty schemes are never valid.
@@ -159,8 +159,8 @@
                     << " Port: " << port;
 }
 
-SchemeHostPort::SchemeHostPort(gurl_base::StringPiece scheme,
-                               gurl_base::StringPiece host,
+SchemeHostPort::SchemeHostPort(std::string_view scheme,
+                               std::string_view host,
                                uint16_t port)
     : SchemeHostPort(std::string(scheme),
                      std::string(host),
@@ -171,8 +171,8 @@
   if (!url.is_valid())
     return;
 
-  gurl_base::StringPiece scheme = url.scheme_piece();
-  gurl_base::StringPiece host = url.host_piece();
+  std::string_view scheme = url.scheme_piece();
+  std::string_view host = url.host_piece();
 
   // A valid GURL never returns PORT_INVALID.
   int port = url.EffectiveIntPort();
diff --git a/url/scheme_host_port.h b/url/scheme_host_port.h
index 0798fec..9938824 100644
--- a/url/scheme_host_port.h
+++ b/url/scheme_host_port.h
@@ -8,9 +8,9 @@
 #include <stdint.h>
 
 #include <string>
+#include <string_view>
 
 #include "polyfills/base/component_export.h"
-#include "base/strings/string_piece.h"
 
 class GURL;
 
@@ -84,9 +84,7 @@
   // ports (e.g. 'file').
   //
   // Copies the data in |scheme| and |host|.
-  SchemeHostPort(gurl_base::StringPiece scheme,
-                 gurl_base::StringPiece host,
-                 uint16_t port);
+  SchemeHostPort(std::string_view scheme, std::string_view host, uint16_t port);
 
   // Metadata influencing whether or not the constructor should sanity check
   // host canonicalization.
diff --git a/url/url_canon.h b/url/url_canon.h
index 55fe426..0af495a 100644
--- a/url/url_canon.h
+++ b/url/url_canon.h
@@ -8,6 +8,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <string_view>
+
 #include "polyfills/base/component_export.h"
 #include "polyfills/base/export_template.h"
 #include "polyfills/base/memory/raw_ptr_exclusion.h"
@@ -57,6 +59,11 @@
   // write the data, then use set_size() to declare the new length().
   size_t capacity() const { return buffer_len_; }
 
+  // Returns the contents of the buffer as a string_view.
+  std::basic_string_view<T> view() const {
+    return std::basic_string_view<T>(data(), length());
+  }
+
   // Called by the user of this class to get the output. The output will NOT
   // be NULL-terminated. Call length() to get the
   // length.
@@ -102,6 +109,8 @@
     cur_len_ += str_len;
   }
 
+  void Append(std::basic_string_view<T> str) { Append(str.data(), str.size()); }
+
   void ReserveSizeIfNeeded(size_t estimated_size) {
     // Reserve a bit extra to account for escaped chars.
     if (estimated_size > buffer_len_)
@@ -278,7 +287,7 @@
 //
 // On error, returns false. The output in this case is undefined.
 COMPONENT_EXPORT(URL)
-bool IDNToASCII(const char16_t* src, int src_len, CanonOutputW* output);
+bool IDNToASCII(std::u16string_view src, CanonOutputW* output);
 
 // Piece-by-piece canonicalizers ----------------------------------------------
 //
diff --git a/url/url_canon_filesystemurl.cc b/url/url_canon_filesystemurl.cc
index 0472484..f1a9f1c 100644
--- a/url/url_canon_filesystemurl.cc
+++ b/url/url_canon_filesystemurl.cc
@@ -36,7 +36,7 @@
   // Scheme (known, so we don't bother running it through the more
   // complicated scheme canonicalizer).
   new_parsed->scheme.begin = output->length();
-  output->Append("filesystem:", 11);
+  output->Append("filesystem:");
   new_parsed->scheme.len = 10;
 
   if (!inner_parsed || !inner_parsed->scheme.is_valid())
@@ -46,7 +46,7 @@
   SchemeType inner_scheme_type = SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION;
   if (CompareSchemeComponent(spec, inner_parsed->scheme, url::kFileScheme)) {
     new_inner_parsed.scheme.begin = output->length();
-    output->Append("file://", 7);
+    output->Append("file://");
     new_inner_parsed.scheme.len = 4;
     success &= CanonicalizePath(spec, inner_parsed->path, output,
                                 &new_inner_parsed.path);
diff --git a/url/url_canon_fileurl.cc b/url/url_canon_fileurl.cc
index dae5c4c..5c243f6 100644
--- a/url/url_canon_fileurl.cc
+++ b/url/url_canon_fileurl.cc
@@ -4,7 +4,8 @@
 
 // Functions for canonicalizing "file:" URLs.
 
-#include "base/strings/string_piece.h"
+#include <string_view>
+
 #include "base/strings/string_util.h"
 #include "url/url_canon.h"
 #include "url/url_canon_internal.h"
@@ -18,13 +19,13 @@
 bool IsLocalhost(const char* spec, int begin, int end) {
   if (begin > end)
     return false;
-  return gurl_base::StringPiece(&spec[begin], end - begin) == "localhost";
+  return std::string_view(&spec[begin], end - begin) == "localhost";
 }
 
 bool IsLocalhost(const char16_t* spec, int begin, int end) {
   if (begin > end)
     return false;
-  return gurl_base::StringPiece16(&spec[begin], end - begin) == u"localhost";
+  return std::u16string_view(&spec[begin], end - begin) == u"localhost";
 }
 
 template <typename CHAR>
@@ -134,7 +135,7 @@
   // Scheme (known, so we don't bother running it through the more
   // complicated scheme canonicalizer).
   new_parsed->scheme.begin = output->length();
-  output->Append("file://", 7);
+  output->Append("file://");
   new_parsed->scheme.len = 4;
 
   // If the host is localhost, and the path starts with a Windows drive letter,
diff --git a/url/url_canon_host.cc b/url/url_canon_host.cc
index eacc69f..65118b2 100644
--- a/url/url_canon_host.cc
+++ b/url/url_canon_host.cc
@@ -6,11 +6,14 @@
 #include "polyfills/base/cpu_reduction_experiment.h"
 #include "url/url_canon.h"
 #include "url/url_canon_internal.h"
+#include "url/url_features.h"
 
 namespace url {
 
 namespace {
 
+// clang-format off
+//
 // For reference, here's what IE supports:
 // Key: 0 (disallowed: failure if present in the input)
 //      + (allowed either escaped or unescaped, and unmodified)
@@ -37,19 +40,15 @@
 // I also didn't test if characters affecting HTML parsing are allowed
 // unescaped, e.g. (") or (#), which would indicate the beginning of the path.
 // Surprisingly, space is accepted in the input and always escaped.
-
+//
+// TODO(https://crbug.com/1416013): Remove the above historical reference
+// information once we are 100% standard compliant to the URL Standard.
+//
 // This table lists the canonical version of all characters we allow in the
 // input, with 0 indicating it is disallowed. We use the magic kEscapedHostChar
 // value to indicate that this character should be escaped. We are a little more
 // restrictive than IE, but less restrictive than Firefox.
 //
-// Note that we disallow the % character. We will allow it when part of an
-// escape sequence, of course, but this disallows "%25". Even though IE allows
-// it, allowing it would put us in a funny state. If there was an invalid
-// escape sequence like "%zz", we'll add "%25zz" to the output and fail.
-// Allowing percents means we'll succeed a second time, so validity would change
-// based on how many times you run the canonicalizer. We prefer to always report
-// the same vailidity, so reject this.
 const unsigned char kEsc = 0xff;
 const unsigned char kHostCharLookup[0x80] = {
 // 00-1f: all are invalid
@@ -68,6 +67,27 @@
 //   p    q    r    s    t    u    v    w    x    y    z    {    |    }    ~
     'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',kEsc,kEsc,kEsc,  0 ,  0 };
 
+// The following table is used when kStandardCompliantHostCharLookup feature is
+// enabled. See https://crbug.com/1416013 for details. At present, ' ' (SPACE)
+// and '*' (asterisk) are still non-compliant to the URL Standard.
+const unsigned char kStandardCompliantHostCharLookup[0x80] = {
+// 00-1f: all are invalid
+     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+//  ' '   !    "    #    $    %    &    '    (    )    *    +    ,    -    .    /
+    kEsc,'!', '"',  0,  '$',  0,  '&', '\'','(', ')', kEsc, '+', ',', '-', '.',  0,
+//   0    1    2    3    4    5    6    7    8    9    :    ;    <    =    >    ?
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';' , 0,  '=',  0,   0,
+//   @    A    B    C    D    E    F    G    H    I    J    K    L    M    N    O
+     0,  'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+//   P    Q    R    S    T    U    V    W    X    Y    Z    [    \    ]    ^    _
+    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '[',  0,  ']',  0,  '_',
+//   `    a    b    c    d    e    f    g    h    i    j    k    l    m    n    o
+    '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+//   p    q    r    s    t    u    v    w    x    y    z    {    |    }    ~
+    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{',  0, '}',  '~',  0 };
+// clang-format on
+
 // RFC1034 maximum FQDN length.
 constexpr size_t kMaxHostLength = 253;
 
@@ -149,7 +169,12 @@
 
     if (source < 0x80) {
       // We have ASCII input, we can use our lookup table.
-      unsigned char replacement = kHostCharLookup[source];
+      unsigned char replacement;
+      if (url::IsUsingStandardCompliantHostCharacters()) {
+        replacement = kStandardCompliantHostCharLookup[source];
+      } else {
+        replacement = kHostCharLookup[source];
+      }
       if (!replacement) {
         // Invalid character, add it as percent-escaped and mark as failed.
         AppendEscapedChar(source, output);
@@ -189,9 +214,7 @@
   }
 
   StackBufferW wide_output;
-  if (!IDNToASCII(url_escaped_host.data(),
-                  url_escaped_host.length(),
-                  &wide_output)) {
+  if (!IDNToASCII(url_escaped_host.view(), &wide_output)) {
     // Some error, give up. This will write some reasonable looking
     // representation of the string to the output.
     AppendInvalidNarrowString(src, 0, src_len, output);
@@ -381,7 +404,7 @@
     // we just leave it in place.
     if (host_info->IsIPAddress()) {
       output->set_length(output_begin);
-      output->Append(canon_ip.data(), canon_ip.length());
+      output->Append(canon_ip.view());
     }
   } else {
     // Canonicalization failed. Set BROKEN to notify the caller.
diff --git a/url/url_canon_mailtourl.cc b/url/url_canon_mailtourl.cc
index e48b642..cbd4bb4 100644
--- a/url/url_canon_mailtourl.cc
+++ b/url/url_canon_mailtourl.cc
@@ -45,7 +45,7 @@
   // Scheme (known, so we don't bother running it through the more
   // complicated scheme canonicalizer).
   new_parsed->scheme.begin = output->length();
-  output->Append("mailto:", 7);
+  output->Append("mailto:");
   new_parsed->scheme.len = 6;
 
   bool success = true;
diff --git a/url/url_canon_path.cc b/url/url_canon_path.cc
index 7f917db..440da70 100644
--- a/url/url_canon_path.cc
+++ b/url/url_canon_path.cc
@@ -336,8 +336,7 @@
             // the last character of the escape sequence.
             char unescaped_flags = kPathCharLookup[unescaped_value];
 
-            if (!gurl_base::FeatureList::IsEnabled(
-                    url::kDontDecodeAsciiPercentEncodedURLPath) &&
+            if (!url::IsUsingDontDecodeAsciiPercentEncodedURLPath() &&
                 (unescaped_flags & UNESCAPE)) {
               // This escaped value shouldn't be escaped.  Try to copy it.
               unescape_escaped_char = true;
diff --git a/url/url_canon_stdstring.h b/url/url_canon_stdstring.h
index c8f9500..2ddf569 100644
--- a/url/url_canon_stdstring.h
+++ b/url/url_canon_stdstring.h
@@ -10,11 +10,11 @@
 // we have segregated it here.
 
 #include <string>
+#include <string_view>
 
 #include "base/compiler_specific.h"
 #include "polyfills/base/component_export.h"
 #include "polyfills/base/memory/raw_ptr_exclusion.h"
-#include "base/strings/string_piece.h"
 #include "url/url_canon.h"
 
 namespace url {
@@ -55,64 +55,64 @@
 };
 
 // An extension of the Replacements class that allows the setters to use
-// StringPieces (implicitly allowing strings or char*s).
+// string_views (implicitly allowing strings or char*s).
 //
-// The contents of the StringPieces are not copied and must remain valid until
-// the StringPieceReplacements object goes out of scope.
+// The contents of the string_views are not copied and must remain valid until
+// the StringViewReplacements object goes out of scope.
 //
 // In order to make it harder to misuse the API the setters do not accept rvalue
 // references to std::strings.
 // Note: Extra const char* overloads are necessary to break ambiguities that
 // would otherwise exist for char literals.
 template <typename CharT>
-class StringPieceReplacements : public Replacements<CharT> {
+class StringViewReplacements : public Replacements<CharT> {
  private:
   using StringT = std::basic_string<CharT>;
-  using StringPieceT = gurl_base::BasicStringPiece<CharT>;
+  using StringViewT = std::basic_string_view<CharT>;
   using ParentT = Replacements<CharT>;
   using SetterFun = void (ParentT::*)(const CharT*, const Component&);
 
-  void SetImpl(SetterFun fun, StringPieceT str) {
+  void SetImpl(SetterFun fun, StringViewT str) {
     (this->*fun)(str.data(), Component(0, static_cast<int>(str.size())));
   }
 
  public:
   void SetSchemeStr(const CharT* str) { SetImpl(&ParentT::SetScheme, str); }
-  void SetSchemeStr(StringPieceT str) { SetImpl(&ParentT::SetScheme, str); }
+  void SetSchemeStr(StringViewT str) { SetImpl(&ParentT::SetScheme, str); }
   void SetSchemeStr(const StringT&&) = delete;
 
   void SetUsernameStr(const CharT* str) { SetImpl(&ParentT::SetUsername, str); }
-  void SetUsernameStr(StringPieceT str) { SetImpl(&ParentT::SetUsername, str); }
+  void SetUsernameStr(StringViewT str) { SetImpl(&ParentT::SetUsername, str); }
   void SetUsernameStr(const StringT&&) = delete;
   using ParentT::ClearUsername;
 
   void SetPasswordStr(const CharT* str) { SetImpl(&ParentT::SetPassword, str); }
-  void SetPasswordStr(StringPieceT str) { SetImpl(&ParentT::SetPassword, str); }
+  void SetPasswordStr(StringViewT str) { SetImpl(&ParentT::SetPassword, str); }
   void SetPasswordStr(const StringT&&) = delete;
   using ParentT::ClearPassword;
 
   void SetHostStr(const CharT* str) { SetImpl(&ParentT::SetHost, str); }
-  void SetHostStr(StringPieceT str) { SetImpl(&ParentT::SetHost, str); }
+  void SetHostStr(StringViewT str) { SetImpl(&ParentT::SetHost, str); }
   void SetHostStr(const StringT&&) = delete;
   using ParentT::ClearHost;
 
   void SetPortStr(const CharT* str) { SetImpl(&ParentT::SetPort, str); }
-  void SetPortStr(StringPieceT str) { SetImpl(&ParentT::SetPort, str); }
+  void SetPortStr(StringViewT str) { SetImpl(&ParentT::SetPort, str); }
   void SetPortStr(const StringT&&) = delete;
   using ParentT::ClearPort;
 
   void SetPathStr(const CharT* str) { SetImpl(&ParentT::SetPath, str); }
-  void SetPathStr(StringPieceT str) { SetImpl(&ParentT::SetPath, str); }
+  void SetPathStr(StringViewT str) { SetImpl(&ParentT::SetPath, str); }
   void SetPathStr(const StringT&&) = delete;
   using ParentT::ClearPath;
 
   void SetQueryStr(const CharT* str) { SetImpl(&ParentT::SetQuery, str); }
-  void SetQueryStr(StringPieceT str) { SetImpl(&ParentT::SetQuery, str); }
+  void SetQueryStr(StringViewT str) { SetImpl(&ParentT::SetQuery, str); }
   void SetQueryStr(const StringT&&) = delete;
   using ParentT::ClearQuery;
 
   void SetRefStr(const CharT* str) { SetImpl(&ParentT::SetRef, str); }
-  void SetRefStr(StringPieceT str) { SetImpl(&ParentT::SetRef, str); }
+  void SetRefStr(StringViewT str) { SetImpl(&ParentT::SetRef, str); }
   void SetRefStr(const StringT&&) = delete;
   using ParentT::ClearRef;
 
diff --git a/url/url_canon_unittest.cc b/url/url_canon_unittest.cc
index c1b19d2..da4b7b3 100644
--- a/url/url_canon_unittest.cc
+++ b/url/url_canon_unittest.cc
@@ -6,8 +6,8 @@
 
 #include <errno.h>
 #include <stddef.h>
+#include <string_view>
 
-#include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/gtest_util.h"
 #include "base/test/metrics/histogram_tester.h"
@@ -119,12 +119,12 @@
     {0x10FFFF, "\xF4\x8F\xBF\xBF"},
   };
   std::string out_str;
-  for (size_t i = 0; i < std::size(utf_cases); i++) {
+  for (const auto& utf_case : utf_cases) {
     out_str.clear();
     StdStringCanonOutput output(&out_str);
-    AppendUTF8Value(utf_cases[i].input, &output);
+    AppendUTF8Value(utf_case.input, &output);
     output.Complete();
-    EXPECT_EQ(utf_cases[i].output, out_str);
+    EXPECT_EQ(utf_case.output, out_str);
   }
 }
 
@@ -171,27 +171,27 @@
   };
 
   std::string out_str;
-  for (size_t i = 0; i < std::size(utf_cases); i++) {
-    if (utf_cases[i].input8) {
+  for (const auto& utf_case : utf_cases) {
+    if (utf_case.input8) {
       out_str.clear();
       StdStringCanonOutput output(&out_str);
 
-      size_t input_len = strlen(utf_cases[i].input8);
+      size_t input_len = strlen(utf_case.input8);
       bool success = true;
       for (size_t ch = 0; ch < input_len; ch++) {
-        success &= AppendUTF8EscapedChar(utf_cases[i].input8, &ch, input_len,
-                                         &output);
+        success &=
+            AppendUTF8EscapedChar(utf_case.input8, &ch, input_len, &output);
       }
       output.Complete();
-      EXPECT_EQ(utf_cases[i].expected_success, success);
-      EXPECT_EQ(std::string(utf_cases[i].output), out_str);
+      EXPECT_EQ(utf_case.expected_success, success);
+      EXPECT_EQ(std::string(utf_case.output), out_str);
     }
-    if (utf_cases[i].input16) {
+    if (utf_case.input16) {
       out_str.clear();
       StdStringCanonOutput output(&out_str);
 
       std::u16string input_str(
-          test_utils::TruncateWStringToUTF16(utf_cases[i].input16));
+          test_utils::TruncateWStringToUTF16(utf_case.input16));
       size_t input_len = input_str.length();
       bool success = true;
       for (size_t ch = 0; ch < input_len; ch++) {
@@ -199,18 +199,17 @@
                                          &output);
       }
       output.Complete();
-      EXPECT_EQ(utf_cases[i].expected_success, success);
-      EXPECT_EQ(std::string(utf_cases[i].output), out_str);
+      EXPECT_EQ(utf_case.expected_success, success);
+      EXPECT_EQ(std::string(utf_case.output), out_str);
     }
 
-    if (utf_cases[i].input8 && utf_cases[i].input16 &&
-        utf_cases[i].expected_success) {
+    if (utf_case.input8 && utf_case.input16 && utf_case.expected_success) {
       // Check that the UTF-8 and UTF-16 inputs are equivalent.
 
       // UTF-16 -> UTF-8
-      std::string input8_str(utf_cases[i].input8);
+      std::string input8_str(utf_case.input8);
       std::u16string input16_str(
-          test_utils::TruncateWStringToUTF16(utf_cases[i].input16));
+          test_utils::TruncateWStringToUTF16(utf_case.input16));
       EXPECT_EQ(input8_str, gurl_base::UTF16ToUTF8(input16_str));
 
       // UTF-8 -> UTF-16
@@ -242,36 +241,36 @@
 
   std::string out_str;
 
-  for (size_t i = 0; i < std::size(scheme_cases); i++) {
-    int url_len = static_cast<int>(strlen(scheme_cases[i].input));
+  for (const auto& scheme_case : scheme_cases) {
+    int url_len = static_cast<int>(strlen(scheme_case.input));
     Component in_comp(0, url_len);
     Component out_comp;
 
     out_str.clear();
     StdStringCanonOutput output1(&out_str);
-    bool success = CanonicalizeScheme(scheme_cases[i].input, in_comp, &output1,
-                                      &out_comp);
+    bool success =
+        CanonicalizeScheme(scheme_case.input, in_comp, &output1, &out_comp);
     output1.Complete();
 
-    EXPECT_EQ(scheme_cases[i].expected_success, success);
-    EXPECT_EQ(std::string(scheme_cases[i].expected), out_str);
-    EXPECT_EQ(scheme_cases[i].expected_component.begin, out_comp.begin);
-    EXPECT_EQ(scheme_cases[i].expected_component.len, out_comp.len);
+    EXPECT_EQ(scheme_case.expected_success, success);
+    EXPECT_EQ(std::string(scheme_case.expected), out_str);
+    EXPECT_EQ(scheme_case.expected_component.begin, out_comp.begin);
+    EXPECT_EQ(scheme_case.expected_component.len, out_comp.len);
 
     // Now try the wide version.
     out_str.clear();
     StdStringCanonOutput output2(&out_str);
 
-    std::u16string wide_input(gurl_base::UTF8ToUTF16(scheme_cases[i].input));
+    std::u16string wide_input(gurl_base::UTF8ToUTF16(scheme_case.input));
     in_comp.len = static_cast<int>(wide_input.length());
     success = CanonicalizeScheme(wide_input.c_str(), in_comp, &output2,
                                  &out_comp);
     output2.Complete();
 
-    EXPECT_EQ(scheme_cases[i].expected_success, success);
-    EXPECT_EQ(std::string(scheme_cases[i].expected), out_str);
-    EXPECT_EQ(scheme_cases[i].expected_component.begin, out_comp.begin);
-    EXPECT_EQ(scheme_cases[i].expected_component.len, out_comp.len);
+    EXPECT_EQ(scheme_case.expected_success, success);
+    EXPECT_EQ(std::string(scheme_case.expected), out_str);
+    EXPECT_EQ(scheme_case.expected_component.begin, out_comp.begin);
+    EXPECT_EQ(scheme_case.expected_component.len, out_comp.len);
   }
 
   // Test the case where the scheme is declared nonexistent, it should be
@@ -315,23 +314,29 @@
 TEST_P(URLCanonHostTest, Host) {
   bool use_idna_non_transitional = IsUsingIDNA2008NonTransitional();
 
+  // clang-format off
   IPAddressCase host_cases[] = {
       // Basic canonicalization, uppercase should be converted to lowercase.
       {"GoOgLe.CoM", L"GoOgLe.CoM", "google.com", Component(0, 10),
        CanonHostInfo::NEUTRAL, -1, ""},
-      // Spaces and some other characters should be escaped.
-      {"Goo%20 goo%7C|.com", L"Goo%20 goo%7C|.com", "goo%20%20goo%7C%7C.com",
-       Component(0, 22), CanonHostInfo::NEUTRAL, -1, ""},
+      // TODO(https://crbug.com/1416013): Update the test after SPACE is
+      // correctly handled.
+      {"Goo%20 goo.com", L"Goo%20 goo.com", "goo%20%20goo.com",
+       Component(0, 16), CanonHostInfo::NEUTRAL, -1, ""},
+      // TODO(https://crbug.com/1416013): Update the test after ASTERISK is
+      // correctly handled.
+      {"Goo%2a*goo.com", L"Goo%2a*goo.com", "goo%2A%2Agoo.com",
+       Component(0, 16), CanonHostInfo::NEUTRAL, -1, ""},
       // Exciting different types of spaces!
-      {NULL, L"GOO\x00a0\x3000goo.com", "goo%20%20goo.com", Component(0, 16),
+      {nullptr, L"GOO\x00a0\x3000goo.com", "goo%20%20goo.com", Component(0, 16),
        CanonHostInfo::NEUTRAL, -1, ""},
       // Other types of space (no-break, zero-width, zero-width-no-break) are
       // name-prepped away to nothing.
-      {NULL, L"GOO\x200b\x2060\xfeffgoo.com", "googoo.com", Component(0, 10),
+      {nullptr, L"GOO\x200b\x2060\xfeffgoo.com", "googoo.com", Component(0, 10),
        CanonHostInfo::NEUTRAL, -1, ""},
       // Ideographic full stop (full-width period for Chinese, etc.) should be
       // treated as a dot.
-      {NULL,
+      {nullptr,
        L"www.foo\x3002"
        L"bar.com",
        "www.foo.bar.com", Component(0, 15), CanonHostInfo::NEUTRAL, -1, ""},
@@ -437,7 +442,7 @@
       // Fullwidth exclamation mark is disallowed. UTS 46, table 4, row (b)
       // However, we do allow this at the moment because we don't use
       // STD3 rules and canonicalize full-width ASCII to ASCII.
-      {"wow\xef\xbc\x81", L"wow\xff01", "wow%21", Component(0, 6),
+      {"wow\xef\xbc\x81", L"wow\xff01", "wow!", Component(0, 4),
        CanonHostInfo::NEUTRAL, -1, ""},
       // U+2132 (turned capital F) is disallowed. UTS 46, table 4, row (c)
       // Allowed in IDNA 2003, but the mapping changed after Unicode 3.2
@@ -575,7 +580,7 @@
       // before punycode string was created. I.e.
       // if '(' is escaped after punycode is created we would get xn--%28-8tb
       // (incorrect).
-      {"\xd1\x82(", L"\x0442(", "xn--%28-7ed", Component(0, 11),
+      {"\xd1\x82(", L"\x0442(", "xn--(-8tb", Component(0, 9),
        CanonHostInfo::NEUTRAL, -1, ""},
       // Address with all hexadecimal characters with leading number of 1<<32
       // or greater and should return NEUTRAL rather than BROKEN if not all
@@ -597,37 +602,38 @@
       {"xn--m\xc3\xbcnchen", L"xn--m\xfcnchen", "xn--m%C3%BCnchen",
        Component(0, 16), CanonHostInfo::BROKEN, -1, ""},
   };
+  // clang-format on
 
   // CanonicalizeHost() non-verbose.
   std::string out_str;
-  for (size_t i = 0; i < std::size(host_cases); i++) {
+  for (const auto& host_case : host_cases) {
     // Narrow version.
-    if (host_cases[i].input8) {
-      int host_len = static_cast<int>(strlen(host_cases[i].input8));
+    if (host_case.input8) {
+      int host_len = static_cast<int>(strlen(host_case.input8));
       Component in_comp(0, host_len);
       Component out_comp;
 
       out_str.clear();
       StdStringCanonOutput output(&out_str);
 
-      bool success = CanonicalizeHost(host_cases[i].input8, in_comp, &output,
-                                      &out_comp);
+      bool success =
+          CanonicalizeHost(host_case.input8, in_comp, &output, &out_comp);
       output.Complete();
 
-      EXPECT_EQ(host_cases[i].expected_family != CanonHostInfo::BROKEN,
-                success) << "for input: " << host_cases[i].input8;
-      EXPECT_EQ(std::string(host_cases[i].expected), out_str) <<
-                "for input: " << host_cases[i].input8;
-      EXPECT_EQ(host_cases[i].expected_component.begin, out_comp.begin) <<
-                "for input: " << host_cases[i].input8;
-      EXPECT_EQ(host_cases[i].expected_component.len, out_comp.len) <<
-                "for input: " << host_cases[i].input8;
+      EXPECT_EQ(host_case.expected_family != CanonHostInfo::BROKEN, success)
+          << "for input: " << host_case.input8;
+      EXPECT_EQ(std::string(host_case.expected), out_str)
+          << "for input: " << host_case.input8;
+      EXPECT_EQ(host_case.expected_component.begin, out_comp.begin)
+          << "for input: " << host_case.input8;
+      EXPECT_EQ(host_case.expected_component.len, out_comp.len)
+          << "for input: " << host_case.input8;
     }
 
     // Wide version.
-    if (host_cases[i].input16) {
+    if (host_case.input16) {
       std::u16string input16(
-          test_utils::TruncateWStringToUTF16(host_cases[i].input16));
+          test_utils::TruncateWStringToUTF16(host_case.input16));
       int host_len = static_cast<int>(input16.length());
       Component in_comp(0, host_len);
       Component out_comp;
@@ -639,46 +645,43 @@
                                       &out_comp);
       output.Complete();
 
-      EXPECT_EQ(host_cases[i].expected_family != CanonHostInfo::BROKEN,
-                success);
-      EXPECT_EQ(std::string(host_cases[i].expected), out_str);
-      EXPECT_EQ(host_cases[i].expected_component.begin, out_comp.begin);
-      EXPECT_EQ(host_cases[i].expected_component.len, out_comp.len);
+      EXPECT_EQ(host_case.expected_family != CanonHostInfo::BROKEN, success);
+      EXPECT_EQ(std::string(host_case.expected), out_str);
+      EXPECT_EQ(host_case.expected_component.begin, out_comp.begin);
+      EXPECT_EQ(host_case.expected_component.len, out_comp.len);
     }
   }
 
   // CanonicalizeHostVerbose()
-  for (size_t i = 0; i < std::size(host_cases); i++) {
+  for (const auto& host_case : host_cases) {
     // Narrow version.
-    if (host_cases[i].input8) {
-      int host_len = static_cast<int>(strlen(host_cases[i].input8));
+    if (host_case.input8) {
+      int host_len = static_cast<int>(strlen(host_case.input8));
       Component in_comp(0, host_len);
 
       out_str.clear();
       StdStringCanonOutput output(&out_str);
       CanonHostInfo host_info;
 
-      CanonicalizeHostVerbose(host_cases[i].input8, in_comp, &output,
-                              &host_info);
+      CanonicalizeHostVerbose(host_case.input8, in_comp, &output, &host_info);
       output.Complete();
 
-      EXPECT_EQ(host_cases[i].expected_family, host_info.family);
-      EXPECT_EQ(std::string(host_cases[i].expected), out_str);
-      EXPECT_EQ(host_cases[i].expected_component.begin,
-                host_info.out_host.begin);
-      EXPECT_EQ(host_cases[i].expected_component.len, host_info.out_host.len);
-      EXPECT_EQ(std::string(host_cases[i].expected_address_hex),
+      EXPECT_EQ(host_case.expected_family, host_info.family);
+      EXPECT_EQ(std::string(host_case.expected), out_str);
+      EXPECT_EQ(host_case.expected_component.begin, host_info.out_host.begin);
+      EXPECT_EQ(host_case.expected_component.len, host_info.out_host.len);
+      EXPECT_EQ(std::string(host_case.expected_address_hex),
                 BytesToHexString(host_info.address, host_info.AddressLength()));
-      if (host_cases[i].expected_family == CanonHostInfo::IPV4) {
-        EXPECT_EQ(host_cases[i].expected_num_ipv4_components,
+      if (host_case.expected_family == CanonHostInfo::IPV4) {
+        EXPECT_EQ(host_case.expected_num_ipv4_components,
                   host_info.num_ipv4_components);
       }
     }
 
     // Wide version.
-    if (host_cases[i].input16) {
+    if (host_case.input16) {
       std::u16string input16(
-          test_utils::TruncateWStringToUTF16(host_cases[i].input16));
+          test_utils::TruncateWStringToUTF16(host_case.input16));
       int host_len = static_cast<int>(input16.length());
       Component in_comp(0, host_len);
 
@@ -689,21 +692,71 @@
       CanonicalizeHostVerbose(input16.c_str(), in_comp, &output, &host_info);
       output.Complete();
 
-      EXPECT_EQ(host_cases[i].expected_family, host_info.family);
-      EXPECT_EQ(std::string(host_cases[i].expected), out_str);
-      EXPECT_EQ(host_cases[i].expected_component.begin,
-                host_info.out_host.begin);
-      EXPECT_EQ(host_cases[i].expected_component.len, host_info.out_host.len);
-      EXPECT_EQ(std::string(host_cases[i].expected_address_hex),
+      EXPECT_EQ(host_case.expected_family, host_info.family);
+      EXPECT_EQ(std::string(host_case.expected), out_str);
+      EXPECT_EQ(host_case.expected_component.begin, host_info.out_host.begin);
+      EXPECT_EQ(host_case.expected_component.len, host_info.out_host.len);
+      EXPECT_EQ(std::string(host_case.expected_address_hex),
                 BytesToHexString(host_info.address, host_info.AddressLength()));
-      if (host_cases[i].expected_family == CanonHostInfo::IPV4) {
-        EXPECT_EQ(host_cases[i].expected_num_ipv4_components,
+      if (host_case.expected_family == CanonHostInfo::IPV4) {
+        EXPECT_EQ(host_case.expected_num_ipv4_components,
                   host_info.num_ipv4_components);
       }
     }
   }
 }
 
+TEST(URLCanonTest, HostPuncutationChar) {
+  // '%' is not tested here. '%' is used for percent-escaping.
+  const std::string_view allowed_host_chars[] = {
+      "!", "\"", "$", "&", "'", "(", ")", "+", ",",
+      "-", ".",  ";", "=", "_", "`", "{", "}", "~",
+  };
+
+  const std::string_view forbidden_host_chars[] = {
+      "#", "/", ":", "<", ">", "?", "@", "[", "\\", "]", "^", "|",
+  };
+
+  // Standard non-compliant characters which are escaped. See
+  // https://crbug.com/1416013.
+  struct EscapedCharTestCase {
+    std::string_view input;
+    std::string_view expected;
+  } escaped_host_chars[] = {{" ", "%20"}, {"*", "%2A"}};
+
+  for (const std::string_view input : allowed_host_chars) {
+    std::string out_str;
+    Component in_comp(0, input.size());
+    Component out_comp;
+    StdStringCanonOutput output(&out_str);
+    bool success = CanonicalizeHost(input.data(), in_comp, &output, &out_comp);
+    EXPECT_TRUE(success) << "Input: " << input;
+    output.Complete();
+    EXPECT_EQ(out_str, input) << "Input: " << input;
+  }
+
+  for (const std::string_view input : forbidden_host_chars) {
+    std::string out_str;
+    Component in_comp(0, input.size());
+    Component out_comp;
+    StdStringCanonOutput output(&out_str);
+    EXPECT_FALSE(CanonicalizeHost(input.data(), in_comp, &output, &out_comp))
+        << "Input: " << input;
+  }
+
+  for (const auto& c : escaped_host_chars) {
+    std::string out_str;
+    Component in_comp(0, c.input.size());
+    Component out_comp;
+    StdStringCanonOutput output(&out_str);
+    bool success =
+        CanonicalizeHost(c.input.data(), in_comp, &output, &out_comp);
+    EXPECT_TRUE(success) << "Input: " << c.input;
+    output.Complete();
+    EXPECT_EQ(out_str, c.expected) << "Input: " << c.input;
+  }
+}
+
 TEST(URLCanonTest, IPv4) {
   // clang-format off
   IPAddressCase cases[] = {
@@ -1130,34 +1183,30 @@
     {"ftp://me\\mydomain:pass@foo.com/", "", Component(0, -1), Component(0, -1), true},
   };
 
-  for (size_t i = 0; i < std::size(user_info_cases); i++) {
-    int url_len = static_cast<int>(strlen(user_info_cases[i].input));
+  for (const auto& user_info_case : user_info_cases) {
+    int url_len = static_cast<int>(strlen(user_info_case.input));
     Parsed parsed;
-    ParseStandardURL(user_info_cases[i].input, url_len, &parsed);
+    ParseStandardURL(user_info_case.input, url_len, &parsed);
     Component out_user, out_pass;
     std::string out_str;
     StdStringCanonOutput output1(&out_str);
 
-    bool success = CanonicalizeUserInfo(user_info_cases[i].input,
-                                        parsed.username,
-                                        user_info_cases[i].input,
-                                        parsed.password,
-                                        &output1,
-                                        &out_user,
-                                        &out_pass);
+    bool success = CanonicalizeUserInfo(user_info_case.input, parsed.username,
+                                        user_info_case.input, parsed.password,
+                                        &output1, &out_user, &out_pass);
     output1.Complete();
 
-    EXPECT_EQ(user_info_cases[i].expected_success, success);
-    EXPECT_EQ(std::string(user_info_cases[i].expected), out_str);
-    EXPECT_EQ(user_info_cases[i].expected_username.begin, out_user.begin);
-    EXPECT_EQ(user_info_cases[i].expected_username.len, out_user.len);
-    EXPECT_EQ(user_info_cases[i].expected_password.begin, out_pass.begin);
-    EXPECT_EQ(user_info_cases[i].expected_password.len, out_pass.len);
+    EXPECT_EQ(user_info_case.expected_success, success);
+    EXPECT_EQ(std::string(user_info_case.expected), out_str);
+    EXPECT_EQ(user_info_case.expected_username.begin, out_user.begin);
+    EXPECT_EQ(user_info_case.expected_username.len, out_user.len);
+    EXPECT_EQ(user_info_case.expected_password.begin, out_pass.begin);
+    EXPECT_EQ(user_info_case.expected_password.len, out_pass.len);
 
     // Now try the wide version
     out_str.clear();
     StdStringCanonOutput output2(&out_str);
-    std::u16string wide_input(gurl_base::UTF8ToUTF16(user_info_cases[i].input));
+    std::u16string wide_input(gurl_base::UTF8ToUTF16(user_info_case.input));
     success = CanonicalizeUserInfo(wide_input.c_str(),
                                    parsed.username,
                                    wide_input.c_str(),
@@ -1167,12 +1216,12 @@
                                    &out_pass);
     output2.Complete();
 
-    EXPECT_EQ(user_info_cases[i].expected_success, success);
-    EXPECT_EQ(std::string(user_info_cases[i].expected), out_str);
-    EXPECT_EQ(user_info_cases[i].expected_username.begin, out_user.begin);
-    EXPECT_EQ(user_info_cases[i].expected_username.len, out_user.len);
-    EXPECT_EQ(user_info_cases[i].expected_password.begin, out_pass.begin);
-    EXPECT_EQ(user_info_cases[i].expected_password.len, out_pass.len);
+    EXPECT_EQ(user_info_case.expected_success, success);
+    EXPECT_EQ(std::string(user_info_case.expected), out_str);
+    EXPECT_EQ(user_info_case.expected_username.begin, out_user.begin);
+    EXPECT_EQ(user_info_case.expected_username.len, out_user.len);
+    EXPECT_EQ(user_info_case.expected_password.begin, out_pass.begin);
+    EXPECT_EQ(user_info_case.expected_password.len, out_pass.len);
   }
 }
 
@@ -1199,39 +1248,33 @@
     {"80", PORT_UNSPECIFIED, ":80", Component(1, 2), true},
   };
 
-  for (size_t i = 0; i < std::size(port_cases); i++) {
-    int url_len = static_cast<int>(strlen(port_cases[i].input));
+  for (const auto& port_case : port_cases) {
+    int url_len = static_cast<int>(strlen(port_case.input));
     Component in_comp(0, url_len);
     Component out_comp;
     std::string out_str;
     StdStringCanonOutput output1(&out_str);
-    bool success = CanonicalizePort(port_cases[i].input,
-                                    in_comp,
-                                    port_cases[i].default_port,
-                                    &output1,
-                                    &out_comp);
+    bool success = CanonicalizePort(
+        port_case.input, in_comp, port_case.default_port, &output1, &out_comp);
     output1.Complete();
 
-    EXPECT_EQ(port_cases[i].expected_success, success);
-    EXPECT_EQ(std::string(port_cases[i].expected), out_str);
-    EXPECT_EQ(port_cases[i].expected_component.begin, out_comp.begin);
-    EXPECT_EQ(port_cases[i].expected_component.len, out_comp.len);
+    EXPECT_EQ(port_case.expected_success, success);
+    EXPECT_EQ(std::string(port_case.expected), out_str);
+    EXPECT_EQ(port_case.expected_component.begin, out_comp.begin);
+    EXPECT_EQ(port_case.expected_component.len, out_comp.len);
 
     // Now try the wide version
     out_str.clear();
     StdStringCanonOutput output2(&out_str);
-    std::u16string wide_input(gurl_base::UTF8ToUTF16(port_cases[i].input));
-    success = CanonicalizePort(wide_input.c_str(),
-                               in_comp,
-                               port_cases[i].default_port,
-                               &output2,
-                               &out_comp);
+    std::u16string wide_input(gurl_base::UTF8ToUTF16(port_case.input));
+    success = CanonicalizePort(wide_input.c_str(), in_comp,
+                               port_case.default_port, &output2, &out_comp);
     output2.Complete();
 
-    EXPECT_EQ(port_cases[i].expected_success, success);
-    EXPECT_EQ(std::string(port_cases[i].expected), out_str);
-    EXPECT_EQ(port_cases[i].expected_component.begin, out_comp.begin);
-    EXPECT_EQ(port_cases[i].expected_component.len, out_comp.len);
+    EXPECT_EQ(port_case.expected_success, success);
+    EXPECT_EQ(std::string(port_case.expected), out_str);
+    EXPECT_EQ(port_case.expected_component.begin, out_comp.begin);
+    EXPECT_EQ(port_case.expected_component.len, out_comp.len);
   }
 }
 
@@ -1437,34 +1480,34 @@
     {"q=\"asdf\"", L"q=\"asdf\"", "?q=%22asdf%22"},
   };
 
-  for (size_t i = 0; i < std::size(query_cases); i++) {
+  for (const auto& query_case : query_cases) {
     Component out_comp;
 
-    if (query_cases[i].input8) {
-      int len = static_cast<int>(strlen(query_cases[i].input8));
+    if (query_case.input8) {
+      int len = static_cast<int>(strlen(query_case.input8));
       Component in_comp(0, len);
       std::string out_str;
 
       StdStringCanonOutput output(&out_str);
-      CanonicalizeQuery(query_cases[i].input8, in_comp, NULL, &output,
+      CanonicalizeQuery(query_case.input8, in_comp, nullptr, &output,
                         &out_comp);
       output.Complete();
 
-      EXPECT_EQ(query_cases[i].expected, out_str);
+      EXPECT_EQ(query_case.expected, out_str);
     }
 
-    if (query_cases[i].input16) {
+    if (query_case.input16) {
       std::u16string input16(
-          test_utils::TruncateWStringToUTF16(query_cases[i].input16));
+          test_utils::TruncateWStringToUTF16(query_case.input16));
       int len = static_cast<int>(input16.length());
       Component in_comp(0, len);
       std::string out_str;
 
       StdStringCanonOutput output(&out_str);
-      CanonicalizeQuery(input16.c_str(), in_comp, NULL, &output, &out_comp);
+      CanonicalizeQuery(input16.c_str(), in_comp, nullptr, &output, &out_comp);
       output.Complete();
 
-      EXPECT_EQ(query_cases[i].expected, out_str);
+      EXPECT_EQ(query_case.expected, out_str);
     }
   }
 
@@ -1472,7 +1515,8 @@
   std::string out_str;
   StdStringCanonOutput output(&out_str);
   Component out_comp;
-  CanonicalizeQuery("a \x00z\x01", Component(0, 5), NULL, &output, &out_comp);
+  CanonicalizeQuery("a \x00z\x01", Component(0, 5), nullptr, &output,
+                    &out_comp);
   output.Complete();
   EXPECT_EQ("?a%20%00z%01", out_str);
 }
@@ -1509,27 +1553,27 @@
       {"#asdf", L"#asdf", "##asdf", Component(1, 5), true},
   };
 
-  for (size_t i = 0; i < std::size(ref_cases); i++) {
+  for (const auto& ref_case : ref_cases) {
     // 8-bit input
-    if (ref_cases[i].input8) {
-      int len = static_cast<int>(strlen(ref_cases[i].input8));
+    if (ref_case.input8) {
+      int len = static_cast<int>(strlen(ref_case.input8));
       Component in_comp(0, len);
       Component out_comp;
 
       std::string out_str;
       StdStringCanonOutput output(&out_str);
-      CanonicalizeRef(ref_cases[i].input8, in_comp, &output, &out_comp);
+      CanonicalizeRef(ref_case.input8, in_comp, &output, &out_comp);
       output.Complete();
 
-      EXPECT_EQ(ref_cases[i].expected_component.begin, out_comp.begin);
-      EXPECT_EQ(ref_cases[i].expected_component.len, out_comp.len);
-      EXPECT_EQ(ref_cases[i].expected, out_str);
+      EXPECT_EQ(ref_case.expected_component.begin, out_comp.begin);
+      EXPECT_EQ(ref_case.expected_component.len, out_comp.len);
+      EXPECT_EQ(ref_case.expected, out_str);
     }
 
     // 16-bit input
-    if (ref_cases[i].input16) {
+    if (ref_case.input16) {
       std::u16string input16(
-          test_utils::TruncateWStringToUTF16(ref_cases[i].input16));
+          test_utils::TruncateWStringToUTF16(ref_case.input16));
       int len = static_cast<int>(input16.length());
       Component in_comp(0, len);
       Component out_comp;
@@ -1539,9 +1583,9 @@
       CanonicalizeRef(input16.c_str(), in_comp, &output, &out_comp);
       output.Complete();
 
-      EXPECT_EQ(ref_cases[i].expected_component.begin, out_comp.begin);
-      EXPECT_EQ(ref_cases[i].expected_component.len, out_comp.len);
-      EXPECT_EQ(ref_cases[i].expected, out_str);
+      EXPECT_EQ(ref_case.expected_component.begin, out_comp.begin);
+      EXPECT_EQ(ref_case.expected_component.len, out_comp.len);
+      EXPECT_EQ(ref_case.expected, out_str);
     }
   }
 
@@ -1564,24 +1608,14 @@
   // The individual component canonicalize tests should have caught the cases
   // for each of those components. Here, we just need to test that the various
   // parts are included or excluded properly, and have the correct separators.
+  // clang-format off
   struct URLCase {
     const char* input;
     const char* expected;
     bool expected_success;
   } cases[] = {
-      {"http://www.google.com/foo?bar=baz#",
-       "http://www.google.com/foo?bar=baz#", true},
-      {"http://[www.google.com]/", "http://[www.google.com]/", false},
-      {"ht\ttp:@www.google.com:80/;p?#", "ht%09tp://www.google.com:80/;p?#",
-       false},
-      {"http:////////user:@google.com:99?foo", "http://user@google.com:99/?foo",
-       true},
-      {"www.google.com", ":www.google.com/", false},
-      {"http://192.0x00A80001", "http://192.168.0.1/", true},
-      {"http://www/foo%2Ehtml", "http://www/foo.html", true},
-      {"http://user:pass@/", "http://user:pass@/", false},
-      {"http://%25DOMAIN:foobar@foodomain.com/",
-       "http://%25DOMAIN:foobar@foodomain.com/", true},
+    {"http://www.google.com/foo?bar=baz#", "http://www.google.com/foo?bar=baz#",
+     true},
 
       // Backslashes should get converted to forward slashes.
       {"http:\\\\www.google.com\\foo", "http://www.google.com/foo", true},
@@ -1618,27 +1652,28 @@
       // ICU will convert to an ASCII one, generating "%81".
       {"ws:)W\x1eW\xef\xb9\xaa"
        "81:80/",
-       "ws://%29w%1ew%81/", false},
+       "ws://)w%1ew%81/", false},
       // Regression test for the last_invalid_percent_index bug described in
       // https://crbug.com/1080890#c10.
       {R"(HTTP:S/5%\../>%41)", "http://s/%3E%41", true},
   };
+  // clang-format on
 
-  for (size_t i = 0; i < std::size(cases); i++) {
-    int url_len = static_cast<int>(strlen(cases[i].input));
+  for (const auto& i : cases) {
+    int url_len = static_cast<int>(strlen(i.input));
     Parsed parsed;
-    ParseStandardURL(cases[i].input, url_len, &parsed);
+    ParseStandardURL(i.input, url_len, &parsed);
 
     Parsed out_parsed;
     std::string out_str;
     StdStringCanonOutput output(&out_str);
     bool success = CanonicalizeStandardURL(
-        cases[i].input, url_len, parsed,
-        SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION, NULL, &output, &out_parsed);
+        i.input, url_len, parsed, SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION,
+        nullptr, &output, &out_parsed);
     output.Complete();
 
-    EXPECT_EQ(cases[i].expected_success, success);
-    EXPECT_EQ(cases[i].expected, out_str);
+    EXPECT_EQ(i.expected_success, success);
+    EXPECT_EQ(i.expected, out_str);
   }
 }
 
@@ -1665,8 +1700,8 @@
        "filesystem://a:b@google.com:22/foo?baz@cat"},
   };
 
-  for (size_t i = 0; i < std::size(replace_cases); i++) {
-    const ReplaceCase& cur = replace_cases[i];
+  for (const auto& replace_case : replace_cases) {
+    const ReplaceCase& cur = replace_case;
     int base_len = static_cast<int>(strlen(cur.base));
     Parsed parsed;
     ParseStandardURL(cur.base, base_len, &parsed);
@@ -1688,12 +1723,12 @@
     std::string out_str;
     StdStringCanonOutput output(&out_str);
     Parsed out_parsed;
-    ReplaceStandardURL(replace_cases[i].base, parsed, r,
-                       SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION, NULL,
+    ReplaceStandardURL(replace_case.base, parsed, r,
+                       SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION, nullptr,
                        &output, &out_parsed);
     output.Complete();
 
-    EXPECT_EQ(replace_cases[i].expected, out_str);
+    EXPECT_EQ(replace_case.expected, out_str);
   }
 
   // The path pointer should be ignored if the address is invalid.
@@ -1712,7 +1747,7 @@
     StdStringCanonOutput output1(&out_str1);
     Parsed new_parsed;
     ReplaceStandardURL(src, parsed, r,
-                       SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION, NULL,
+                       SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION, nullptr,
                        &output1, &new_parsed);
     output1.Complete();
     EXPECT_STREQ("http://www.google.com/", out_str1.c_str());
@@ -1722,7 +1757,7 @@
     std::string out_str2;
     StdStringCanonOutput output2(&out_str2);
     ReplaceStandardURL(src, parsed, r,
-                       SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION, NULL,
+                       SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION, nullptr,
                        &output2, &new_parsed);
     output2.Complete();
     EXPECT_STREQ("http://www.google.com/", out_str2.c_str());
@@ -1765,8 +1800,8 @@
        nullptr, nullptr, nullptr, "file:///C:/gaba?query#ref"},
   };
 
-  for (size_t i = 0; i < std::size(replace_cases); i++) {
-    const ReplaceCase& cur = replace_cases[i];
+  for (const auto& replace_case : replace_cases) {
+    const ReplaceCase& cur = replace_case;
     SCOPED_TRACE(cur.base);
     int base_len = static_cast<int>(strlen(cur.base));
     Parsed parsed;
@@ -1786,10 +1821,10 @@
     std::string out_str;
     StdStringCanonOutput output(&out_str);
     Parsed out_parsed;
-    ReplaceFileURL(cur.base, parsed, r, NULL, &output, &out_parsed);
+    ReplaceFileURL(cur.base, parsed, r, nullptr, &output, &out_parsed);
     output.Complete();
 
-    EXPECT_EQ(replace_cases[i].expected, out_str);
+    EXPECT_EQ(replace_case.expected, out_str);
   }
 }
 
@@ -1834,8 +1869,8 @@
        "filesystem:http://bar.com:40/t/gaba?query#ref"},
   };
 
-  for (size_t i = 0; i < std::size(replace_cases); i++) {
-    const ReplaceCase& cur = replace_cases[i];
+  for (const auto& replace_case : replace_cases) {
+    const ReplaceCase& cur = replace_case;
     int base_len = static_cast<int>(strlen(cur.base));
     Parsed parsed;
     ParseFileSystemURL(cur.base, base_len, &parsed);
@@ -1854,10 +1889,10 @@
     std::string out_str;
     StdStringCanonOutput output(&out_str);
     Parsed out_parsed;
-    ReplaceFileSystemURL(cur.base, parsed, r, NULL, &output, &out_parsed);
+    ReplaceFileSystemURL(cur.base, parsed, r, nullptr, &output, &out_parsed);
     output.Complete();
 
-    EXPECT_EQ(replace_cases[i].expected, out_str);
+    EXPECT_EQ(replace_case.expected, out_str);
   }
 }
 
@@ -1878,8 +1913,8 @@
        nullptr, nullptr, "data:"},
   };
 
-  for (size_t i = 0; i < std::size(replace_cases); i++) {
-    const ReplaceCase& cur = replace_cases[i];
+  for (const auto& replace_case : replace_cases) {
+    const ReplaceCase& cur = replace_case;
     int base_len = static_cast<int>(strlen(cur.base));
     Parsed parsed;
     ParsePathURL(cur.base, base_len, false, &parsed);
@@ -1901,36 +1936,46 @@
     ReplacePathURL(cur.base, parsed, r, &output, &out_parsed);
     output.Complete();
 
-    EXPECT_EQ(replace_cases[i].expected, out_str);
+    EXPECT_EQ(replace_case.expected, out_str);
   }
 }
 
 TEST(URLCanonTest, ReplaceMailtoURL) {
   ReplaceCase replace_cases[] = {
       // Replace everything
-    {"mailto:jon@foo.com?body=sup", "mailto", NULL, NULL, NULL, NULL, "addr1", "to=tony", NULL, "mailto:addr1?to=tony"},
+      {"mailto:jon@foo.com?body=sup", "mailto", nullptr, nullptr, nullptr,
+       nullptr, "addr1", "to=tony", nullptr, "mailto:addr1?to=tony"},
       // Replace nothing
-    {"mailto:jon@foo.com?body=sup", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "mailto:jon@foo.com?body=sup"},
+      {"mailto:jon@foo.com?body=sup", nullptr, nullptr, nullptr, nullptr,
+       nullptr, nullptr, nullptr, nullptr, "mailto:jon@foo.com?body=sup"},
       // Replace the path
-    {"mailto:jon@foo.com?body=sup", NULL, NULL, NULL, NULL, NULL, "jason", NULL, NULL, "mailto:jason?body=sup"},
+      {"mailto:jon@foo.com?body=sup", nullptr, nullptr, nullptr, nullptr,
+       nullptr, "jason", nullptr, nullptr, "mailto:jason?body=sup"},
       // Replace the query
-    {"mailto:jon@foo.com?body=sup", NULL, NULL, NULL, NULL, NULL, NULL, "custom=1", NULL, "mailto:jon@foo.com?custom=1"},
+      {"mailto:jon@foo.com?body=sup", nullptr, nullptr, nullptr, nullptr,
+       nullptr, nullptr, "custom=1", nullptr, "mailto:jon@foo.com?custom=1"},
       // Replace the path and query
-    {"mailto:jon@foo.com?body=sup", NULL, NULL, NULL, NULL, NULL, "jason", "custom=1", NULL, "mailto:jason?custom=1"},
+      {"mailto:jon@foo.com?body=sup", nullptr, nullptr, nullptr, nullptr,
+       nullptr, "jason", "custom=1", nullptr, "mailto:jason?custom=1"},
       // Set the query to empty (should leave trailing question mark)
-    {"mailto:jon@foo.com?body=sup", NULL, NULL, NULL, NULL, NULL, NULL, "", NULL, "mailto:jon@foo.com?"},
+      {"mailto:jon@foo.com?body=sup", nullptr, nullptr, nullptr, nullptr,
+       nullptr, nullptr, "", nullptr, "mailto:jon@foo.com?"},
       // Clear the query
-    {"mailto:jon@foo.com?body=sup", NULL, NULL, NULL, NULL, NULL, NULL, "|", NULL, "mailto:jon@foo.com"},
+      {"mailto:jon@foo.com?body=sup", nullptr, nullptr, nullptr, nullptr,
+       nullptr, nullptr, "|", nullptr, "mailto:jon@foo.com"},
       // Clear the path
-    {"mailto:jon@foo.com?body=sup", NULL, NULL, NULL, NULL, NULL, "|", NULL, NULL, "mailto:?body=sup"},
+      {"mailto:jon@foo.com?body=sup", nullptr, nullptr, nullptr, nullptr,
+       nullptr, "|", nullptr, nullptr, "mailto:?body=sup"},
       // Clear the path + query
-    {"mailto:", NULL, NULL, NULL, NULL, NULL, "|", "|", NULL, "mailto:"},
+      {"mailto:", nullptr, nullptr, nullptr, nullptr, nullptr, "|", "|",
+       nullptr, "mailto:"},
       // Setting the ref should have no effect
-    {"mailto:addr1", NULL, NULL, NULL, NULL, NULL, NULL, NULL, "BLAH", "mailto:addr1"},
+      {"mailto:addr1", nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
+       nullptr, "BLAH", "mailto:addr1"},
   };
 
-  for (size_t i = 0; i < std::size(replace_cases); i++) {
-    const ReplaceCase& cur = replace_cases[i];
+  for (const auto& replace_case : replace_cases) {
+    const ReplaceCase& cur = replace_case;
     int base_len = static_cast<int>(strlen(cur.base));
     Parsed parsed;
     ParseMailtoURL(cur.base, base_len, &parsed);
@@ -1952,7 +1997,7 @@
     ReplaceMailtoURL(cur.base, parsed, r, &output, &out_parsed);
     output.Complete();
 
-    EXPECT_EQ(replace_cases[i].expected, out_str);
+    EXPECT_EQ(replace_case.expected, out_str);
   }
 }
 
@@ -2042,31 +2087,31 @@
 #endif  // _WIN32
   };
 
-  for (size_t i = 0; i < std::size(cases); i++) {
-    int url_len = static_cast<int>(strlen(cases[i].input));
+  for (const auto& i : cases) {
+    int url_len = static_cast<int>(strlen(i.input));
     Parsed parsed;
-    ParseFileURL(cases[i].input, url_len, &parsed);
+    ParseFileURL(i.input, url_len, &parsed);
 
     Parsed out_parsed;
     std::string out_str;
     StdStringCanonOutput output(&out_str);
-    bool success = CanonicalizeFileURL(cases[i].input, url_len, parsed, NULL,
+    bool success = CanonicalizeFileURL(i.input, url_len, parsed, nullptr,
                                        &output, &out_parsed);
     output.Complete();
 
-    EXPECT_EQ(cases[i].expected_success, success);
-    EXPECT_EQ(cases[i].expected, out_str);
+    EXPECT_EQ(i.expected_success, success);
+    EXPECT_EQ(i.expected, out_str);
 
     // Make sure the spec was properly identified, the file canonicalizer has
     // different code for writing the spec.
     EXPECT_EQ(0, out_parsed.scheme.begin);
     EXPECT_EQ(4, out_parsed.scheme.len);
 
-    EXPECT_EQ(cases[i].expected_host.begin, out_parsed.host.begin);
-    EXPECT_EQ(cases[i].expected_host.len, out_parsed.host.len);
+    EXPECT_EQ(i.expected_host.begin, out_parsed.host.begin);
+    EXPECT_EQ(i.expected_host.len, out_parsed.host.len);
 
-    EXPECT_EQ(cases[i].expected_path.begin, out_parsed.path.begin);
-    EXPECT_EQ(cases[i].expected_path.len, out_parsed.path.len);
+    EXPECT_EQ(i.expected_path.begin, out_parsed.path.begin);
+    EXPECT_EQ(i.expected_path.len, out_parsed.path.len);
   }
 }
 
@@ -2088,23 +2133,23 @@
       {"filesystem:fiLe:///temporary", "filesystem:file:///temporary/", true},
       {"filesystem:File:///temporary/Bob?qUery#reF",
        "filesystem:file:///temporary/Bob?qUery#reF", true},
-      {"FilEsysteM:htTp:E=/.", "filesystem:http://e%3D//", false},
+      {"FilEsysteM:htTp:E=/.", "filesystem:http://e=//", false},
   };
 
-  for (size_t i = 0; i < std::size(cases); i++) {
-    int url_len = static_cast<int>(strlen(cases[i].input));
+  for (const auto& i : cases) {
+    int url_len = static_cast<int>(strlen(i.input));
     Parsed parsed;
-    ParseFileSystemURL(cases[i].input, url_len, &parsed);
+    ParseFileSystemURL(i.input, url_len, &parsed);
 
     Parsed out_parsed;
     std::string out_str;
     StdStringCanonOutput output(&out_str);
-    bool success = CanonicalizeFileSystemURL(cases[i].input, url_len, parsed,
-                                             NULL, &output, &out_parsed);
+    bool success = CanonicalizeFileSystemURL(i.input, url_len, parsed, nullptr,
+                                             &output, &out_parsed);
     output.Complete();
 
-    EXPECT_EQ(cases[i].expected_success, success);
-    EXPECT_EQ(cases[i].expected, out_str);
+    EXPECT_EQ(i.expected_success, success);
+    EXPECT_EQ(i.expected, out_str);
 
     // Make sure the spec was properly identified, the filesystem canonicalizer
     // has different code for writing the spec.
@@ -2130,26 +2175,26 @@
       {"javascript:\uFFFF", "javascript:%EF%BF%BF"},
   };
 
-  for (size_t i = 0; i < std::size(path_cases); i++) {
-    int url_len = static_cast<int>(strlen(path_cases[i].input));
+  for (const auto& path_case : path_cases) {
+    int url_len = static_cast<int>(strlen(path_case.input));
     Parsed parsed;
-    ParsePathURL(path_cases[i].input, url_len, true, &parsed);
+    ParsePathURL(path_case.input, url_len, true, &parsed);
 
     Parsed out_parsed;
     std::string out_str;
     StdStringCanonOutput output(&out_str);
-    bool success = CanonicalizePathURL(path_cases[i].input, url_len, parsed,
+    bool success = CanonicalizePathURL(path_case.input, url_len, parsed,
                                        &output, &out_parsed);
     output.Complete();
 
     EXPECT_TRUE(success);
-    EXPECT_EQ(path_cases[i].expected, out_str);
+    EXPECT_EQ(path_case.expected, out_str);
 
     EXPECT_EQ(0, out_parsed.host.begin);
     EXPECT_EQ(-1, out_parsed.host.len);
 
     // When we end with a colon at the end, there should be no path.
-    if (path_cases[i].input[url_len - 1] == ':') {
+    if (path_case.input[url_len - 1] == ':') {
       EXPECT_EQ(0, out_parsed.GetContent().begin);
       EXPECT_EQ(-1, out_parsed.GetContent().len);
     }
@@ -2168,20 +2213,20 @@
       {"\uFFFF", L"\uFFFF", "%EF%BF%BF"},
   };
 
-  for (size_t i = 0; i < std::size(path_cases); i++) {
+  for (const auto& path_case : path_cases) {
     // 8-bit string input
     std::string out_str;
     StdStringCanonOutput output(&out_str);
     url::Component out_component;
-    CanonicalizePathURLPath(path_cases[i].input.data(),
-                            Component(0, path_cases[i].input.size()), &output,
+    CanonicalizePathURLPath(path_case.input.data(),
+                            Component(0, path_case.input.size()), &output,
                             &out_component);
     output.Complete();
 
-    EXPECT_EQ(path_cases[i].expected, out_str);
+    EXPECT_EQ(path_case.expected, out_str);
 
     EXPECT_EQ(0, out_component.begin);
-    EXPECT_EQ(path_cases[i].expected.size(),
+    EXPECT_EQ(path_case.expected.size(),
               static_cast<size_t>(out_component.len));
 
     // 16-bit string input
@@ -2189,16 +2234,16 @@
     StdStringCanonOutput output16(&out_str16);
     url::Component out_component16;
     std::u16string input16(
-        test_utils::TruncateWStringToUTF16(path_cases[i].input16.data()));
+        test_utils::TruncateWStringToUTF16(path_case.input16.data()));
     CanonicalizePathURLPath(input16.c_str(),
-                            Component(0, path_cases[i].input16.size()),
-                            &output16, &out_component16);
+                            Component(0, path_case.input16.size()), &output16,
+                            &out_component16);
     output16.Complete();
 
-    EXPECT_EQ(path_cases[i].expected, out_str16);
+    EXPECT_EQ(path_case.expected, out_str16);
 
     EXPECT_EQ(0, out_component16.begin);
-    EXPECT_EQ(path_cases[i].expected.size(),
+    EXPECT_EQ(path_case.expected.size(),
               static_cast<size_t>(out_component16.len));
   }
 }
@@ -2393,148 +2438,209 @@
     const char* resolved;  // What we expect in the result when resolving.
   } rel_cases[] = {
       // Basic absolute input.
-    {"http://host/a", true, false, "http://another/", true, false, false, NULL},
-    {"http://host/a", true, false, "http:////another/", true, false, false, NULL},
+      {"http://host/a", true, false, "http://another/", true, false, false,
+       nullptr},
+      {"http://host/a", true, false, "http:////another/", true, false, false,
+       nullptr},
       // Empty relative URLs should only remove the ref part of the URL,
       // leaving the rest unchanged.
-    {"http://foo/bar", true, false, "", true, true, true, "http://foo/bar"},
-    {"http://foo/bar#ref", true, false, "", true, true, true, "http://foo/bar"},
-    {"http://foo/bar#", true, false, "", true, true, true, "http://foo/bar"},
+      {"http://foo/bar", true, false, "", true, true, true, "http://foo/bar"},
+      {"http://foo/bar#ref", true, false, "", true, true, true,
+       "http://foo/bar"},
+      {"http://foo/bar#", true, false, "", true, true, true, "http://foo/bar"},
       // Spaces at the ends of the relative path should be ignored.
-    {"http://foo/bar", true, false, "  another  ", true, true, true, "http://foo/another"},
-    {"http://foo/bar", true, false, "  .  ", true, true, true, "http://foo/"},
-    {"http://foo/bar", true, false, " \t ", true, true, true, "http://foo/bar"},
+      {"http://foo/bar", true, false, "  another  ", true, true, true,
+       "http://foo/another"},
+      {"http://foo/bar", true, false, "  .  ", true, true, true, "http://foo/"},
+      {"http://foo/bar", true, false, " \t ", true, true, true,
+       "http://foo/bar"},
       // Matching schemes without two slashes are treated as relative.
-    {"http://host/a", true, false, "http:path", true, true, true, "http://host/path"},
-    {"http://host/a/", true, false, "http:path", true, true, true, "http://host/a/path"},
-    {"http://host/a", true, false, "http:/path", true, true, true, "http://host/path"},
-    {"http://host/a", true, false, "HTTP:/path", true, true, true, "http://host/path"},
+      {"http://host/a", true, false, "http:path", true, true, true,
+       "http://host/path"},
+      {"http://host/a/", true, false, "http:path", true, true, true,
+       "http://host/a/path"},
+      {"http://host/a", true, false, "http:/path", true, true, true,
+       "http://host/path"},
+      {"http://host/a", true, false, "HTTP:/path", true, true, true,
+       "http://host/path"},
       // Nonmatching schemes are absolute.
-    {"http://host/a", true, false, "https:host2", true, false, false, NULL},
-    {"http://host/a", true, false, "htto:/host2", true, false, false, NULL},
+      {"http://host/a", true, false, "https:host2", true, false, false,
+       nullptr},
+      {"http://host/a", true, false, "htto:/host2", true, false, false,
+       nullptr},
       // Absolute path input
-    {"http://host/a", true, false, "/b/c/d", true, true, true, "http://host/b/c/d"},
-    {"http://host/a", true, false, "\\b\\c\\d", true, true, true, "http://host/b/c/d"},
-    {"http://host/a", true, false, "/b/../c", true, true, true, "http://host/c"},
-    {"http://host/a?b#c", true, false, "/b/../c", true, true, true, "http://host/c"},
-    {"http://host/a", true, false, "\\b/../c?x#y", true, true, true, "http://host/c?x#y"},
-    {"http://host/a?b#c", true, false, "/b/../c?x#y", true, true, true, "http://host/c?x#y"},
+      {"http://host/a", true, false, "/b/c/d", true, true, true,
+       "http://host/b/c/d"},
+      {"http://host/a", true, false, "\\b\\c\\d", true, true, true,
+       "http://host/b/c/d"},
+      {"http://host/a", true, false, "/b/../c", true, true, true,
+       "http://host/c"},
+      {"http://host/a?b#c", true, false, "/b/../c", true, true, true,
+       "http://host/c"},
+      {"http://host/a", true, false, "\\b/../c?x#y", true, true, true,
+       "http://host/c?x#y"},
+      {"http://host/a?b#c", true, false, "/b/../c?x#y", true, true, true,
+       "http://host/c?x#y"},
       // Relative path input
-    {"http://host/a", true, false, "b", true, true, true, "http://host/b"},
-    {"http://host/a", true, false, "bc/de", true, true, true, "http://host/bc/de"},
-    {"http://host/a/", true, false, "bc/de?query#ref", true, true, true, "http://host/a/bc/de?query#ref"},
-    {"http://host/a/", true, false, ".", true, true, true, "http://host/a/"},
-    {"http://host/a/", true, false, "..", true, true, true, "http://host/"},
-    {"http://host/a/", true, false, "./..", true, true, true, "http://host/"},
-    {"http://host/a/", true, false, "../.", true, true, true, "http://host/"},
-    {"http://host/a/", true, false, "././.", true, true, true, "http://host/a/"},
-    {"http://host/a?query#ref", true, false, "../../../foo", true, true, true, "http://host/foo"},
+      {"http://host/a", true, false, "b", true, true, true, "http://host/b"},
+      {"http://host/a", true, false, "bc/de", true, true, true,
+       "http://host/bc/de"},
+      {"http://host/a/", true, false, "bc/de?query#ref", true, true, true,
+       "http://host/a/bc/de?query#ref"},
+      {"http://host/a/", true, false, ".", true, true, true, "http://host/a/"},
+      {"http://host/a/", true, false, "..", true, true, true, "http://host/"},
+      {"http://host/a/", true, false, "./..", true, true, true, "http://host/"},
+      {"http://host/a/", true, false, "../.", true, true, true, "http://host/"},
+      {"http://host/a/", true, false, "././.", true, true, true,
+       "http://host/a/"},
+      {"http://host/a?query#ref", true, false, "../../../foo", true, true, true,
+       "http://host/foo"},
       // Query input
-    {"http://host/a", true, false, "?foo=bar", true, true, true, "http://host/a?foo=bar"},
-    {"http://host/a?x=y#z", true, false, "?", true, true, true, "http://host/a?"},
-    {"http://host/a?x=y#z", true, false, "?foo=bar#com", true, true, true, "http://host/a?foo=bar#com"},
+      {"http://host/a", true, false, "?foo=bar", true, true, true,
+       "http://host/a?foo=bar"},
+      {"http://host/a?x=y#z", true, false, "?", true, true, true,
+       "http://host/a?"},
+      {"http://host/a?x=y#z", true, false, "?foo=bar#com", true, true, true,
+       "http://host/a?foo=bar#com"},
       // Ref input
-    {"http://host/a", true, false, "#ref", true, true, true, "http://host/a#ref"},
-    {"http://host/a#b", true, false, "#", true, true, true, "http://host/a#"},
-    {"http://host/a?foo=bar#hello", true, false, "#bye", true, true, true, "http://host/a?foo=bar#bye"},
+      {"http://host/a", true, false, "#ref", true, true, true,
+       "http://host/a#ref"},
+      {"http://host/a#b", true, false, "#", true, true, true, "http://host/a#"},
+      {"http://host/a?foo=bar#hello", true, false, "#bye", true, true, true,
+       "http://host/a?foo=bar#bye"},
       // Non-hierarchical base: no relative handling. Relative input should
       // error, and if a scheme is present, it should be treated as absolute.
-    {"data:foobar", false, false, "baz.html", false, false, false, NULL},
-    {"data:foobar", false, false, "data:baz", true, false, false, NULL},
-    {"data:foobar", false, false, "data:/base", true, false, false, NULL},
+      {"data:foobar", false, false, "baz.html", false, false, false, nullptr},
+      {"data:foobar", false, false, "data:baz", true, false, false, nullptr},
+      {"data:foobar", false, false, "data:/base", true, false, false, nullptr},
       // Non-hierarchical base: absolute input should succeed.
-    {"data:foobar", false, false, "http://host/", true, false, false, NULL},
-    {"data:foobar", false, false, "http:host", true, false, false, NULL},
+      {"data:foobar", false, false, "http://host/", true, false, false,
+       nullptr},
+      {"data:foobar", false, false, "http:host", true, false, false, nullptr},
       // Non-hierarchical base: empty URL should give error.
-    {"data:foobar", false, false, "", false, false, false, NULL},
+      {"data:foobar", false, false, "", false, false, false, nullptr},
       // Invalid schemes should be treated as relative.
-    {"http://foo/bar", true, false, "./asd:fgh", true, true, true, "http://foo/asd:fgh"},
-    {"http://foo/bar", true, false, ":foo", true, true, true, "http://foo/:foo"},
-    {"http://foo/bar", true, false, " hello world", true, true, true, "http://foo/hello%20world"},
-    {"data:asdf", false, false, ":foo", false, false, false, NULL},
-    {"data:asdf", false, false, "bad(':foo')", false, false, false, NULL},
+      {"http://foo/bar", true, false, "./asd:fgh", true, true, true,
+       "http://foo/asd:fgh"},
+      {"http://foo/bar", true, false, ":foo", true, true, true,
+       "http://foo/:foo"},
+      {"http://foo/bar", true, false, " hello world", true, true, true,
+       "http://foo/hello%20world"},
+      {"data:asdf", false, false, ":foo", false, false, false, nullptr},
+      {"data:asdf", false, false, "bad(':foo')", false, false, false, nullptr},
       // We should treat semicolons like any other character in URL resolving
-    {"http://host/a", true, false, ";foo", true, true, true, "http://host/;foo"},
-    {"http://host/a;", true, false, ";foo", true, true, true, "http://host/;foo"},
-    {"http://host/a", true, false, ";/../bar", true, true, true, "http://host/bar"},
+      {"http://host/a", true, false, ";foo", true, true, true,
+       "http://host/;foo"},
+      {"http://host/a;", true, false, ";foo", true, true, true,
+       "http://host/;foo"},
+      {"http://host/a", true, false, ";/../bar", true, true, true,
+       "http://host/bar"},
       // Relative URLs can also be written as "//foo/bar" which is relative to
       // the scheme. In this case, it would take the old scheme, so for http
       // the example would resolve to "http://foo/bar".
-    {"http://host/a", true, false, "//another", true, true, true, "http://another/"},
-    {"http://host/a", true, false, "//another/path?query#ref", true, true, true, "http://another/path?query#ref"},
-    {"http://host/a", true, false, "///another/path", true, true, true, "http://another/path"},
-    {"http://host/a", true, false, "//Another\\path", true, true, true, "http://another/path"},
-    {"http://host/a", true, false, "//", true, true, false, "http:"},
+      {"http://host/a", true, false, "//another", true, true, true,
+       "http://another/"},
+      {"http://host/a", true, false, "//another/path?query#ref", true, true,
+       true, "http://another/path?query#ref"},
+      {"http://host/a", true, false, "///another/path", true, true, true,
+       "http://another/path"},
+      {"http://host/a", true, false, "//Another\\path", true, true, true,
+       "http://another/path"},
+      {"http://host/a", true, false, "//", true, true, false, "http:"},
       // IE will also allow one or the other to be a backslash to get the same
       // behavior.
-    {"http://host/a", true, false, "\\/another/path", true, true, true, "http://another/path"},
-    {"http://host/a", true, false, "/\\Another\\path", true, true, true, "http://another/path"},
+      {"http://host/a", true, false, "\\/another/path", true, true, true,
+       "http://another/path"},
+      {"http://host/a", true, false, "/\\Another\\path", true, true, true,
+       "http://another/path"},
 #ifdef WIN32
       // Resolving against Windows file base URLs.
-    {"file:///C:/foo", true, true, "http://host/", true, false, false, NULL},
-    {"file:///C:/foo", true, true, "bar", true, true, true, "file:///C:/bar"},
-    {"file:///C:/foo", true, true, "../../../bar.html", true, true, true, "file:///C:/bar.html"},
-    {"file:///C:/foo", true, true, "/../bar.html", true, true, true, "file:///C:/bar.html"},
+      {"file:///C:/foo", true, true, "http://host/", true, false, false,
+       nullptr},
+      {"file:///C:/foo", true, true, "bar", true, true, true, "file:///C:/bar"},
+      {"file:///C:/foo", true, true, "../../../bar.html", true, true, true,
+       "file:///C:/bar.html"},
+      {"file:///C:/foo", true, true, "/../bar.html", true, true, true,
+       "file:///C:/bar.html"},
       // But two backslashes on Windows should be UNC so should be treated
       // as absolute.
-    {"http://host/a", true, false, "\\\\another\\path", true, false, false, NULL},
+      {"http://host/a", true, false, "\\\\another\\path", true, false, false,
+       nullptr},
       // IE doesn't support drive specs starting with two slashes. It fails
       // immediately and doesn't even try to load. We fix it up to either
       // an absolute path or UNC depending on what it looks like.
-    {"file:///C:/something", true, true, "//c:/foo", true, true, true, "file:///C:/foo"},
-    {"file:///C:/something", true, true, "//localhost/c:/foo", true, true, true, "file:///C:/foo"},
+      {"file:///C:/something", true, true, "//c:/foo", true, true, true,
+       "file:///C:/foo"},
+      {"file:///C:/something", true, true, "//localhost/c:/foo", true, true,
+       true, "file:///C:/foo"},
       // Windows drive specs should be allowed and treated as absolute.
-    {"file:///C:/foo", true, true, "c:", true, false, false, NULL},
-    {"file:///C:/foo", true, true, "c:/foo", true, false, false, NULL},
-    {"http://host/a", true, false, "c:\\foo", true, false, false, NULL},
+      {"file:///C:/foo", true, true, "c:", true, false, false, nullptr},
+      {"file:///C:/foo", true, true, "c:/foo", true, false, false, nullptr},
+      {"http://host/a", true, false, "c:\\foo", true, false, false, nullptr},
       // Relative paths with drive letters should be allowed when the base is
       // also a file.
-    {"file:///C:/foo", true, true, "/z:/bar", true, true, true, "file:///Z:/bar"},
+      {"file:///C:/foo", true, true, "/z:/bar", true, true, true,
+       "file:///Z:/bar"},
       // Treat absolute paths as being off of the drive.
-    {"file:///C:/foo", true, true, "/bar", true, true, true, "file:///C:/bar"},
-    {"file://localhost/C:/foo", true, true, "/bar", true, true, true, "file://localhost/C:/bar"},
-    {"file:///C:/foo/com/", true, true, "/bar", true, true, true, "file:///C:/bar"},
+      {"file:///C:/foo", true, true, "/bar", true, true, true,
+       "file:///C:/bar"},
+      {"file://localhost/C:/foo", true, true, "/bar", true, true, true,
+       "file://localhost/C:/bar"},
+      {"file:///C:/foo/com/", true, true, "/bar", true, true, true,
+       "file:///C:/bar"},
       // On Windows, two slashes without a drive letter when the base is a file
       // means that the path is UNC.
-    {"file:///C:/something", true, true, "//somehost/path", true, true, true, "file://somehost/path"},
-    {"file:///C:/something", true, true, "/\\//somehost/path", true, true, true, "file://somehost/path"},
+      {"file:///C:/something", true, true, "//somehost/path", true, true, true,
+       "file://somehost/path"},
+      {"file:///C:/something", true, true, "/\\//somehost/path", true, true,
+       true, "file://somehost/path"},
 #else
       // On Unix we fall back to relative behavior since there's nothing else
       // reasonable to do.
-    {"http://host/a", true, false, "\\\\Another\\path", true, true, true, "http://another/path"},
+      {"http://host/a", true, false, "\\\\Another\\path", true, true, true,
+       "http://another/path"},
 #endif
       // Even on Windows, we don't allow relative drive specs when the base
       // is not file.
-    {"http://host/a", true, false, "/c:\\foo", true, true, true, "http://host/c:/foo"},
-    {"http://host/a", true, false, "//c:\\foo", true, true, true, "http://c/foo"},
+      {"http://host/a", true, false, "/c:\\foo", true, true, true,
+       "http://host/c:/foo"},
+      {"http://host/a", true, false, "//c:\\foo", true, true, true,
+       "http://c/foo"},
       // Cross-platform relative file: resolution behavior.
-    {"file://host/a", true, true, "/", true, true, true, "file://host/"},
-    {"file://host/a", true, true, "//", true, true, true, "file:///"},
-    {"file://host/a", true, true, "/b", true, true, true, "file://host/b"},
-    {"file://host/a", true, true, "//b", true, true, true, "file://b/"},
+      {"file://host/a", true, true, "/", true, true, true, "file://host/"},
+      {"file://host/a", true, true, "//", true, true, true, "file:///"},
+      {"file://host/a", true, true, "/b", true, true, true, "file://host/b"},
+      {"file://host/a", true, true, "//b", true, true, true, "file://b/"},
       // Ensure that ports aren't allowed for hosts relative to a file url.
       // Although the result string shows a host:port portion, the call to
       // resolve the relative URL returns false, indicating parse failure,
       // which is what is required.
-    {"file:///foo.txt", true, true, "//host:80/bar.txt", true, true, false, "file://host:80/bar.txt"},
+      {"file:///foo.txt", true, true, "//host:80/bar.txt", true, true, false,
+       "file://host:80/bar.txt"},
       // Filesystem URL tests; filesystem URLs are only valid and relative if
       // they have no scheme, e.g. "./index.html". There's no valid equivalent
       // to http:index.html.
-    {"filesystem:http://host/t/path", true, false, "filesystem:http://host/t/path2", true, false, false, NULL},
-    {"filesystem:http://host/t/path", true, false, "filesystem:https://host/t/path2", true, false, false, NULL},
-    {"filesystem:http://host/t/path", true, false, "http://host/t/path2", true, false, false, NULL},
-    {"http://host/t/path", true, false, "filesystem:http://host/t/path2", true, false, false, NULL},
-    {"filesystem:http://host/t/path", true, false, "./path2", true, true, true, "filesystem:http://host/t/path2"},
-    {"filesystem:http://host/t/path/", true, false, "path2", true, true, true, "filesystem:http://host/t/path/path2"},
-    {"filesystem:http://host/t/path", true, false, "filesystem:http:path2", true, false, false, NULL},
+      {"filesystem:http://host/t/path", true, false,
+       "filesystem:http://host/t/path2", true, false, false, nullptr},
+      {"filesystem:http://host/t/path", true, false,
+       "filesystem:https://host/t/path2", true, false, false, nullptr},
+      {"filesystem:http://host/t/path", true, false, "http://host/t/path2",
+       true, false, false, nullptr},
+      {"http://host/t/path", true, false, "filesystem:http://host/t/path2",
+       true, false, false, nullptr},
+      {"filesystem:http://host/t/path", true, false, "./path2", true, true,
+       true, "filesystem:http://host/t/path2"},
+      {"filesystem:http://host/t/path/", true, false, "path2", true, true, true,
+       "filesystem:http://host/t/path/path2"},
+      {"filesystem:http://host/t/path", true, false, "filesystem:http:path2",
+       true, false, false, nullptr},
       // Absolute URLs are still not relative to a non-standard base URL.
-    {"about:blank", false, false, "http://X/A", true, false, true, ""},
-    {"about:blank", false, false, "content://content.Provider/", true, false, true, ""},
+      {"about:blank", false, false, "http://X/A", true, false, true, ""},
+      {"about:blank", false, false, "content://content.Provider/", true, false,
+       true, ""},
   };
 
-  for (size_t i = 0; i < std::size(rel_cases); i++) {
-    const RelativeCase& cur_case = rel_cases[i];
-
+  for (const auto& cur_case : rel_cases) {
     Parsed parsed;
     int base_len = static_cast<int>(strlen(cur_case.base));
     if (cur_case.is_base_file)
@@ -2564,7 +2670,7 @@
 
       bool succeed_resolve = ResolveRelativeURL(
           cur_case.base, parsed, cur_case.is_base_file, cur_case.test,
-          relative_component, NULL, &output, &resolved_parsed);
+          relative_component, nullptr, &output, &resolved_parsed);
       output.Complete();
 
       EXPECT_EQ(cur_case.succeed_resolve, succeed_resolve);
@@ -2614,7 +2720,7 @@
   Parsed repl_parsed;
   std::string repl_str;
   StdStringCanonOutput repl_output(&repl_str);
-  ReplaceFileURL(src, parsed, repl, NULL, &repl_output, &repl_parsed);
+  ReplaceFileURL(src, parsed, repl, nullptr, &repl_output, &repl_parsed);
   repl_output.Complete();
 
   // Generate the expected string and check.
@@ -2642,7 +2748,7 @@
       {"WSS", PORT_UNSPECIFIED},
   };
 
-  for (auto& test_case : cases) {
+  for (const auto& test_case : cases) {
     SCOPED_TRACE(test_case.scheme);
     EXPECT_EQ(test_case.expected_port,
               DefaultPortForScheme(test_case.scheme, strlen(test_case.scheme)));
@@ -2651,7 +2757,7 @@
 
 TEST(URLCanonTest, FindWindowsDriveLetter) {
   struct TestCase {
-    gurl_base::StringPiece spec;
+    std::string_view spec;
     int begin;
     int end;  // -1 for end of spec
     int expected_drive_letter_pos;
@@ -2695,33 +2801,33 @@
 
   // Basic ASCII test.
   std::u16string str = u"hello";
-  EXPECT_TRUE(IDNToASCII(str.data(), str.length(), &output));
+  EXPECT_TRUE(IDNToASCII(str, &output));
   EXPECT_EQ(u"hello", std::u16string(output.data()));
   output.set_length(0);
 
   // Mixed ASCII/non-ASCII.
   str = u"hellö";
-  EXPECT_TRUE(IDNToASCII(str.data(), str.length(), &output));
+  EXPECT_TRUE(IDNToASCII(str, &output));
   EXPECT_EQ(u"xn--hell-8qa", std::u16string(output.data()));
   output.set_length(0);
 
   // All non-ASCII.
   str = u"你好";
-  EXPECT_TRUE(IDNToASCII(str.data(), str.length(), &output));
+  EXPECT_TRUE(IDNToASCII(str, &output));
   EXPECT_EQ(u"xn--6qq79v", std::u16string(output.data()));
   output.set_length(0);
 
   // Characters that need mapping (the resulting Punycode is the encoding for
   // "1⁄4").
   str = u"¼";
-  EXPECT_TRUE(IDNToASCII(str.data(), str.length(), &output));
+  EXPECT_TRUE(IDNToASCII(str, &output));
   EXPECT_EQ(u"xn--14-c6t", std::u16string(output.data()));
   output.set_length(0);
 
   // String to encode already starts with "xn--", and all ASCII. Should not
   // modify the string.
   str = u"xn--hell-8qa";
-  EXPECT_TRUE(IDNToASCII(str.data(), str.length(), &output));
+  EXPECT_TRUE(IDNToASCII(str, &output));
   EXPECT_EQ(u"xn--hell-8qa", std::u16string(output.data()));
   output.set_length(0);
 
@@ -2729,7 +2835,7 @@
   // Should fail, due to a special case: if the label starts with "xn--", it
   // should be parsed as Punycode, which must be all ASCII.
   str = u"xn--hellö";
-  EXPECT_FALSE(IDNToASCII(str.data(), str.length(), &output));
+  EXPECT_FALSE(IDNToASCII(str, &output));
   output.set_length(0);
 
   // String to encode already starts with "xn--", and mixed ASCII/non-ASCII.
@@ -2737,7 +2843,7 @@
   // which would be a valid ASCII character, U+0044, if the high byte were
   // ignored.
   str = u"xn--1⁄4";
-  EXPECT_FALSE(IDNToASCII(str.data(), str.length(), &output));
+  EXPECT_FALSE(IDNToASCII(str, &output));
   output.set_length(0);
 }
 
@@ -2765,7 +2871,7 @@
 
 TEST_P(URLCanonAsciiPercentEncodePathTest, UnescapePathCharHistogram) {
   struct TestCase {
-    gurl_base::StringPiece path;
+    std::string_view path;
     gurl_base::HistogramBase::Count cnt;
   } cases[] = {
       {"/a", 0},
diff --git a/url/url_features.cc b/url/url_features.cc
index e046f60..9c9827b 100644
--- a/url/url_features.cc
+++ b/url/url_features.cc
@@ -30,6 +30,11 @@
              "DontDecodeAsciiPercentEncodedURLPath",
              gurl_base::FEATURE_ENABLED_BY_DEFAULT);
 
+// Kill switch for https://crbug.com/1416013.
+BASE_FEATURE(kStandardCompliantHostCharacters,
+             "StandardCompliantHostCharacters",
+             gurl_base::FEATURE_ENABLED_BY_DEFAULT);
+
 bool IsUsingIDNA2008NonTransitional() {
   // If the FeatureList isn't available yet, fall back to the feature's default
   // state. This may happen during early startup, see crbug.com/1441956.
@@ -41,6 +46,28 @@
   return gurl_base::FeatureList::IsEnabled(kUseIDNA2008NonTransitional);
 }
 
+bool IsUsingDontDecodeAsciiPercentEncodedURLPath() {
+  // If the FeatureList isn't available yet, fall back to the feature's default
+  // state. This may happen during early startup, see https://crbug.com/1478960.
+  if (!gurl_base::FeatureList::GetInstance()) {
+    return kDontDecodeAsciiPercentEncodedURLPath.default_state ==
+           gurl_base::FEATURE_ENABLED_BY_DEFAULT;
+  }
+
+  return gurl_base::FeatureList::IsEnabled(kDontDecodeAsciiPercentEncodedURLPath);
+}
+
+bool IsUsingStandardCompliantHostCharacters() {
+  // If the FeatureList isn't available yet, fall back to the feature's default
+  // state. This may happen during early startup, see crbug.com/1441956.
+  if (!gurl_base::FeatureList::GetInstance()) {
+    return kStandardCompliantHostCharacters.default_state ==
+           gurl_base::FEATURE_ENABLED_BY_DEFAULT;
+  }
+
+  return gurl_base::FeatureList::IsEnabled(kStandardCompliantHostCharacters);
+}
+
 bool IsRecordingIDNA2008Metrics() {
   return gurl_base::FeatureList::IsEnabled(kRecordIDNA2008Metrics);
 }
diff --git a/url/url_features.h b/url/url_features.h
index 3dfb383..55b3234 100644
--- a/url/url_features.h
+++ b/url/url_features.h
@@ -18,6 +18,14 @@
 // Returns true if Chrome is recording IDNA 2008 related metrics.
 COMPONENT_EXPORT(URL) bool IsRecordingIDNA2008Metrics();
 
+// Returns true if kDontDecodeAsciiPercentEncodedURLPath feature is enabled.
+// See url::kDontDecodeAsciiPercentEncodedURLPath for details.
+COMPONENT_EXPORT(URL) bool IsUsingDontDecodeAsciiPercentEncodedURLPath();
+
+// Returns true if kDontDecodeAsciiPercentEncodedURLPath feature is enabled.
+// See url::kStandardCompliantHostCharacters for details.
+COMPONENT_EXPORT(URL) bool IsUsingStandardCompliantHostCharacters();
+
 // Returns true if Chrome is enforcing the 4 part check for IPv4 embedded IPv6
 // addresses.
 COMPONENT_EXPORT(URL)
@@ -33,6 +41,12 @@
 COMPONENT_EXPORT(URL)
 BASE_DECLARE_FEATURE(kDontDecodeAsciiPercentEncodedURLPath);
 
+// When enabled, Chrome uses URL Standard compliant mode to
+// handle punctuation characters in URL host part.
+// https://crbug.com/1416013 for details.
+COMPONENT_EXPORT(URL)
+BASE_DECLARE_FEATURE(kStandardCompliantHostCharacters);
+
 }  // namespace url
 
 #endif  // URL_URL_FEATURES_H_
diff --git a/url/url_idna_ascii_only.cc b/url/url_idna_ascii_only.cc
index 2a4f0d3..6a864bb 100644
--- a/url/url_idna_ascii_only.cc
+++ b/url/url_idna_ascii_only.cc
@@ -6,8 +6,8 @@
 
 #include <ostream>
 #include <string>
+#include <string_view>
 
-#include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "url/url_canon_internal.h"
@@ -16,9 +16,9 @@
 
 // Only allow ASCII to avoid ICU dependency. Use NSString+IDN
 // to convert non-ASCII URL prior to passing to API.
-bool IDNToASCII(const char16_t* src, int src_len, CanonOutputW* output) {
-  if (gurl_base::IsStringASCII(gurl_base::StringPiece16(src, src_len))) {
-    output->Append(src, src_len);
+bool IDNToASCII(std::u16string_view src, CanonOutputW* output) {
+  if (gurl_base::IsStringASCII(src)) {
+    output->Append(src);
     return true;
   }
   GURL_DCHECK(false) << "IDN URL support is not available.";
diff --git a/url/url_idna_icu.cc b/url/url_idna_icu.cc
index 4a3a602..7c1931c 100644
--- a/url/url_idna_icu.cc
+++ b/url/url_idna_icu.cc
@@ -11,6 +11,7 @@
 #include <ostream>
 
 #include "polyfills/base/check_op.h"
+#include "base/numerics/safe_conversions.h"
 #include <unicode/uidna.h>
 #include <unicode/utypes.h>
 #include "url/url_canon_icu.h"
@@ -90,7 +91,7 @@
 // conversions in our code. In addition, consider using icu::IDNA's UTF-8/ASCII
 // version with StringByteSink. That way, we can avoid C wrappers and additional
 // string conversion.
-bool IDNToASCII(const char16_t* src, int src_len, CanonOutputW* output) {
+bool IDNToASCII(std::u16string_view src, CanonOutputW* output) {
   GURL_DCHECK(output->length() == 0);  // Output buffer is assumed empty.
 
   UIDNA* uidna = GetUIDNA();
@@ -98,8 +99,9 @@
   while (true) {
     UErrorCode err = U_ZERO_ERROR;
     UIDNAInfo info = UIDNA_INFO_INITIALIZER;
-    int output_length = uidna_nameToASCII(uidna, src, src_len, output->data(),
-                                          output->capacity(), &info, &err);
+    int output_length = uidna_nameToASCII(
+        uidna, src.data(), gurl_base::checked_cast<int32_t>(src.size()),
+        output->data(), output->capacity(), &info, &err);
 
     // Ignore various errors for web compatibility. The options are specified
     // by the WHATWG URL Standard. See
diff --git a/url/url_parse_perftest.cc b/url/url_parse_perftest.cc
index b9b85d9..63bccdb 100644
--- a/url/url_parse_perftest.cc
+++ b/url/url_parse_perftest.cc
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/strings/string_piece.h"
+#include <string_view>
+
 #include "base/test/perf_time_logger.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
@@ -13,7 +14,7 @@
 namespace {
 
 TEST(URLParse, FullURL) {
-  constexpr gurl_base::StringPiece kUrl =
+  constexpr std::string_view kUrl =
       "http://me:pass@host/foo/bar.html;param?query=yes#ref";
 
   url::Parsed parsed;
@@ -24,16 +25,16 @@
   timer.Done();
 }
 
-constexpr gurl_base::StringPiece kTypicalUrl1 =
+constexpr std::string_view kTypicalUrl1 =
     "http://www.google.com/"
     "search?q=url+parsing&ie=utf-8&oe=utf-8&aq=t&rls=org.mozilla:en-US:"
     "official&client=firefox-a";
 
-constexpr gurl_base::StringPiece kTypicalUrl2 =
+constexpr std::string_view kTypicalUrl2 =
     "http://www.amazon.com/Stephen-King-Thrillers-Horror-People/dp/0766012336/"
     "ref=sr_1_2/133-4144931-4505264?ie=UTF8&s=books&qid=2144880915&sr=8-2";
 
-constexpr gurl_base::StringPiece kTypicalUrl3 =
+constexpr std::string_view kTypicalUrl3 =
     "http://store.apple.com/1-800-MY-APPLE/WebObjects/AppleStore.woa/wa/"
     "RSLID?nnmm=browse&mco=578E9744&node=home/desktop/mac_pro";
 
diff --git a/url/url_util.cc b/url/url_util.cc
index 1fb663e..267e4b9 100644
--- a/url/url_util.cc
+++ b/url/url_util.cc
@@ -147,18 +147,6 @@
   DO_NOT_REMOVE_WHITESPACE,
 };
 
-// This template converts a given character type to the corresponding
-// StringPiece type.
-template<typename CHAR> struct CharToStringPiece {
-};
-template<> struct CharToStringPiece<char> {
-  typedef gurl_base::StringPiece Piece;
-};
-template <>
-struct CharToStringPiece<char16_t> {
-  typedef gurl_base::StringPiece16 Piece;
-};
-
 // Given a string and a range inside the string, compares it to the given
 // lower-case |compare_to| buffer.
 template<typename CHAR>
@@ -168,8 +156,7 @@
   if (component.is_empty())
     return compare_to[0] == 0;  // When component is empty, match empty scheme.
   return gurl_base::EqualsCaseInsensitiveASCII(
-      typename CharToStringPiece<CHAR>::Piece(&spec[component.begin],
-                                              component.len),
+      std::basic_string_view(&spec[component.begin], component.len),
       compare_to);
 }
 
@@ -185,8 +172,7 @@
 
   for (const SchemeWithType& scheme_with_type : schemes) {
     if (gurl_base::EqualsCaseInsensitiveASCII(
-            typename CharToStringPiece<CHAR>::Piece(&spec[scheme.begin],
-                                                    scheme.len),
+            std::basic_string_view(&spec[scheme.begin], scheme.len),
             scheme_with_type.scheme)) {
       *type = scheme_with_type.type;
       return true;
@@ -735,8 +721,8 @@
   return DoFindAndCompareScheme(str, str_len, compare, found_scheme);
 }
 
-bool DomainIs(gurl_base::StringPiece canonical_host,
-              gurl_base::StringPiece canonical_domain) {
+bool DomainIs(std::string_view canonical_host,
+              std::string_view canonical_domain) {
   if (canonical_host.empty() || canonical_domain.empty())
     return false;
 
@@ -754,7 +740,7 @@
   const char* host_first_pos =
       canonical_host.data() + host_len - canonical_domain.length();
 
-  if (gurl_base::StringPiece(host_first_pos, canonical_domain.length()) !=
+  if (std::string_view(host_first_pos, canonical_domain.length()) !=
       canonical_domain) {
     return false;
   }
@@ -771,7 +757,7 @@
   return true;
 }
 
-bool HostIsIPAddress(gurl_base::StringPiece host) {
+bool HostIsIPAddress(std::string_view host) {
   STACK_UNINITIALIZED url::RawCanonOutputT<char, 128> ignored_output;
   url::CanonHostInfo host_info;
   url::CanonicalizeIPAddress(host.data(), Component(0, host.length()),
@@ -847,19 +833,18 @@
                              charset_converter, output, out_parsed);
 }
 
-void DecodeURLEscapeSequences(const char* input,
-                              int length,
+void DecodeURLEscapeSequences(std::string_view input,
                               DecodeURLMode mode,
                               CanonOutputW* output) {
-  if (length <= 0)
+  if (input.empty()) {
     return;
+  }
 
   STACK_UNINITIALIZED RawCanonOutputT<char> unescaped_chars;
-  size_t length_size_t = static_cast<size_t>(length);
-  for (size_t i = 0; i < length_size_t; i++) {
+  for (size_t i = 0; i < input.length(); i++) {
     if (input[i] == '%') {
       unsigned char ch;
-      if (DecodeEscaped(input, &i, length_size_t, &ch)) {
+      if (DecodeEscaped(input.data(), &i, input.length(), &ch)) {
         unescaped_chars.push_back(ch);
       } else {
         // Invalid escape sequence, copy the percent literal.
@@ -908,16 +893,20 @@
   }
 }
 
-void EncodeURIComponent(const char* input, int length, CanonOutput* output) {
-  for (int i = 0; i < length; ++i) {
-    unsigned char c = static_cast<unsigned char>(input[i]);
-    if (IsComponentChar(c))
+void EncodeURIComponent(std::string_view input, CanonOutput* output) {
+  for (unsigned char c : input) {
+    if (IsComponentChar(c)) {
       output->push_back(c);
-    else
+    } else {
       AppendEscapedChar(c, output);
+    }
   }
 }
 
+bool IsURIComponentChar(char c) {
+  return IsComponentChar(c);
+}
+
 bool CompareSchemeComponent(const char* spec,
                             const Component& component,
                             const char* compare_to) {
@@ -930,4 +919,16 @@
   return DoCompareSchemeComponent(spec, component, compare_to);
 }
 
+bool HasInvalidURLEscapeSequences(std::string_view input) {
+  for (size_t i = 0; i < input.size(); i++) {
+    if (input[i] == '%') {
+      unsigned char ch;
+      if (!DecodeEscaped(input.data(), &i, input.size(), &ch)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 }  // namespace url
diff --git a/url/url_util.h b/url/url_util.h
index b489362..4254426 100644
--- a/url/url_util.h
+++ b/url/url_util.h
@@ -7,10 +7,10 @@
 
 #include <memory>
 #include <string>
+#include <string_view>
 #include <vector>
 
 #include "polyfills/base/component_export.h"
-#include "base/strings/string_piece.h"
 #include "url/third_party/mozilla/url_parse.h"
 #include "url/url_canon.h"
 #include "url/url_constants.h"
@@ -203,12 +203,12 @@
 // input domain should match host canonicalization rules. i.e. it should be
 // lowercase except for escape chars.
 COMPONENT_EXPORT(URL)
-bool DomainIs(gurl_base::StringPiece canonical_host,
-              gurl_base::StringPiece canonical_domain);
+bool DomainIs(std::string_view canonical_host,
+              std::string_view canonical_domain);
 
 // Returns true if the hostname is an IP address. Note: this function isn't very
 // cheap, as it must re-parse the host to verify.
-COMPONENT_EXPORT(URL) bool HostIsIPAddress(gurl_base::StringPiece host);
+COMPONENT_EXPORT(URL) bool HostIsIPAddress(std::string_view host);
 
 // URL library wrappers --------------------------------------------------------
 
@@ -299,15 +299,29 @@
 
 // Unescapes the given string using URL escaping rules.
 COMPONENT_EXPORT(URL)
-void DecodeURLEscapeSequences(const char* input,
-                              int length,
+void DecodeURLEscapeSequences(std::string_view input,
                               DecodeURLMode mode,
                               CanonOutputW* output);
 
 // Escapes the given string as defined by the JS method encodeURIComponent. See
 // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/encodeURIComponent
 COMPONENT_EXPORT(URL)
-void EncodeURIComponent(const char* input, int length, CanonOutput* output);
+void EncodeURIComponent(std::string_view input, CanonOutput* output);
+
+// Returns true if `c` is a character that does not require escaping in
+// encodeURIComponent.
+// TODO(crbug.com/1481056): Remove this when event-level reportEvent is removed
+// (if it is still this function's only consumer).
+COMPONENT_EXPORT(URL)
+bool IsURIComponentChar(char c);
+
+// Checks an arbitrary string for invalid escape sequences.
+//
+// A valid percent-encoding is '%' followed by exactly two hex-digits. This
+// function returns true if an occurrence of '%' is found and followed by
+// anything other than two hex-digits.
+COMPONENT_EXPORT(URL)
+bool HasInvalidURLEscapeSequences(std::string_view input);
 
 }  // namespace url
 
diff --git a/url/url_util_unittest.cc b/url/url_util_unittest.cc
index b052c3d..1435d3b 100644
--- a/url/url_util_unittest.cc
+++ b/url/url_util_unittest.cc
@@ -6,7 +6,8 @@
 
 #include <stddef.h>
 
-#include "base/strings/string_piece.h"
+#include <string_view>
+
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest-message.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -259,14 +260,12 @@
   for (size_t i = 0; i < std::size(decode_cases); i++) {
     const char* input = decode_cases[i].input;
     RawCanonOutputT<char16_t> output;
-    DecodeURLEscapeSequences(input, strlen(input),
-                             DecodeURLMode::kUTF8OrIsomorphic, &output);
+    DecodeURLEscapeSequences(input, DecodeURLMode::kUTF8OrIsomorphic, &output);
     EXPECT_EQ(decode_cases[i].output, gurl_base::UTF16ToUTF8(std::u16string(
                                           output.data(), output.length())));
 
     RawCanonOutputT<char16_t> output_utf8;
-    DecodeURLEscapeSequences(input, strlen(input), DecodeURLMode::kUTF8,
-                             &output_utf8);
+    DecodeURLEscapeSequences(input, DecodeURLMode::kUTF8, &output_utf8);
     EXPECT_EQ(decode_cases[i].output,
               gurl_base::UTF16ToUTF8(
                   std::u16string(output_utf8.data(), output_utf8.length())));
@@ -275,8 +274,7 @@
   // Our decode should decode %00
   const char zero_input[] = "%00";
   RawCanonOutputT<char16_t> zero_output;
-  DecodeURLEscapeSequences(zero_input, strlen(zero_input), DecodeURLMode::kUTF8,
-                           &zero_output);
+  DecodeURLEscapeSequences(zero_input, DecodeURLMode::kUTF8, &zero_output);
   EXPECT_NE("%00", gurl_base::UTF16ToUTF8(std::u16string(zero_output.data(),
                                                     zero_output.length())));
 
@@ -301,14 +299,13 @@
   for (const auto& test : utf8_decode_cases) {
     const char* input = test.input;
     RawCanonOutputT<char16_t> output_iso;
-    DecodeURLEscapeSequences(input, strlen(input),
-                             DecodeURLMode::kUTF8OrIsomorphic, &output_iso);
+    DecodeURLEscapeSequences(input, DecodeURLMode::kUTF8OrIsomorphic,
+                             &output_iso);
     EXPECT_EQ(std::u16string(test.expected_iso.data()),
               std::u16string(output_iso.data(), output_iso.length()));
 
     RawCanonOutputT<char16_t> output_utf8;
-    DecodeURLEscapeSequences(input, strlen(input), DecodeURLMode::kUTF8,
-                             &output_utf8);
+    DecodeURLEscapeSequences(input, DecodeURLMode::kUTF8, &output_utf8);
     EXPECT_EQ(std::u16string(test.expected_utf8.data()),
               std::u16string(output_utf8.data(), output_utf8.length()));
   }
@@ -341,7 +338,7 @@
   for (size_t i = 0; i < std::size(encode_cases); i++) {
     const char* input = encode_cases[i].input;
     RawCanonOutputT<char> buffer;
-    EncodeURIComponent(input, strlen(input), &buffer);
+    EncodeURIComponent(input, &buffer);
     std::string output(buffer.data(), buffer.length());
     EXPECT_EQ(encode_cases[i].output, output);
   }
@@ -588,7 +585,7 @@
 }
 
 namespace {
-absl::optional<std::string> CanonicalizeSpec(gurl_base::StringPiece spec,
+absl::optional<std::string> CanonicalizeSpec(std::string_view spec,
                                              bool trim_path_end) {
   std::string canonicalized;
   StdStringCanonOutput output(&canonicalized);
@@ -635,4 +632,87 @@
   }
 }
 
+TEST_F(URLUtilTest, TestHasInvalidURLEscapeSequences) {
+  struct TestCase {
+    const char* input;
+    bool is_invalid;
+  } cases[] = {
+      // Edge cases.
+      {"", false},
+      {"%", true},
+
+      // Single regular chars with no escaping are valid.
+      {"a", false},
+      {"g", false},
+      {"A", false},
+      {"G", false},
+      {":", false},
+      {"]", false},
+      {"\x00", false},      // ASCII 'NUL' char
+      {"\x01", false},      // ASCII 'SOH' char
+      {"\xC2\xA3", false},  // UTF-8 encoded '£'.
+
+      // Longer strings without escaping are valid.
+      {"Hello world", false},
+      {"Here: [%25] <-- a percent-encoded percent character.", false},
+
+      // Valid %-escaped sequences ('%' followed by two hex digits).
+      {"%00", false},
+      {"%20", false},
+      {"%02", false},
+      {"%ff", false},
+      {"%FF", false},
+      {"%0a", false},
+      {"%0A", false},
+      {"abc%FF", false},
+      {"%FFabc", false},
+      {"abc%FFabc", false},
+      {"hello %FF world", false},
+      {"%20hello%20world", false},
+      {"%25", false},
+      {"%25%25", false},
+      {"%250", false},
+      {"%259", false},
+      {"%25A", false},
+      {"%25F", false},
+      {"%0a:", false},
+
+      // '%' followed by a single character is never a valid sequence.
+      {"%%", true},
+      {"%2", true},
+      {"%a", true},
+      {"%A", true},
+      {"%g", true},
+      {"%G", true},
+      {"%:", true},
+      {"%[", true},
+      {"%F", true},
+      {"%\xC2\xA3", true},  //% followed by UTF-8 encoded '£'.
+
+      // String ends on a potential escape sequence but without two hex-digits
+      // is invalid.
+      {"abc%", true},
+      {"abc%%", true},
+      {"abc%%%", true},
+      {"abc%a", true},
+
+      // One hex and one non-hex digit is invalid.
+      {"%a:", true},
+      {"%:a", true},
+      {"%::", true},
+      {"%ag", true},
+      {"%ga", true},
+      {"%-1", true},
+      {"%1-", true},
+      {"%0\xC2\xA3", true},  // %0£.
+  };
+
+  for (TestCase test_case : cases) {
+    const char* input = test_case.input;
+    bool result = HasInvalidURLEscapeSequences(input);
+    EXPECT_EQ(test_case.is_invalid, result)
+        << "Invalid result for '" << input << "'";
+  }
+}
+
 }  // namespace url