diff --git a/AUTHORS b/AUTHORS
index a619990..ce38168 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -54,6 +54,7 @@
 Alexander Zhirov <ciberst@gmail.com>
 Alexandre Abreu <wiss1976@gmail.com>
 Alexandru Chiculita <achicu@adobe.com>
+Alexey Knyazev <lexa.knyazev@gmail.com>
 Alexey Korepanov <alexkorep@gmail.com>
 Alexey Kuts <kruntuid@gmail.com>
 Alexey Kuzmin <alex.s.kuzmin@gmail.com>
@@ -89,6 +90,7 @@
 Andrew Hung <andrhung@amazon.com>
 Andrew Jorgensen <ajorgens@amazon.com>
 Andrew MacPherson <andrew.macpherson@soundtrap.com>
+Andrew Nicols <andrewrn@gmail.com>
 Andrew Tulloch <andrew@tullo.ch>
 Andriy Rysin <arysin@gmail.com>
 Anish Patankar <anish.p@samsung.com>
@@ -327,6 +329,7 @@
 Frédéric Jacob <frederic.jacob.78@gmail.com>
 Frédéric Wang <fred.wang@free.fr>
 Fu Junwei <junwei.fu@intel.com>
+Gabriel Campana <gabriel.campana@ledger.fr>
 Gabor Rapcsanyi <g.rapcsanyi@samsung.com>
 Gaetano Mendola <mendola@gmail.com>
 Gajendra N <gajendra.n@samsung.com>
@@ -441,6 +444,7 @@
 James Vega <vega.james@gmail.com>
 James Wei <james.wei@intel.com>
 James Willcox <jwillcox@litl.com>
+Jan Grulich <grulja@gmail.com>
 Jan Rucka <ruckajan10@gmail.com>
 Jan Sauer <jan@jansauer.de>
 Janusz Majnert <jmajnert@gmail.com>
@@ -449,6 +453,7 @@
 Jared Sohn <jared.sohn@gmail.com>
 Jared Wein <weinjared@gmail.com>
 Jari Karppanen <jkarp@amazon.com>
+Jason Gronn <jasontopia03@gmail.com>
 Jay Oster <jay@kodewerx.org>
 Jay Soffian <jaysoffian@gmail.com>
 Jeado Ko <haibane84@gmail.com>
@@ -461,6 +466,7 @@
 Jeremy Spiegel <jeremysspiegel@gmail.com>
 Jeroen Van den Berghe <vandenberghe.jeroen@gmail.com>
 Jerry Lin <wahahab11@gmail.com>
+Jerry Zhang <zhj8407@gmail.com>
 Jesper Storm Bache <jsbache@gmail.com>
 Jesse Miller <jesse@jmiller.biz>
 Jesus Sanchez-Palencia <jesus.sanchez-palencia.fernandez.fil@intel.com>
@@ -492,6 +498,7 @@
 Jinsong Fan <fanjinsong@sogou-inc.com>
 Jinsong Fan <jinsong.van@gmail.com>
 Jinwoo Song <jinwoo7.song@samsung.com>
+Jinyoung Hur <hur.ims@navercorp.com>
 Jinyoung Hur <hurims@gmail.com>
 Jitendra Kumar Sahoo <jitendra.ks@samsung.com>
 Joachim Bauch <jbauch@webrtc.org>
@@ -500,6 +507,7 @@
 Joe Knoll <joe.knoll@workday.com>
 Joe Thomas <mhx348@motorola.com>
 Joel Stanley <joel@jms.id.au>
+Joey Jiao <joeyjiao0810@gmail.com>
 Johannes Rudolph <johannes.rudolph@googlemail.com>
 John Kleinschmidt <kleinschmidtorama@gmail.com>
 John Yani <vanuan@gmail.com>
@@ -556,6 +564,7 @@
 Karan Thakkar <karanjthakkar@gmail.com>
 Kartikey Bhatt <kartikey@amazon.com>
 Kaspar Brand <googlecontrib@velox.ch>
+Kaushalendra Mishra <k.mishra@samsung.com>
 Kaustubh Atrawalkar <kaustubh.a@samsung.com>
 Kaustubh Atrawalkar <kaustubh.ra@gmail.com>
 Ke He <ke.he@intel.com>
@@ -611,6 +620,7 @@
 Le Hoang Quyen <le.hoang.q@gmail.com>
 Legend Lee <guanxian.li@intel.com>
 Leith Bade <leith@leithalweapon.geek.nz>
+Lei Gao <leigao@huawei.com>
 Lei Li <lli.kernel.kvm@gmail.com>
 Lenny Khazan <lenny.khazan@gmail.com>
 Leo Wolf <jclw@ymail.com>
@@ -660,6 +670,7 @@
 Mariusz Mlynski <marius.mlynski@gmail.com>
 Mark Hahnenberg <mhahnenb@andrew.cmu.edu>
 Mark Seaborn <mrs@mythic-beasts.com>
+Mark Winter <wintermarkedward@gmail.com>
 Martijn Croonen <martijn@martijnc.be>
 Martin Bednorz <m.s.bednorz@gmail.com>
 Martin Persson <mnpn03@gmail.com>
@@ -696,6 +707,7 @@
 Michael Constant <mconst@gmail.com>
 Michael Forney <mforney@mforney.org>
 Michael Gilbert <floppymaster@gmail.com>
+Michael Kolomeytsev <michael.kolomeytsev@gmail.com>
 Michael Lopez <lopes92290@gmail.com>
 Michael Morrison <codebythepound@gmail.com>
 Michael Müller <michael@fds-team.de>
@@ -868,6 +880,7 @@
 Robert O'Callahan <rocallahan@gmail.com>
 Robert Nagy <robert.nagy@gmail.com>
 Robert Sesek <rsesek@bluestatic.org>
+Roee Kasher <roee91@gmail.com>
 Roger Zanoni <rogerzanoni@gmail.com>
 Roland Takacs <rtakacs.u-szeged@partner.samsung.com>
 Romain Pokrzywka <romain.pokrzywka@gmail.com>
@@ -965,10 +978,12 @@
 Siddharth Shankar <funkysidd@gmail.com>
 Simeon Kuran <simeon.kuran@gmail.com>
 Simon Arlott <simon.arlott@gmail.com>
+Simon Jackson <simon.jackson@sonocent.com>
 Simon La Macchia <smacchia@amazon.com>
 Siva Kumar Gunturi <siva.gunturi@samsung.com>
 Sohan Jyoti Ghosh <sohan.jyoti@huawei.com>
 Sohan Jyoti Ghosh <sohan.jyoti@samsung.com>
+Song Fangzhen <songfangzhen@bytedance.com>
 Song YeWen <ffmpeg@gmail.com>
 Sooho Park <sooho1000@gmail.com>
 Soojung Choi <crystal2840@gmail.com>
@@ -1077,6 +1092,7 @@
 Wojciech Bielawski <wojciech.bielawski@gmail.com>
 Wanming Lin <wanming.lin@intel.com>
 Wei Li <wei.c.li@intel.com>
+Wen Fan <fanwen1@huawei.com>
 Wenxiang Qian <leonwxqian@gmail.com>
 WenSheng He <wensheng.he@samsung.com>
 Wesley Lancel <wesleylancel@gmail.com>
diff --git a/base/BUILD b/base/BUILD
index 2ab77e8..63787b7 100644
--- a/base/BUILD
+++ b/base/BUILD
@@ -9,6 +9,7 @@
     hdrs = [
         "compiler_specific.h",
         "containers/checked_iterators.h",
+        "containers/contains.h",
         "containers/contiguous_iterator.h",
         "containers/span.h",
         "containers/util.h",
@@ -16,6 +17,7 @@
         "functional/identity.h",
         "functional/invoke.h",
         "functional/not_fn.h",
+        "i18n/uchar.h",
         "macros.h",
         "no_destructor.h",
         "optional.h",
diff --git a/base/compiler_specific.h b/base/compiler_specific.h
index fe3d499..fa961b0 100644
--- a/base/compiler_specific.h
+++ b/base/compiler_specific.h
@@ -65,7 +65,7 @@
 // To provide the complementary behavior (prevent the annotated function from
 // being omitted) look at NOINLINE. Also note that this doesn't prevent code
 // folding of multiple identical caller functions into a single signature. To
-// prevent code folding, see gurl_base::debug::Alias.
+// prevent code folding, see NO_CODE_FOLDING() in base/debug/alias.h.
 // Use like:
 //   void NOT_TAIL_CALLED FooBar();
 #if defined(__clang__) && __has_attribute(not_tail_called)
diff --git a/base/containers/contiguous_iterator.h b/base/containers/contiguous_iterator.h
index a1c1f9b..48b2755 100644
--- a/base/containers/contiguous_iterator.h
+++ b/base/containers/contiguous_iterator.h
@@ -26,13 +26,19 @@
 template <typename T>
 struct IsPointer : std::is_pointer<T> {};
 
+template <typename T, typename StringT = std::basic_string<iter_value_t<T>>>
+struct IsStringIterImpl
+    : disjunction<std::is_same<T, typename StringT::const_iterator>,
+                  std::is_same<T, typename StringT::iterator>> {};
+
 // An iterator to std::basic_string is contiguous.
 // Reference: https://wg21.link/basic.string.general#2
-template <typename T, typename StringT = std::basic_string<iter_value_t<T>>>
+//
+// Note: Requires indirection via `IsStringIterImpl` to avoid triggering a
+// `static_assert(is_trivial_v<value_type>)` inside libc++'s std::basic_string.
+template <typename T>
 struct IsStringIter
-    : conjunction<std::is_trivial<iter_value_t<T>>,
-                  disjunction<std::is_same<T, typename StringT::const_iterator>,
-                              std::is_same<T, typename StringT::iterator>>> {};
+    : conjunction<std::is_trivial<iter_value_t<T>>, IsStringIterImpl<T>> {};
 
 // An iterator to std::array is contiguous.
 // Reference: https://wg21.link/array.overview#1
diff --git a/base/containers/util.h b/base/containers/util.h
index 14f012a..7a65b6a 100644
--- a/base/containers/util.h
+++ b/base/containers/util.h
@@ -12,7 +12,7 @@
 // TODO(crbug.com/817982): What we really need is for checked_math.h to be
 // able to do checked arithmetic on pointers.
 template <typename T>
-static inline uintptr_t get_uintptr(const T* t) {
+inline uintptr_t get_uintptr(const T* t) {
   return reinterpret_cast<uintptr_t>(t);
 }
 
diff --git a/base/macros.h b/base/macros.h
index c67bdbd..19d15ca 100644
--- a/base/macros.h
+++ b/base/macros.h
@@ -14,21 +14,20 @@
 // Use explicit deletions instead.  See the section on copyability/movability in
 // //styleguide/c++/c++-dos-and-donts.md for more information.
 
-// Put this in the declarations for a class to be uncopyable.
+// DEPRECATED: See above. Makes a class uncopyable.
 #define DISALLOW_COPY(TypeName) \
   TypeName(const TypeName&) = delete
 
-// Put this in the declarations for a class to be unassignable.
+// DEPRECATED: See above. Makes a class unassignable.
 #define DISALLOW_ASSIGN(TypeName) TypeName& operator=(const TypeName&) = delete
 
-// Put this in the declarations for a class to be uncopyable and unassignable.
+// DEPRECATED: See above. Makes a class uncopyable and unassignable.
 #define DISALLOW_COPY_AND_ASSIGN(TypeName) \
   DISALLOW_COPY(TypeName);                 \
   DISALLOW_ASSIGN(TypeName)
 
-// A macro to disallow all the implicit constructors, namely the
+// DEPRECATED: See above. Disallow all implicit constructors, namely the
 // default constructor, copy constructor and operator= functions.
-// This is especially useful for classes containing only static methods.
 #define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
   TypeName() = delete;                           \
   DISALLOW_COPY_AND_ASSIGN(TypeName)
diff --git a/base/ranges/algorithm.h b/base/ranges/algorithm.h
index 646b733..e6432f8 100644
--- a/base/ranges/algorithm.h
+++ b/base/ranges/algorithm.h
@@ -419,11 +419,12 @@
                     InputIterator last,
                     const T& value,
                     Proj proj = {}) {
-  // Note: In order to be able to apply `proj` to each element in [first, last)
-  // we are dispatching to std::find_if instead of std::find.
-  return std::find_if(first, last, [&proj, &value](auto&& lhs) {
-    return gurl_base::invoke(proj, std::forward<decltype(lhs)>(lhs)) == value;
-  });
+  for (; first != last; ++first) {
+    if (gurl_base::invoke(proj, *first) == value)
+      break;
+  }
+
+  return first;
 }
 
 // Let `E(i)` be `bool(invoke(proj, *i) == value)`.
@@ -4299,7 +4300,7 @@
 //
 // Returns: `last`.
 //
-// Complexity: At most `3 log(last - first)` comparisons and twice as many
+// Complexity: At most `3 * (last - first)` comparisons and twice as many
 // projections.
 //
 // Reference: https://wg21.link/make.heap#:~:text=ranges::make_heap(I
@@ -4323,7 +4324,7 @@
 //
 // Returns: `end(range)`.
 //
-// Complexity: At most `3 log(size(range))` comparisons and twice as many
+// Complexity: At most `3 * size(range)` comparisons and twice as many
 // projections.
 //
 // Reference: https://wg21.link/make.heap#:~:text=ranges::make_heap(R
diff --git a/base/stl_util.h b/base/stl_util.h
index f3d86ef..29f200e 100644
--- a/base/stl_util.h
+++ b/base/stl_util.h
@@ -24,6 +24,7 @@
 #include <vector>
 
 #include "polyfills/base/check.h"
+#include "base/containers/contains.h"
 #include "base/optional.h"
 #include "base/ranges/algorithm.h"
 #include "base/template_util.h"
@@ -51,38 +52,6 @@
     std::is_same<typename std::iterator_traits<Iter>::iterator_category,
                  std::random_access_iterator_tag>::value;
 
-// Utility type traits used for specializing gurl_base::Contains() below.
-template <typename Container, typename Element, typename = void>
-struct HasFindWithNpos : std::false_type {};
-
-template <typename Container, typename Element>
-struct HasFindWithNpos<
-    Container,
-    Element,
-    void_t<decltype(std::declval<const Container&>().find(
-                        std::declval<const Element&>()) != Container::npos)>>
-    : std::true_type {};
-
-template <typename Container, typename Element, typename = void>
-struct HasFindWithEnd : std::false_type {};
-
-template <typename Container, typename Element>
-struct HasFindWithEnd<Container,
-                      Element,
-                      void_t<decltype(std::declval<const Container&>().find(
-                                          std::declval<const Element&>()) !=
-                                      std::declval<const Container&>().end())>>
-    : std::true_type {};
-
-template <typename Container, typename Element, typename = void>
-struct HasContains : std::false_type {};
-
-template <typename Container, typename Element>
-struct HasContains<Container,
-                   Element,
-                   void_t<decltype(std::declval<const Container&>().contains(
-                       std::declval<const Element&>()))>> : std::true_type {};
-
 }  // namespace internal
 
 // C++14 implementation of C++17's std::size():
@@ -219,51 +188,6 @@
   return std::count(container.begin(), container.end(), val);
 }
 
-// General purpose implementation to check if |container| contains |value|.
-template <typename Container,
-          typename Value,
-          std::enable_if_t<
-              !internal::HasFindWithNpos<Container, Value>::value &&
-              !internal::HasFindWithEnd<Container, Value>::value &&
-              !internal::HasContains<Container, Value>::value>* = nullptr>
-bool Contains(const Container& container, const Value& value) {
-  using std::begin;
-  using std::end;
-  return std::find(begin(container), end(container), value) != end(container);
-}
-
-// Specialized Contains() implementation for when |container| has a find()
-// member function and a static npos member, but no contains() member function.
-template <typename Container,
-          typename Value,
-          std::enable_if_t<internal::HasFindWithNpos<Container, Value>::value &&
-                           !internal::HasContains<Container, Value>::value>* =
-              nullptr>
-bool Contains(const Container& container, const Value& value) {
-  return container.find(value) != Container::npos;
-}
-
-// Specialized Contains() implementation for when |container| has a find()
-// and end() member function, but no contains() member function.
-template <typename Container,
-          typename Value,
-          std::enable_if_t<internal::HasFindWithEnd<Container, Value>::value &&
-                           !internal::HasContains<Container, Value>::value>* =
-              nullptr>
-bool Contains(const Container& container, const Value& value) {
-  return container.find(value) != container.end();
-}
-
-// Specialized Contains() implementation for when |container| has a contains()
-// member function.
-template <
-    typename Container,
-    typename Value,
-    std::enable_if_t<internal::HasContains<Container, Value>::value>* = nullptr>
-bool Contains(const Container& container, const Value& value) {
-  return container.contains(value);
-}
-
 // O(1) implementation of const casting an iterator for any sequence,
 // associative or unordered associative container in the STL.
 //
diff --git a/base/strings/BUILD b/base/strings/BUILD
index c76b35a..65f3293 100644
--- a/base/strings/BUILD
+++ b/base/strings/BUILD
@@ -12,7 +12,7 @@
         "string_util_constants.cc",
         "utf_string_conversion_utils.cc",
         "utf_string_conversions.cc",
-    ] + build_config.strings_srcs,
+    ],
     hdrs = [
         "char_traits.h",
         "string16.h",
diff --git a/base/strings/char_traits.h b/base/strings/char_traits.h
index 0fe9f26..13f5833 100644
--- a/base/strings/char_traits.h
+++ b/base/strings/char_traits.h
@@ -7,6 +7,8 @@
 
 #include <stddef.h>
 
+#include <string>
+
 #include "base/compiler_specific.h"
 
 namespace gurl_base {
@@ -33,10 +35,14 @@
 constexpr int CharTraits<T>::compare(const T* s1,
                                      const T* s2,
                                      size_t n) noexcept {
+  // Comparison with operator < fails, because of signed/unsigned
+  // mismatch, https://crbug.com/941696
+  // std::char_traits<T>::lt is guaranteed to be constexpr in C++14:
+  // https://timsong-cpp.github.io/cppwp/n4140/char.traits.specializations#char
   for (; n; --n, ++s1, ++s2) {
-    if (*s1 < *s2)
+    if (std::char_traits<T>::lt(*s1, *s2))
       return -1;
-    if (*s1 > *s2)
+    if (std::char_traits<T>::lt(*s2, *s1))
       return 1;
   }
   return 0;
@@ -50,42 +56,35 @@
   return i;
 }
 
-// char specialization of CharTraits that can use clang's constexpr instrinsics,
-// where available.
+// char and wchar_t specialization of CharTraits that can use clang's constexpr
+// instrinsics, where available.
+#if HAS_FEATURE(cxx_constexpr_string_builtins)
 template <>
 struct CharTraits<char> {
   static constexpr int compare(const char* s1,
                                const char* s2,
-                               size_t n) noexcept;
-  static constexpr size_t length(const char* s) noexcept;
+                               size_t n) noexcept {
+    return __builtin_memcmp(s1, s2, n);
+  }
+
+  static constexpr size_t length(const char* s) noexcept {
+    return __builtin_strlen(s);
+  }
 };
 
-constexpr int CharTraits<char>::compare(const char* s1,
-                                        const char* s2,
-                                        size_t n) noexcept {
-#if HAS_FEATURE(cxx_constexpr_string_builtins)
-  return __builtin_memcmp(s1, s2, n);
-#else
-  for (; n; --n, ++s1, ++s2) {
-    if (*s1 < *s2)
-      return -1;
-    if (*s1 > *s2)
-      return 1;
+template <>
+struct CharTraits<wchar_t> {
+  static constexpr int compare(const wchar_t* s1,
+                               const wchar_t* s2,
+                               size_t n) noexcept {
+    return __builtin_wmemcmp(s1, s2, n);
   }
-  return 0;
-#endif
-}
 
-constexpr size_t CharTraits<char>::length(const char* s) noexcept {
-#if defined(__clang__)
-  return __builtin_strlen(s);
-#else
-  size_t i = 0;
-  for (; *s; ++s)
-    ++i;
-  return i;
+  static constexpr size_t length(const wchar_t* s) noexcept {
+    return __builtin_wcslen(s);
+  }
+};
 #endif
-}
 
 }  // namespace base
 
diff --git a/base/strings/string16.cc b/base/strings/string16.cc
deleted file mode 100644
index 426d5b6..0000000
--- a/base/strings/string16.cc
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/strings/string16.h"
-
-#if defined(WCHAR_T_IS_UTF16) && !defined(_AIX)
-
-#error This file should not be used on 2-byte wchar_t systems
-// If this winds up being needed on 2-byte wchar_t systems, either the
-// definitions below can be used, or the host system's wide character
-// functions like wmemcmp can be wrapped.
-
-#elif defined(WCHAR_T_IS_UTF32)
-
-#include <string.h>
-
-#include <ostream>
-
-#include "base/strings/string_piece.h"
-
-namespace gurl_base {
-
-int c16memcmp(const char16* s1, const char16* s2, size_t n) {
-  // We cannot call memcmp because that changes the semantics.
-  while (n-- > 0) {
-    if (*s1 != *s2) {
-      // We cannot use (*s1 - *s2) because char16 is unsigned.
-      return ((*s1 < *s2) ? -1 : 1);
-    }
-    ++s1;
-    ++s2;
-  }
-  return 0;
-}
-
-size_t c16len(const char16* s) {
-  const char16 *s_orig = s;
-  while (*s) {
-    ++s;
-  }
-  return s - s_orig;
-}
-
-const char16* c16memchr(const char16* s, char16 c, size_t n) {
-  while (n-- > 0) {
-    if (*s == c) {
-      return s;
-    }
-    ++s;
-  }
-  return nullptr;
-}
-
-char16* c16memmove(char16* s1, const char16* s2, size_t n) {
-  return static_cast<char16*>(memmove(s1, s2, n * sizeof(char16)));
-}
-
-char16* c16memcpy(char16* s1, const char16* s2, size_t n) {
-  return static_cast<char16*>(memcpy(s1, s2, n * sizeof(char16)));
-}
-
-char16* c16memset(char16* s, char16 c, size_t n) {
-  char16 *s_orig = s;
-  while (n-- > 0) {
-    *s = c;
-    ++s;
-  }
-  return s_orig;
-}
-
-namespace string16_internals {
-
-std::ostream& operator<<(std::ostream& out, const string16& str) {
-  return out << gurl_base::StringPiece16(str);
-}
-
-void PrintTo(const string16& str, std::ostream* out) {
-  *out << str;
-}
-
-}  // namespace string16_internals
-
-}  // namespace base
-
-template class std::
-    basic_string<gurl_base::char16, gurl_base::string16_internals::string16_char_traits>;
-
-#endif  // WCHAR_T_IS_UTF32
diff --git a/base/strings/string16.h b/base/strings/string16.h
index f17a57f..dc3ddc7 100644
--- a/base/strings/string16.h
+++ b/base/strings/string16.h
@@ -6,34 +6,18 @@
 #define BASE_STRINGS_STRING16_H_
 
 // WHAT:
-// A version of std::basic_string that provides 2-byte characters even when
-// wchar_t is not implemented as a 2-byte type. You can access this class as
-// string16. We also define char16, which string16 is based upon.
+// Type aliases for string and character types supporting UTF-16 data. Prior to
+// C++11 there was no standard library solution for this, which is why wstring
+// was used where possible (i.e. where wchar_t holds UTF-16 encoded data).
 //
-// WHY:
-// On Windows, wchar_t is 2 bytes, and it can conveniently handle UTF-16/UCS-2
-// data. Plenty of existing code operates on strings encoded as UTF-16.
-//
-// On many other platforms, sizeof(wchar_t) is 4 bytes by default. We can make
-// it 2 bytes by using the GCC flag -fshort-wchar. But then std::wstring fails
-// at run time, because it calls some functions (like wcslen) that come from
-// the system's native C library -- which was built with a 4-byte wchar_t!
-// It's wasteful to use 4-byte wchar_t strings to carry UTF-16 data, and it's
-// entirely improper on those systems where the encoding of wchar_t is defined
-// as UTF-32.
-//
-// Here, we define string16, which is similar to std::wstring but replaces all
-// libc functions with custom, 2-byte-char compatible routines. It is capable
-// of carrying UTF-16-encoded data.
+// In C++11 we gained std::u16string, which is a cross-platform solution for
+// UTF-16 strings. This is now the string16 type where ever wchar_t does not
+// hold UTF16 data (i.e. commonly non-Windows platforms). Eventually this should
+// be used everywhere, at which point this type alias and this file should be
+// removed. https://crbug.com/911896 tracks the migration effort.
 
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-
-#include <functional>
 #include <string>
 
-#include "polyfills/base/base_export.h"
 #include "build/build_config.h"
 
 #if defined(WCHAR_T_IS_UTF16)
@@ -42,188 +26,24 @@
 // a literal string. This indirection allows for an easier migration of
 // gurl_base::char16 to char16_t on platforms where WCHAR_T_IS_UTF16, as only a one
 // character change to the macro will be necessary.
-// This macro does not exist when WCHAR_T_IS_UTF32, as it is currently not
-// possible to create a char array form a literal in this case.
 // TODO(https://crbug.com/911896): Remove this macro once gurl_base::char16 is
 // char16_t on all platforms.
 #define STRING16_LITERAL(x) L##x
 
 namespace gurl_base {
-
-typedef wchar_t char16;
-typedef std::wstring string16;
-
+using char16 = wchar_t;
+using string16 = std::wstring;
 }  // namespace base
 
-#elif defined(WCHAR_T_IS_UTF32)
+#else
 
-#include <wchar.h>  // for mbstate_t
+#define STRING16_LITERAL(x) u##x
 
 namespace gurl_base {
-
-typedef uint16_t char16;
-
-// char16 versions of the functions required by string16_char_traits; these
-// are based on the wide character functions of similar names ("w" or "wcs"
-// instead of "c16").
-BASE_EXPORT int c16memcmp(const char16* s1, const char16* s2, size_t n);
-BASE_EXPORT size_t c16len(const char16* s);
-BASE_EXPORT const char16* c16memchr(const char16* s, char16 c, size_t n);
-BASE_EXPORT char16* c16memmove(char16* s1, const char16* s2, size_t n);
-BASE_EXPORT char16* c16memcpy(char16* s1, const char16* s2, size_t n);
-BASE_EXPORT char16* c16memset(char16* s, char16 c, size_t n);
-
-// This namespace contains the implementation of gurl_base::string16 along with
-// things that need to be found via argument-dependent lookup from a
-// gurl_base::string16.
-namespace string16_internals {
-
-struct string16_char_traits {
-  typedef char16 char_type;
-  typedef int int_type;
-
-  // int_type needs to be able to hold each possible value of char_type, and in
-  // addition, the distinct value of eof().
-  static_assert(sizeof(int_type) > sizeof(char_type),
-                "int must be larger than 16 bits wide");
-
-  typedef std::streamoff off_type;
-  typedef mbstate_t state_type;
-  typedef std::fpos<state_type> pos_type;
-
-  static void assign(char_type& c1, const char_type& c2) {
-    c1 = c2;
-  }
-
-  static bool eq(const char_type& c1, const char_type& c2) {
-    return c1 == c2;
-  }
-  static bool lt(const char_type& c1, const char_type& c2) {
-    return c1 < c2;
-  }
-
-  static int compare(const char_type* s1, const char_type* s2, size_t n) {
-    return c16memcmp(s1, s2, n);
-  }
-
-  static size_t length(const char_type* s) {
-    return c16len(s);
-  }
-
-  static const char_type* find(const char_type* s, size_t n,
-                               const char_type& a) {
-    return c16memchr(s, a, n);
-  }
-
-  static char_type* move(char_type* s1, const char_type* s2, size_t n) {
-    return c16memmove(s1, s2, n);
-  }
-
-  static char_type* copy(char_type* s1, const char_type* s2, size_t n) {
-    return c16memcpy(s1, s2, n);
-  }
-
-  static char_type* assign(char_type* s, size_t n, char_type a) {
-    return c16memset(s, a, n);
-  }
-
-  static int_type not_eof(const int_type& c) {
-    return eq_int_type(c, eof()) ? 0 : c;
-  }
-
-  static char_type to_char_type(const int_type& c) {
-    return char_type(c);
-  }
-
-  static int_type to_int_type(const char_type& c) {
-    return int_type(c);
-  }
-
-  static bool eq_int_type(const int_type& c1, const int_type& c2) {
-    return c1 == c2;
-  }
-
-  static int_type eof() {
-    return static_cast<int_type>(EOF);
-  }
-};
-
-}  // namespace string16_internals
-
-typedef std::basic_string<char16,
-                          gurl_base::string16_internals::string16_char_traits>
-    string16;
-
-namespace string16_internals {
-
-BASE_EXPORT extern std::ostream& operator<<(std::ostream& out,
-                                            const string16& str);
-
-// This is required by googletest to print a readable output on test failures.
-BASE_EXPORT extern void PrintTo(const string16& str, std::ostream* out);
-
-}  // namespace string16_internals
-
+using char16 = char16_t;
+using string16 = std::u16string;
 }  // namespace base
 
-// The string class will be explicitly instantiated only once, in string16.cc.
-//
-// std::basic_string<> in GNU libstdc++ contains a static data member,
-// _S_empty_rep_storage, to represent empty strings.  When an operation such
-// as assignment or destruction is performed on a string, causing its existing
-// data member to be invalidated, it must not be freed if this static data
-// member is being used.  Otherwise, it counts as an attempt to free static
-// (and not allocated) data, which is a memory error.
-//
-// Generally, due to C++ template magic, _S_empty_rep_storage will be marked
-// as a coalesced symbol, meaning that the linker will combine multiple
-// instances into a single one when generating output.
-//
-// If a string class is used by multiple shared libraries, a problem occurs.
-// Each library will get its own copy of _S_empty_rep_storage.  When strings
-// are passed across a library boundary for alteration or destruction, memory
-// errors will result.  GNU libstdc++ contains a configuration option,
-// --enable-fully-dynamic-string (_GLIBCXX_FULLY_DYNAMIC_STRING), which
-// disables the static data member optimization, but it's a good optimization
-// and non-STL code is generally at the mercy of the system's STL
-// configuration.  Fully-dynamic strings are not the default for GNU libstdc++
-// libstdc++ itself or for the libstdc++ installations on the systems we care
-// about, such as Mac OS X and relevant flavors of Linux.
-//
-// See also http://gcc.gnu.org/bugzilla/show_bug.cgi?id=24196 .
-//
-// To avoid problems, string classes need to be explicitly instantiated only
-// once, in exactly one library.  All other string users see it via an "extern"
-// declaration.  This is precisely how GNU libstdc++ handles
-// std::basic_string<char> (string) and std::basic_string<wchar_t> (wstring).
-//
-// This also works around a Mac OS X linker bug in ld64-85.2.1 (Xcode 3.1.2),
-// in which the linker does not fully coalesce symbols when dead code
-// stripping is enabled.  This bug causes the memory errors described above
-// to occur even when a std::basic_string<> does not cross shared library
-// boundaries, such as in statically-linked executables.
-//
-// TODO(mark): File this bug with Apple and update this note with a bug number.
-
-extern template class BASE_EXPORT
-    std::basic_string<gurl_base::char16,
-                      gurl_base::string16_internals::string16_char_traits>;
-
-// Specialize std::hash for gurl_base::string16. Although the style guide forbids
-// this in general, it is necessary for consistency with WCHAR_T_IS_UTF16
-// platforms, where gurl_base::string16 is a type alias for std::wstring.
-namespace std {
-template <>
-struct hash<gurl_base::string16> {
-  std::size_t operator()(const gurl_base::string16& s) const {
-    std::size_t result = 0;
-    for (gurl_base::char16 c : s)
-      result = (result * 131) + c;
-    return result;
-  }
-};
-}  // namespace std
-
-#endif  // WCHAR_T_IS_UTF32
+#endif  // WCHAR_T_IS_UTF16
 
 #endif  // BASE_STRINGS_STRING16_H_
diff --git a/base/strings/string16_unittest.cc b/base/strings/string16_unittest.cc
index a9aecef..9cdb075 100644
--- a/base/strings/string16_unittest.cc
+++ b/base/strings/string16_unittest.cc
@@ -2,74 +2,22 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <sstream>
-#include <unordered_set>
-
 #include "base/strings/string16.h"
 
-#include "base/strings/utf_string_conversions.h"
-#include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gurl_base {
 
-#if defined(WCHAR_T_IS_UTF16)
+// Ensure that STRING16_LITERAL can be used to instantiate constants of type
+// char16 and char16[], respectively.
 TEST(String16Test, String16Literal) {
-  static constexpr char16 kHelloWorld[] = STRING16_LITERAL("Hello, World");
-  string16 hello_world = kHelloWorld;
-  EXPECT_EQ(kHelloWorld, hello_world);
-}
-#endif
+  static constexpr char16 kHelloChars[] = {
+      STRING16_LITERAL('H'), STRING16_LITERAL('e'), STRING16_LITERAL('l'),
+      STRING16_LITERAL('l'), STRING16_LITERAL('o'), STRING16_LITERAL('\0'),
+  };
 
-// We define a custom operator<< for string16 so we can use it with logging.
-// This tests that conversion.
-TEST(String16Test, OutputStream) {
-  // Basic stream test.
-  {
-    std::ostringstream stream;
-    stream << "Empty '" << string16() << "' standard '"
-           << string16(ASCIIToUTF16("Hello, world")) << "'";
-    EXPECT_STREQ("Empty '' standard 'Hello, world'",
-                 stream.str().c_str());
-  }
-
-  // Interesting edge cases.
-  {
-    // These should each get converted to the invalid character: EF BF BD.
-    string16 initial_surrogate;
-    initial_surrogate.push_back(0xd800);
-    string16 final_surrogate;
-    final_surrogate.push_back(0xdc00);
-
-    // Old italic A = U+10300, will get converted to: F0 90 8C 80 'z'.
-    string16 surrogate_pair;
-    surrogate_pair.push_back(0xd800);
-    surrogate_pair.push_back(0xdf00);
-    surrogate_pair.push_back('z');
-
-    // Will get converted to the invalid char + 's': EF BF BD 's'.
-    string16 unterminated_surrogate;
-    unterminated_surrogate.push_back(0xd800);
-    unterminated_surrogate.push_back('s');
-
-    std::ostringstream stream;
-    stream << initial_surrogate << "," << final_surrogate << ","
-           << surrogate_pair << "," << unterminated_surrogate;
-
-    EXPECT_STREQ("\xef\xbf\xbd,\xef\xbf\xbd,\xf0\x90\x8c\x80z,\xef\xbf\xbds",
-                 stream.str().c_str());
-  }
-}
-
-TEST(String16Test, Hash) {
-  string16 str1 = ASCIIToUTF16("hello");
-  string16 str2 = ASCIIToUTF16("world");
-
-  std::unordered_set<string16> set;
-
-  set.insert(str1);
-  EXPECT_EQ(1u, set.count(str1));
-  EXPECT_EQ(0u, set.count(str2));
+  static constexpr char16 kHelloStr[] = STRING16_LITERAL("Hello");
+  EXPECT_EQ(std::char_traits<char16>::compare(kHelloChars, kHelloStr, 6), 0);
 }
 
 }  // namespace base
diff --git a/base/strings/string_piece.cc b/base/strings/string_piece.cc
index 62ba11f..fe9be5f 100644
--- a/base/strings/string_piece.cc
+++ b/base/strings/string_piece.cc
@@ -12,6 +12,7 @@
 #include <ostream>
 
 #include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
 
 namespace gurl_base {
 namespace {
@@ -24,8 +25,7 @@
 // the possible values of an unsigned char.  Thus it should be be declared
 // as follows:
 //   bool table[UCHAR_MAX + 1]
-inline void BuildLookupTable(const StringPiece& characters_wanted,
-                             bool* table) {
+inline void BuildLookupTable(StringPiece characters_wanted, bool* table) {
   const size_t length = characters_wanted.length();
   const char* const data = characters_wanted.data();
   for (size_t i = 0; i < length; ++i) {
@@ -41,39 +41,25 @@
 template class BasicStringPiece<string16>;
 #endif
 
-std::ostream& operator<<(std::ostream& o, const StringPiece& piece) {
+std::ostream& operator<<(std::ostream& o, StringPiece piece) {
   o.write(piece.data(), static_cast<std::streamsize>(piece.size()));
   return o;
 }
 
-std::ostream& operator<<(std::ostream& o, const StringPiece16& piece) {
+std::ostream& operator<<(std::ostream& o, StringPiece16 piece) {
   return o << UTF16ToUTF8(piece);
 }
 
+#if !defined(WCHAR_T_IS_UTF16)
+std::ostream& operator<<(std::ostream& o, WStringPiece piece) {
+  return o << WideToUTF8(piece);
+}
+#endif
+
 namespace internal {
 
-template<typename STR>
-size_t copyT(const BasicStringPiece<STR>& self,
-             typename STR::value_type* buf,
-             size_t n,
-             size_t pos) {
-  size_t ret = std::min(self.size() - pos, n);
-  memcpy(buf, self.data() + pos, ret * sizeof(typename STR::value_type));
-  return ret;
-}
-
-size_t copy(const StringPiece& self, char* buf, size_t n, size_t pos) {
-  return copyT(self, buf, n, pos);
-}
-
-size_t copy(const StringPiece16& self, char16* buf, size_t n, size_t pos) {
-  return copyT(self, buf, n, pos);
-}
-
-template<typename STR>
-size_t findT(const BasicStringPiece<STR>& self,
-             const BasicStringPiece<STR>& s,
-             size_t pos) {
+template <typename STR>
+size_t findT(BasicStringPiece<STR> self, BasicStringPiece<STR> s, size_t pos) {
   if (pos > self.size())
     return BasicStringPiece<STR>::npos;
 
@@ -84,16 +70,16 @@
   return xpos + s.size() <= self.size() ? xpos : BasicStringPiece<STR>::npos;
 }
 
-size_t find(const StringPiece& self, const StringPiece& s, size_t pos) {
+size_t find(StringPiece self, StringPiece s, size_t pos) {
   return findT(self, s, pos);
 }
 
-size_t find(const StringPiece16& self, const StringPiece16& s, size_t pos) {
+size_t find(StringPiece16 self, StringPiece16 s, size_t pos) {
   return findT(self, s, pos);
 }
 
-template<typename STR>
-size_t findT(const BasicStringPiece<STR>& self,
+template <typename STR>
+size_t findT(BasicStringPiece<STR> self,
              typename STR::value_type c,
              size_t pos) {
   if (pos >= self.size())
@@ -105,18 +91,16 @@
       static_cast<size_t>(result - self.begin()) : BasicStringPiece<STR>::npos;
 }
 
-size_t find(const StringPiece& self, char c, size_t pos) {
+size_t find(StringPiece self, char c, size_t pos) {
   return findT(self, c, pos);
 }
 
-size_t find(const StringPiece16& self, char16 c, size_t pos) {
+size_t find(StringPiece16 self, char16 c, size_t pos) {
   return findT(self, c, pos);
 }
 
-template<typename STR>
-size_t rfindT(const BasicStringPiece<STR>& self,
-              const BasicStringPiece<STR>& s,
-              size_t pos) {
+template <typename STR>
+size_t rfindT(BasicStringPiece<STR> self, BasicStringPiece<STR> s, size_t pos) {
   if (self.size() < s.size())
     return BasicStringPiece<STR>::npos;
 
@@ -131,16 +115,16 @@
       static_cast<size_t>(result - self.begin()) : BasicStringPiece<STR>::npos;
 }
 
-size_t rfind(const StringPiece& self, const StringPiece& s, size_t pos) {
+size_t rfind(StringPiece self, StringPiece s, size_t pos) {
   return rfindT(self, s, pos);
 }
 
-size_t rfind(const StringPiece16& self, const StringPiece16& s, size_t pos) {
+size_t rfind(StringPiece16 self, StringPiece16 s, size_t pos) {
   return rfindT(self, s, pos);
 }
 
-template<typename STR>
-size_t rfindT(const BasicStringPiece<STR>& self,
+template <typename STR>
+size_t rfindT(BasicStringPiece<STR> self,
               typename STR::value_type c,
               size_t pos) {
   if (self.size() == 0)
@@ -156,18 +140,16 @@
   return BasicStringPiece<STR>::npos;
 }
 
-size_t rfind(const StringPiece& self, char c, size_t pos) {
+size_t rfind(StringPiece self, char c, size_t pos) {
   return rfindT(self, c, pos);
 }
 
-size_t rfind(const StringPiece16& self, char16 c, size_t pos) {
+size_t rfind(StringPiece16 self, char16 c, size_t pos) {
   return rfindT(self, c, pos);
 }
 
 // 8-bit version using lookup table.
-size_t find_first_of(const StringPiece& self,
-                     const StringPiece& s,
-                     size_t pos) {
+size_t find_first_of(StringPiece self, StringPiece s, size_t pos) {
   if (self.size() == 0 || s.size() == 0)
     return StringPiece::npos;
 
@@ -186,9 +168,7 @@
 }
 
 // 16-bit brute force version.
-size_t find_first_of(const StringPiece16& self,
-                     const StringPiece16& s,
-                     size_t pos) {
+size_t find_first_of(StringPiece16 self, StringPiece16 s, size_t pos) {
   // Use the faster std::find() if searching for a single character.
   StringPiece16::const_iterator found =
       s.size() == 1 ? std::find(self.begin() + pos, self.end(), s[0])
@@ -200,9 +180,7 @@
 }
 
 // 8-bit version using lookup table.
-size_t find_first_not_of(const StringPiece& self,
-                         const StringPiece& s,
-                         size_t pos) {
+size_t find_first_not_of(StringPiece self, StringPiece s, size_t pos) {
   if (self.size() == 0)
     return StringPiece::npos;
 
@@ -224,8 +202,8 @@
 }
 
 // 16-bit brute-force version.
-BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,
-                                     const StringPiece16& s,
+BASE_EXPORT size_t find_first_not_of(StringPiece16 self,
+                                     StringPiece16 s,
                                      size_t pos) {
   if (self.size() == 0)
     return StringPiece16::npos;
@@ -244,8 +222,8 @@
   return StringPiece16::npos;
 }
 
-template<typename STR>
-size_t find_first_not_ofT(const BasicStringPiece<STR>& self,
+template <typename STR>
+size_t find_first_not_ofT(BasicStringPiece<STR> self,
                           typename STR::value_type c,
                           size_t pos) {
   if (self.size() == 0)
@@ -259,20 +237,16 @@
   return BasicStringPiece<STR>::npos;
 }
 
-size_t find_first_not_of(const StringPiece& self,
-                         char c,
-                         size_t pos) {
+size_t find_first_not_of(StringPiece self, char c, size_t pos) {
   return find_first_not_ofT(self, c, pos);
 }
 
-size_t find_first_not_of(const StringPiece16& self,
-                         char16 c,
-                         size_t pos) {
+size_t find_first_not_of(StringPiece16 self, char16 c, size_t pos) {
   return find_first_not_ofT(self, c, pos);
 }
 
 // 8-bit version using lookup table.
-size_t find_last_of(const StringPiece& self, const StringPiece& s, size_t pos) {
+size_t find_last_of(StringPiece self, StringPiece s, size_t pos) {
   if (self.size() == 0 || s.size() == 0)
     return StringPiece::npos;
 
@@ -292,9 +266,7 @@
 }
 
 // 16-bit brute-force version.
-size_t find_last_of(const StringPiece16& self,
-                    const StringPiece16& s,
-                    size_t pos) {
+size_t find_last_of(StringPiece16 self, StringPiece16 s, size_t pos) {
   if (self.size() == 0)
     return StringPiece16::npos;
 
@@ -311,9 +283,7 @@
 }
 
 // 8-bit version using lookup table.
-size_t find_last_not_of(const StringPiece& self,
-                        const StringPiece& s,
-                        size_t pos) {
+size_t find_last_not_of(StringPiece self, StringPiece s, size_t pos) {
   if (self.size() == 0)
     return StringPiece::npos;
 
@@ -337,9 +307,7 @@
 }
 
 // 16-bit brute-force version.
-size_t find_last_not_of(const StringPiece16& self,
-                        const StringPiece16& s,
-                        size_t pos) {
+size_t find_last_not_of(StringPiece16 self, StringPiece16 s, size_t pos) {
   if (self.size() == 0)
     return StringPiece::npos;
 
@@ -359,8 +327,8 @@
   return StringPiece16::npos;
 }
 
-template<typename STR>
-size_t find_last_not_ofT(const BasicStringPiece<STR>& self,
+template <typename STR>
+size_t find_last_not_ofT(BasicStringPiece<STR> self,
                          typename STR::value_type c,
                          size_t pos) {
   if (self.size() == 0)
@@ -375,15 +343,11 @@
   return BasicStringPiece<STR>::npos;
 }
 
-size_t find_last_not_of(const StringPiece& self,
-                        char c,
-                        size_t pos) {
+size_t find_last_not_of(StringPiece self, char c, size_t pos) {
   return find_last_not_ofT(self, c, pos);
 }
 
-size_t find_last_not_of(const StringPiece16& self,
-                        char16 c,
-                        size_t pos) {
+size_t find_last_not_of(StringPiece16 self, char16 c, size_t pos) {
   return find_last_not_ofT(self, c, pos);
 }
 
diff --git a/base/strings/string_piece.h b/base/strings/string_piece.h
index de54e94..dea85e3 100644
--- a/base/strings/string_piece.h
+++ b/base/strings/string_piece.h
@@ -34,6 +34,7 @@
 #include "base/strings/char_traits.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_piece_forward.h"
+#include "build/build_config.h"
 
 namespace gurl_base {
 
@@ -48,86 +49,45 @@
 // template internal to the .cc file.
 namespace internal {
 
-BASE_EXPORT size_t copy(const StringPiece& self,
-                        char* buf,
-                        size_t n,
-                        size_t pos);
-BASE_EXPORT size_t copy(const StringPiece16& self,
-                        char16* buf,
-                        size_t n,
-                        size_t pos);
+BASE_EXPORT size_t find(StringPiece self, StringPiece s, size_t pos);
+BASE_EXPORT size_t find(StringPiece16 self, StringPiece16 s, size_t pos);
+BASE_EXPORT size_t find(StringPiece self, char c, size_t pos);
+BASE_EXPORT size_t find(StringPiece16 self, char16 c, size_t pos);
 
-BASE_EXPORT size_t find(const StringPiece& self,
-                        const StringPiece& s,
-                        size_t pos);
-BASE_EXPORT size_t find(const StringPiece16& self,
-                        const StringPiece16& s,
-                        size_t pos);
-BASE_EXPORT size_t find(const StringPiece& self,
-                        char c,
-                        size_t pos);
-BASE_EXPORT size_t find(const StringPiece16& self,
-                        char16 c,
-                        size_t pos);
+BASE_EXPORT size_t rfind(StringPiece self, StringPiece s, size_t pos);
+BASE_EXPORT size_t rfind(StringPiece16 self, StringPiece16 s, size_t pos);
+BASE_EXPORT size_t rfind(StringPiece self, char c, size_t pos);
+BASE_EXPORT size_t rfind(StringPiece16 self, char16 c, size_t pos);
 
-BASE_EXPORT size_t rfind(const StringPiece& self,
-                         const StringPiece& s,
-                         size_t pos);
-BASE_EXPORT size_t rfind(const StringPiece16& self,
-                         const StringPiece16& s,
-                         size_t pos);
-BASE_EXPORT size_t rfind(const StringPiece& self,
-                         char c,
-                         size_t pos);
-BASE_EXPORT size_t rfind(const StringPiece16& self,
-                         char16 c,
-                         size_t pos);
-
-BASE_EXPORT size_t find_first_of(const StringPiece& self,
-                                 const StringPiece& s,
-                                 size_t pos);
-BASE_EXPORT size_t find_first_of(const StringPiece16& self,
-                                 const StringPiece16& s,
+BASE_EXPORT size_t find_first_of(StringPiece self, StringPiece s, size_t pos);
+BASE_EXPORT size_t find_first_of(StringPiece16 self,
+                                 StringPiece16 s,
                                  size_t pos);
 
-BASE_EXPORT size_t find_first_not_of(const StringPiece& self,
-                                     const StringPiece& s,
+BASE_EXPORT size_t find_first_not_of(StringPiece self,
+                                     StringPiece s,
                                      size_t pos);
-BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,
-                                     const StringPiece16& s,
+BASE_EXPORT size_t find_first_not_of(StringPiece16 self,
+                                     StringPiece16 s,
                                      size_t pos);
-BASE_EXPORT size_t find_first_not_of(const StringPiece& self,
-                                     char c,
-                                     size_t pos);
-BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,
-                                     char16 c,
-                                     size_t pos);
+BASE_EXPORT size_t find_first_not_of(StringPiece self, char c, size_t pos);
+BASE_EXPORT size_t find_first_not_of(StringPiece16 self, char16 c, size_t pos);
 
-BASE_EXPORT size_t find_last_of(const StringPiece& self,
-                                const StringPiece& s,
+BASE_EXPORT size_t find_last_of(StringPiece self, StringPiece s, size_t pos);
+BASE_EXPORT size_t find_last_of(StringPiece16 self,
+                                StringPiece16 s,
                                 size_t pos);
-BASE_EXPORT size_t find_last_of(const StringPiece16& self,
-                                const StringPiece16& s,
-                                size_t pos);
-BASE_EXPORT size_t find_last_of(const StringPiece& self,
-                                char c,
-                                size_t pos);
-BASE_EXPORT size_t find_last_of(const StringPiece16& self,
-                                char16 c,
-                                size_t pos);
+BASE_EXPORT size_t find_last_of(StringPiece self, char c, size_t pos);
+BASE_EXPORT size_t find_last_of(StringPiece16 self, char16 c, size_t pos);
 
-BASE_EXPORT size_t find_last_not_of(const StringPiece& self,
-                                    const StringPiece& s,
+BASE_EXPORT size_t find_last_not_of(StringPiece self,
+                                    StringPiece s,
                                     size_t pos);
-BASE_EXPORT size_t find_last_not_of(const StringPiece16& self,
-                                    const StringPiece16& s,
+BASE_EXPORT size_t find_last_not_of(StringPiece16 self,
+                                    StringPiece16 s,
                                     size_t pos);
-BASE_EXPORT size_t find_last_not_of(const StringPiece16& self,
-                                    char16 c,
-                                    size_t pos);
-BASE_EXPORT size_t find_last_not_of(const StringPiece& self,
-                                    char c,
-                                    size_t pos);
+BASE_EXPORT size_t find_last_not_of(StringPiece16 self, char16 c, size_t pos);
+BASE_EXPORT size_t find_last_not_of(StringPiece self, char c, size_t pos);
 
 }  // namespace internal
 
@@ -181,15 +141,6 @@
       : ptr_(str.data()), length_(str.size()) {}
   constexpr BasicStringPiece(const value_type* offset, size_type len)
       : ptr_(offset), length_(len) {}
-  BasicStringPiece(const typename STRING_TYPE::const_iterator& begin,
-                   const typename STRING_TYPE::const_iterator& end) {
-    GURL_DCHECK(begin <= end) << "StringPiece iterators swapped or invalid.";
-    length_ = static_cast<size_t>(std::distance(begin, end));
-
-    // The length test before assignment is to avoid dereferencing an iterator
-    // that may point to the end() of a string.
-    ptr_ = length_ > 0 ? &*begin : nullptr;
-  }
 
   // data() may return a pointer to a buffer with embedded NULs, and the
   // returned buffer may or may not be null terminated.  Therefore it is
@@ -226,16 +177,6 @@
     length_ -= n;
   }
 
-  constexpr int compare(BasicStringPiece x) const noexcept {
-    int r = CharTraits<value_type>::compare(
-        ptr_, x.ptr_, (length_ < x.length_ ? length_ : x.length_));
-    if (r == 0) {
-      if (length_ < x.length_) r = -1;
-      else if (length_ > x.length_) r = +1;
-    }
-    return r;
-  }
-
   // This is the style of conversion preferred by std::string_view in C++17.
   explicit operator STRING_TYPE() const {
     return empty() ? STRING_TYPE() : STRING_TYPE(data(), size());
@@ -261,72 +202,187 @@
   size_type max_size() const { return length_; }
   size_type capacity() const { return length_; }
 
-  size_type copy(value_type* buf, size_type n, size_type pos = 0) const {
-    return internal::copy(*this, buf, n, pos);
+  // String operations, see https://wg21.link/string.view.ops.
+  constexpr size_type copy(value_type* s,
+                           size_type n,
+                           size_type pos = 0) const {
+    GURL_CHECK_LE(pos, size());
+    size_type rlen = std::min(n, size() - pos);
+    traits_type::copy(s, data() + pos, rlen);
+    return rlen;
   }
 
+  constexpr BasicStringPiece substr(size_type pos = 0,
+                                    size_type n = npos) const {
+    GURL_CHECK_LE(pos, size());
+    return {data() + pos, std::min(n, size() - pos)};
+  }
+
+  constexpr int compare(BasicStringPiece str) const noexcept {
+    size_type rlen = std::min(size(), str.size());
+    int result = CharTraits<value_type>::compare(data(), str.data(), rlen);
+    if (result == 0)
+      result = size() == str.size() ? 0 : (size() < str.size() ? -1 : 1);
+    return result;
+  }
+
+  constexpr int compare(size_type pos,
+                        size_type n,
+                        BasicStringPiece str) const {
+    return substr(pos, n).compare(str);
+  }
+
+  constexpr int compare(size_type pos1,
+                        size_type n1,
+                        BasicStringPiece str,
+                        size_type pos2,
+                        size_type n2) const {
+    return substr(pos1, n1).compare(str.substr(pos2, n2));
+  }
+
+  constexpr int compare(const value_type* s) const {
+    return compare(BasicStringPiece(s));
+  }
+
+  constexpr int compare(size_type pos, size_type n, const value_type* s) const {
+    return substr(pos, n).compare(BasicStringPiece(s));
+  }
+
+  constexpr int compare(size_type pos,
+                        size_type n1,
+                        const value_type* s,
+                        size_type n2) const {
+    return substr(pos, n1).compare(BasicStringPiece(s, n2));
+  }
+
+  // Searching, see https://wg21.link/string.view.find.
+
   // find: Search for a character or substring at a given offset.
-  size_type find(const BasicStringPiece<STRING_TYPE>& s,
-                 size_type pos = 0) const {
+  constexpr size_type find(BasicStringPiece s,
+                           size_type pos = 0) const noexcept {
     return internal::find(*this, s, pos);
   }
-  size_type find(value_type c, size_type pos = 0) const {
+
+  constexpr size_type find(value_type c, size_type pos = 0) const noexcept {
     return internal::find(*this, c, pos);
   }
 
+  constexpr size_type find(const value_type* s,
+                           size_type pos,
+                           size_type n) const {
+    return find(BasicStringPiece(s, n), pos);
+  }
+
+  constexpr size_type find(const value_type* s, size_type pos = 0) const {
+    return find(BasicStringPiece(s), pos);
+  }
+
   // rfind: Reverse find.
-  size_type rfind(const BasicStringPiece& s,
-                  size_type pos = BasicStringPiece::npos) const {
+  constexpr size_type rfind(BasicStringPiece s,
+                            size_type pos = npos) const noexcept {
     return internal::rfind(*this, s, pos);
   }
-  size_type rfind(value_type c, size_type pos = BasicStringPiece::npos) const {
+
+  constexpr size_type rfind(value_type c, size_type pos = npos) const noexcept {
     return internal::rfind(*this, c, pos);
   }
 
-  // find_first_of: Find the first occurence of one of a set of characters.
-  size_type find_first_of(const BasicStringPiece& s,
-                          size_type pos = 0) const {
+  constexpr size_type rfind(const value_type* s,
+                            size_type pos,
+                            size_type n) const {
+    return rfind(BasicStringPiece(s, n), pos);
+  }
+
+  constexpr size_type rfind(const value_type* s, size_type pos = npos) const {
+    return rfind(BasicStringPiece(s), pos);
+  }
+
+  // find_first_of: Find the first occurrence of one of a set of characters.
+  constexpr size_type find_first_of(BasicStringPiece s,
+                                    size_type pos = 0) const noexcept {
     return internal::find_first_of(*this, s, pos);
   }
-  size_type find_first_of(value_type c, size_type pos = 0) const {
+
+  constexpr size_type find_first_of(value_type c,
+                                    size_type pos = 0) const noexcept {
     return find(c, pos);
   }
 
-  // find_first_not_of: Find the first occurence not of a set of characters.
-  size_type find_first_not_of(const BasicStringPiece& s,
-                              size_type pos = 0) const {
-    return internal::find_first_not_of(*this, s, pos);
-  }
-  size_type find_first_not_of(value_type c, size_type pos = 0) const {
-    return internal::find_first_not_of(*this, c, pos);
+  constexpr size_type find_first_of(const value_type* s,
+                                    size_type pos,
+                                    size_type n) const {
+    return find_first_of(BasicStringPiece(s, n), pos);
   }
 
-  // find_last_of: Find the last occurence of one of a set of characters.
-  size_type find_last_of(const BasicStringPiece& s,
-                         size_type pos = BasicStringPiece::npos) const {
+  constexpr size_type find_first_of(const value_type* s,
+                                    size_type pos = 0) const {
+    return find_first_of(BasicStringPiece(s), pos);
+  }
+
+  // find_last_of: Find the last occurrence of one of a set of characters.
+  constexpr size_type find_last_of(BasicStringPiece s,
+                                   size_type pos = npos) const noexcept {
     return internal::find_last_of(*this, s, pos);
   }
-  size_type find_last_of(value_type c,
-                         size_type pos = BasicStringPiece::npos) const {
+
+  constexpr size_type find_last_of(value_type c,
+                                   size_type pos = npos) const noexcept {
     return rfind(c, pos);
   }
 
-  // find_last_not_of: Find the last occurence not of a set of characters.
-  size_type find_last_not_of(const BasicStringPiece& s,
-                             size_type pos = BasicStringPiece::npos) const {
+  constexpr size_type find_last_of(const value_type* s,
+                                   size_type pos,
+                                   size_type n) const {
+    return find_last_of(BasicStringPiece(s, n), pos);
+  }
+
+  constexpr size_type find_last_of(const value_type* s,
+                                   size_type pos = npos) const {
+    return find_last_of(BasicStringPiece(s), pos);
+  }
+
+  // find_first_not_of: Find the first occurrence not of a set of characters.
+  constexpr size_type find_first_not_of(BasicStringPiece s,
+                                        size_type pos = 0) const noexcept {
+    return internal::find_first_not_of(*this, s, pos);
+  }
+
+  constexpr size_type find_first_not_of(value_type c,
+                                        size_type pos = 0) const noexcept {
+    return internal::find_first_not_of(*this, c, pos);
+  }
+
+  constexpr size_type find_first_not_of(const value_type* s,
+                                        size_type pos,
+                                        size_type n) const {
+    return find_first_not_of(BasicStringPiece(s, n), pos);
+  }
+
+  constexpr size_type find_first_not_of(const value_type* s,
+                                        size_type pos = 0) const {
+    return find_first_not_of(BasicStringPiece(s), pos);
+  }
+
+  // find_last_not_of: Find the last occurrence not of a set of characters.
+  constexpr size_type find_last_not_of(BasicStringPiece s,
+                                       size_type pos = npos) const noexcept {
     return internal::find_last_not_of(*this, s, pos);
   }
-  size_type find_last_not_of(value_type c,
-                             size_type pos = BasicStringPiece::npos) const {
+
+  constexpr size_type find_last_not_of(value_type c,
+                                       size_type pos = npos) const noexcept {
     return internal::find_last_not_of(*this, c, pos);
   }
 
-  // substr.
-  constexpr BasicStringPiece substr(
-      size_type pos,
-      size_type n = BasicStringPiece::npos) const {
-    GURL_CHECK_LE(pos, size());
-    return {data() + pos, std::min(n, size() - pos)};
+  constexpr size_type find_last_not_of(const value_type* s,
+                                       size_type pos,
+                                       size_type n) const {
+    return find_last_not_of(BasicStringPiece(s, n), pos);
+  }
+
+  constexpr size_type find_last_not_of(const value_type* s,
+                                       size_type pos = npos) const {
+    return find_last_not_of(BasicStringPiece(s), pos);
   }
 
  protected:
@@ -472,11 +528,12 @@
   return !(lhs < rhs);
 }
 
-BASE_EXPORT std::ostream& operator<<(std::ostream& o,
-                                     const StringPiece& piece);
+BASE_EXPORT std::ostream& operator<<(std::ostream& o, StringPiece piece);
+BASE_EXPORT std::ostream& operator<<(std::ostream& o, StringPiece16 piece);
 
-BASE_EXPORT std::ostream& operator<<(std::ostream& o,
-                                     const StringPiece16& piece);
+#if !defined(WCHAR_T_IS_UTF16)
+BASE_EXPORT std::ostream& operator<<(std::ostream& o, WStringPiece piece);
+#endif
 
 // Hashing ---------------------------------------------------------------------
 
diff --git a/base/strings/string_piece_unittest.cc b/base/strings/string_piece_unittest.cc
index e0d812b..76de8f7 100644
--- a/base/strings/string_piece_unittest.cc
+++ b/base/strings/string_piece_unittest.cc
@@ -269,12 +269,13 @@
   ASSERT_EQ(e.find(d, 4), std::string().find(std::string(), 4));
   ASSERT_EQ(e.find(e, 4), std::string().find(std::string(), 4));
 
+  constexpr typename TypeParam::value_type kNul = '\0';
   ASSERT_EQ(a.find('a'), 0U);
   ASSERT_EQ(a.find('c'), 2U);
   ASSERT_EQ(a.find('z'), 25U);
   ASSERT_EQ(a.find('$'), Piece::npos);
-  ASSERT_EQ(a.find('\0'), Piece::npos);
-  ASSERT_EQ(f.find('\0'), 3U);
+  ASSERT_EQ(a.find(kNul), Piece::npos);
+  ASSERT_EQ(f.find(kNul), 3U);
   ASSERT_EQ(f.find('3'), 2U);
   ASSERT_EQ(f.find('5'), 5U);
   ASSERT_EQ(g.find('o'), 4U);
@@ -282,15 +283,44 @@
   ASSERT_EQ(g.find('o', 5), 8U);
   ASSERT_EQ(a.find('b', 5), Piece::npos);
   // empty string nonsense
-  ASSERT_EQ(d.find('\0'), Piece::npos);
-  ASSERT_EQ(e.find('\0'), Piece::npos);
-  ASSERT_EQ(d.find('\0', 4), Piece::npos);
-  ASSERT_EQ(e.find('\0', 7), Piece::npos);
+  ASSERT_EQ(d.find(kNul), Piece::npos);
+  ASSERT_EQ(e.find(kNul), Piece::npos);
+  ASSERT_EQ(d.find(kNul, 4), Piece::npos);
+  ASSERT_EQ(e.find(kNul, 7), Piece::npos);
   ASSERT_EQ(d.find('x'), Piece::npos);
   ASSERT_EQ(e.find('x'), Piece::npos);
   ASSERT_EQ(d.find('x', 4), Piece::npos);
   ASSERT_EQ(e.find('x', 7), Piece::npos);
 
+  ASSERT_EQ(a.find(b.data(), 1, 0), 1U);
+  ASSERT_EQ(a.find(c.data(), 9, 0), 9U);
+  ASSERT_EQ(a.find(c.data(), Piece::npos, 0), Piece::npos);
+  ASSERT_EQ(b.find(c.data(), Piece::npos, 0), Piece::npos);
+  ASSERT_EQ(a.find(d.data(), 12, 0), 12U);
+  ASSERT_EQ(a.find(e.data(), 17, 0), 17U);
+  // empty string nonsense
+  ASSERT_EQ(d.find(b.data(), 4, 0), Piece::npos);
+  ASSERT_EQ(e.find(b.data(), 7, 0), Piece::npos);
+
+  ASSERT_EQ(a.find(b.data(), 1), Piece::npos);
+  ASSERT_EQ(a.find(c.data(), 9), 23U);
+  ASSERT_EQ(a.find(c.data(), Piece::npos), Piece::npos);
+  ASSERT_EQ(b.find(c.data(), Piece::npos), Piece::npos);
+  ASSERT_EQ(a.find(d.data(), 12), 12U);
+  ASSERT_EQ(a.find(e.data(), 17), 17U);
+  // empty string nonsense
+  ASSERT_EQ(d.find(b.data(), 4), Piece::npos);
+  ASSERT_EQ(e.find(b.data(), 7), Piece::npos);
+
+  ASSERT_EQ(d.find(d.data(), 4, 0),
+            std::string().find(std::string().data(), 4, 0));
+  ASSERT_EQ(d.find(e.data(), 4, 1),
+            std::string().find(std::string().data(), 4, 1));
+  ASSERT_EQ(e.find(d.data(), 4, 2),
+            std::string().find(std::string().data(), 4, 2));
+  ASSERT_EQ(e.find(e.data(), 4, 3),
+            std::string().find(std::string().data(), 4, 3));
+
   ASSERT_EQ(a.rfind(b), 0U);
   ASSERT_EQ(a.rfind(b, 1), 0U);
   ASSERT_EQ(a.rfind(c), 23U);
@@ -325,8 +355,8 @@
   ASSERT_EQ(g.rfind('o', 8), 8U);
   ASSERT_EQ(g.rfind('o', 7), 4U);
   ASSERT_EQ(g.rfind('o', 3), Piece::npos);
-  ASSERT_EQ(f.rfind('\0'), 3U);
-  ASSERT_EQ(f.rfind('\0', 12), 3U);
+  ASSERT_EQ(f.rfind(kNul), 3U);
+  ASSERT_EQ(f.rfind(kNul, 12), 3U);
   ASSERT_EQ(f.rfind('3'), 2U);
   ASSERT_EQ(f.rfind('5'), 5U);
   // empty string nonsense
@@ -335,6 +365,22 @@
   ASSERT_EQ(d.rfind('o', 4), Piece::npos);
   ASSERT_EQ(e.rfind('o', 7), Piece::npos);
 
+  ASSERT_EQ(a.rfind(b.data(), 1, 0), 1U);
+  ASSERT_EQ(a.rfind(c.data(), 22U, 0), 22U);
+  ASSERT_EQ(a.rfind(c.data(), 1U, 0), 1U);
+  ASSERT_EQ(a.rfind(c.data(), 0U, 0), 0U);
+  ASSERT_EQ(b.rfind(c.data(), 0U, 0), 0U);
+  ASSERT_EQ(a.rfind(d.data(), 12, 0), 12U);
+  ASSERT_EQ(a.rfind(e.data(), 17, 0), 17U);
+  ASSERT_EQ(d.rfind(b.data(), 4, 0), 0U);
+  ASSERT_EQ(e.rfind(b.data(), 7, 0), 0U);
+
+  // empty string nonsense
+  ASSERT_EQ(d.rfind(d.data(), 4), std::string().rfind(std::string()));
+  ASSERT_EQ(e.rfind(d.data(), 7), std::string().rfind(std::string()));
+  ASSERT_EQ(d.rfind(e.data(), 4), std::string().rfind(std::string()));
+  ASSERT_EQ(e.rfind(e.data(), 7), std::string().rfind(std::string()));
+
   TypeParam one_two_three_four(TestFixture::as_string("one,two:three;four"));
   TypeParam comma_colon(TestFixture::as_string(",:"));
   ASSERT_EQ(3U, Piece(one_two_three_four).find_first_of(comma_colon));
@@ -382,16 +428,16 @@
   Piece h(equals);
   ASSERT_EQ(h.find_first_not_of('='), Piece::npos);
   ASSERT_EQ(h.find_first_not_of('=', 3), Piece::npos);
-  ASSERT_EQ(h.find_first_not_of('\0'), 0U);
+  ASSERT_EQ(h.find_first_not_of(kNul), 0U);
   ASSERT_EQ(g.find_first_not_of('x'), 2U);
-  ASSERT_EQ(f.find_first_not_of('\0'), 0U);
-  ASSERT_EQ(f.find_first_not_of('\0', 3), 4U);
-  ASSERT_EQ(f.find_first_not_of('\0', 2), 2U);
+  ASSERT_EQ(f.find_first_not_of(kNul), 0U);
+  ASSERT_EQ(f.find_first_not_of(kNul, 3), 4U);
+  ASSERT_EQ(f.find_first_not_of(kNul, 2), 2U);
   // empty string nonsense
   ASSERT_EQ(d.find_first_not_of('x'), Piece::npos);
   ASSERT_EQ(e.find_first_not_of('x'), Piece::npos);
-  ASSERT_EQ(d.find_first_not_of('\0'), Piece::npos);
-  ASSERT_EQ(e.find_first_not_of('\0'), Piece::npos);
+  ASSERT_EQ(d.find_first_not_of(kNul), Piece::npos);
+  ASSERT_EQ(e.find_first_not_of(kNul), Piece::npos);
 
   //  Piece g("xx not found bb");
   TypeParam fifty_six(TestFixture::as_string("56"));
@@ -465,13 +511,14 @@
   // empty string nonsense
   ASSERT_EQ(d.find_last_not_of('x'), Piece::npos);
   ASSERT_EQ(e.find_last_not_of('x'), Piece::npos);
-  ASSERT_EQ(d.find_last_not_of('\0'), Piece::npos);
-  ASSERT_EQ(e.find_last_not_of('\0'), Piece::npos);
+  ASSERT_EQ(d.find_last_not_of(kNul), Piece::npos);
+  ASSERT_EQ(e.find_last_not_of(kNul), Piece::npos);
 
   ASSERT_EQ(a.substr(0, 3), b);
   ASSERT_EQ(a.substr(23), c);
   ASSERT_EQ(a.substr(23, 3), c);
   ASSERT_EQ(a.substr(23, 99), c);
+  ASSERT_EQ(a.substr(), a);
   ASSERT_EQ(a.substr(0), a);
   ASSERT_EQ(a.substr(3, 2), TestFixture::as_string("de"));
   ASSERT_EQ(d.substr(0, 99), e);
@@ -626,10 +673,7 @@
           nullptr,
           static_cast<typename BasicStringPiece<TypeParam>::size_type>(0)));
   ASSERT_EQ(empty, BasicStringPiece<TypeParam>());
-  ASSERT_EQ(str, BasicStringPiece<TypeParam>(str.begin(), str.end()));
-  ASSERT_EQ(empty, BasicStringPiece<TypeParam>(str.begin(), str.begin()));
   ASSERT_EQ(empty, BasicStringPiece<TypeParam>(empty));
-  ASSERT_EQ(empty, BasicStringPiece<TypeParam>(empty.begin(), empty.end()));
 }
 
 TEST(StringPieceTest, ConstexprCtor) {
@@ -677,6 +721,11 @@
 
   {
     StringPiece piece;
+    ASSERT_DEATH_IF_SUPPORTED(piece.copy(nullptr, 0, 1), "");
+  }
+
+  {
+    StringPiece piece;
     ASSERT_DEATH_IF_SUPPORTED(piece.substr(1), "");
   }
 }
@@ -738,6 +787,57 @@
   static_assert(piece.compare("gh") == -1, "");
   static_assert(piece.compare("ghi") == -1, "");
   static_assert(piece.compare("ghij") == -1, "");
+
+  static_assert(piece.compare(0, 0, "") == 0, "");
+  static_assert(piece.compare(0, 1, "d") == 0, "");
+  static_assert(piece.compare(0, 2, "de") == 0, "");
+  static_assert(piece.compare(0, 3, "def") == 0, "");
+  static_assert(piece.compare(1, 0, "") == 0, "");
+  static_assert(piece.compare(1, 1, "e") == 0, "");
+  static_assert(piece.compare(1, 2, "ef") == 0, "");
+  static_assert(piece.compare(1, 3, "ef") == 0, "");
+  static_assert(piece.compare(2, 0, "") == 0, "");
+  static_assert(piece.compare(2, 1, "f") == 0, "");
+  static_assert(piece.compare(2, 2, "f") == 0, "");
+  static_assert(piece.compare(2, 3, "f") == 0, "");
+  static_assert(piece.compare(3, 0, "") == 0, "");
+  static_assert(piece.compare(3, 1, "") == 0, "");
+  static_assert(piece.compare(3, 2, "") == 0, "");
+  static_assert(piece.compare(3, 3, "") == 0, "");
+
+  static_assert(piece.compare(0, 0, "def", 0) == 0, "");
+  static_assert(piece.compare(0, 1, "def", 1) == 0, "");
+  static_assert(piece.compare(0, 2, "def", 2) == 0, "");
+  static_assert(piece.compare(0, 3, "def", 3) == 0, "");
+  static_assert(piece.compare(1, 0, "ef", 0) == 0, "");
+  static_assert(piece.compare(1, 1, "ef", 1) == 0, "");
+  static_assert(piece.compare(1, 2, "ef", 2) == 0, "");
+  static_assert(piece.compare(1, 3, "ef", 2) == 0, "");
+  static_assert(piece.compare(2, 0, "f", 0) == 0, "");
+  static_assert(piece.compare(2, 1, "f", 1) == 0, "");
+  static_assert(piece.compare(2, 2, "f", 1) == 0, "");
+  static_assert(piece.compare(2, 3, "f", 1) == 0, "");
+  static_assert(piece.compare(3, 0, "", 0) == 0, "");
+  static_assert(piece.compare(3, 1, "", 0) == 0, "");
+  static_assert(piece.compare(3, 2, "", 0) == 0, "");
+  static_assert(piece.compare(3, 3, "", 0) == 0, "");
+
+  static_assert(piece.compare(0, 0, "def", 0, 0) == 0, "");
+  static_assert(piece.compare(0, 1, "def", 0, 1) == 0, "");
+  static_assert(piece.compare(0, 2, "def", 0, 2) == 0, "");
+  static_assert(piece.compare(0, 3, "def", 0, 3) == 0, "");
+  static_assert(piece.compare(1, 0, "def", 1, 0) == 0, "");
+  static_assert(piece.compare(1, 1, "def", 1, 1) == 0, "");
+  static_assert(piece.compare(1, 2, "def", 1, 2) == 0, "");
+  static_assert(piece.compare(1, 3, "def", 1, 3) == 0, "");
+  static_assert(piece.compare(2, 0, "def", 2, 0) == 0, "");
+  static_assert(piece.compare(2, 1, "def", 2, 1) == 0, "");
+  static_assert(piece.compare(2, 2, "def", 2, 2) == 0, "");
+  static_assert(piece.compare(2, 3, "def", 2, 3) == 0, "");
+  static_assert(piece.compare(3, 0, "def", 3, 0) == 0, "");
+  static_assert(piece.compare(3, 1, "def", 3, 1) == 0, "");
+  static_assert(piece.compare(3, 2, "def", 3, 2) == 0, "");
+  static_assert(piece.compare(3, 3, "def", 3, 3) == 0, "");
 }
 
 TEST(StringPieceTest, Substr) {
@@ -751,6 +851,7 @@
   static_assert(piece.substr(23) == "xyz", "");
   static_assert(piece.substr(23, 3) == "xyz", "");
   static_assert(piece.substr(23, 99) == "xyz", "");
+  static_assert(piece.substr() == piece, "");
   static_assert(piece.substr(0) == piece, "");
   static_assert(piece.substr(0, 99) == piece, "");
 }
diff --git a/base/strings/string_util.h b/base/strings/string_util.h
index f43a8ac..a1e5c59 100644
--- a/base/strings/string_util.h
+++ b/base/strings/string_util.h
@@ -84,6 +84,31 @@
 // This function is intended to be called from gurl_base::vswprintf.
 BASE_EXPORT bool IsWprintfFormatPortable(const wchar_t* format);
 
+// Simplified implementation of C++20's std::basic_string_view(It, End).
+// Reference: https://wg21.link/string.view.cons
+template <typename StringT, typename Iter>
+constexpr BasicStringPiece<StringT> MakeBasicStringPiece(Iter begin, Iter end) {
+  GURL_DCHECK_GE(end - begin, 0);
+  return {gurl_base::to_address(begin), end - begin};
+}
+
+// Explicit instantiations of MakeBasicStringPiece for the BasicStringPiece
+// aliases defined in base/strings/string_piece_forward.h
+template <typename Iter>
+constexpr StringPiece MakeStringPiece(Iter begin, Iter end) {
+  return MakeBasicStringPiece<std::string>(begin, end);
+}
+
+template <typename Iter>
+constexpr StringPiece16 MakeStringPiece16(Iter begin, Iter end) {
+  return MakeBasicStringPiece<string16>(begin, end);
+}
+
+template <typename Iter>
+constexpr WStringPiece MakeWStringPiece(Iter begin, Iter end) {
+  return MakeBasicStringPiece<std::wstring>(begin, end);
+}
+
 // ASCII-specific tolower.  The standard library's tolower is locale sensitive,
 // so we don't want to use it here.
 template <typename CharT,
@@ -291,9 +316,9 @@
 // Compare the lower-case form of the given string against the given
 // previously-lower-cased ASCII string (typically a constant).
 BASE_EXPORT bool LowerCaseEqualsASCII(StringPiece str,
-                                      StringPiece lowecase_ascii);
+                                      StringPiece lowercase_ascii);
 BASE_EXPORT bool LowerCaseEqualsASCII(StringPiece16 str,
-                                      StringPiece lowecase_ascii);
+                                      StringPiece lowercase_ascii);
 
 // Performs a case-sensitive string compare of the given 16-bit string against
 // the given 8-bit ASCII string (typically a constant). The behavior is
diff --git a/base/strings/string_util_internal.h b/base/strings/string_util_internal.h
index 006aeb0..ccc1367 100644
--- a/base/strings/string_util_internal.h
+++ b/base/strings/string_util_internal.h
@@ -228,7 +228,7 @@
 }
 
 template <bool (*Validator)(uint32_t)>
-inline static bool DoIsStringUTF8(StringPiece str) {
+inline bool DoIsStringUTF8(StringPiece str) {
   const char* src = str.data();
   int32_t src_len = static_cast<int32_t>(str.length());
   int32_t char_index = 0;
@@ -258,8 +258,8 @@
 // string piece gives additional flexibility for the caller (doesn't have to be
 // null terminated) so we choose the StringPiece route.
 template <typename Str>
-static inline bool DoLowerCaseEqualsASCII(BasicStringPiece<Str> str,
-                                          StringPiece lowercase_ascii) {
+inline bool DoLowerCaseEqualsASCII(BasicStringPiece<Str> str,
+                                   StringPiece lowercase_ascii) {
   return std::equal(
       str.begin(), str.end(), lowercase_ascii.begin(), lowercase_ascii.end(),
       [](auto lhs, auto rhs) { return ToLowerASCII(lhs) == rhs; });
diff --git a/base/strings/string_util_posix.h b/base/strings/string_util_posix.h
index 7d5a67b..91cf7a6 100644
--- a/base/strings/string_util_posix.h
+++ b/base/strings/string_util_posix.h
@@ -33,17 +33,6 @@
   return ::vswprintf(buffer, size, format, arguments);
 }
 
-// These mirror the APIs in string_util_win.h. Since gurl_base::StringPiece is
-// already the native string type on POSIX platforms these APIs are simple
-// no-ops.
-inline StringPiece AsCrossPlatformPiece(StringPiece str) {
-  return str;
-}
-
-inline StringPiece AsNativeStringPiece(StringPiece str) {
-  return str;
-}
-
 }  // namespace base
 
 #endif  // BASE_STRINGS_STRING_UTIL_POSIX_H_
diff --git a/base/strings/string_util_unittest.cc b/base/strings/string_util_unittest.cc
index f73b895..beb99e2 100644
--- a/base/strings/string_util_unittest.cc
+++ b/base/strings/string_util_unittest.cc
@@ -1310,6 +1310,47 @@
     EXPECT_EQ(i.portable, IsWprintfFormatPortable(i.input));
 }
 
+TEST(StringUtilTest, MakeBasicStringPieceTest) {
+  constexpr char kFoo[] = "Foo";
+  static_assert(MakeStringPiece(kFoo, kFoo + 3) == kFoo, "");
+  static_assert(MakeStringPiece(kFoo, kFoo + 3).data() == kFoo, "");
+  static_assert(MakeStringPiece(kFoo, kFoo + 3).size() == 3, "");
+  static_assert(MakeStringPiece(kFoo + 3, kFoo + 3).empty(), "");
+  static_assert(MakeStringPiece(kFoo + 4, kFoo + 4).empty(), "");
+
+  std::string foo = kFoo;
+  EXPECT_EQ(MakeStringPiece(foo.begin(), foo.end()), foo);
+  EXPECT_EQ(MakeStringPiece(foo.begin(), foo.end()).data(), foo.data());
+  EXPECT_EQ(MakeStringPiece(foo.begin(), foo.end()).size(), foo.size());
+  EXPECT_TRUE(MakeStringPiece(foo.end(), foo.end()).empty());
+
+  constexpr char16 kBar[] = STRING16_LITERAL("Bar");
+  static_assert(MakeStringPiece16(kBar, kBar + 3) == kBar, "");
+  static_assert(MakeStringPiece16(kBar, kBar + 3).data() == kBar, "");
+  static_assert(MakeStringPiece16(kBar, kBar + 3).size() == 3, "");
+  static_assert(MakeStringPiece16(kBar + 3, kBar + 3).empty(), "");
+  static_assert(MakeStringPiece16(kBar + 4, kBar + 4).empty(), "");
+
+  string16 bar = kBar;
+  EXPECT_EQ(MakeStringPiece16(bar.begin(), bar.end()), bar);
+  EXPECT_EQ(MakeStringPiece16(bar.begin(), bar.end()).data(), bar.data());
+  EXPECT_EQ(MakeStringPiece16(bar.begin(), bar.end()).size(), bar.size());
+  EXPECT_TRUE(MakeStringPiece16(bar.end(), bar.end()).empty());
+
+  constexpr wchar_t kBaz[] = L"Baz";
+  static_assert(MakeWStringPiece(kBaz, kBaz + 3) == kBaz, "");
+  static_assert(MakeWStringPiece(kBaz, kBaz + 3).data() == kBaz, "");
+  static_assert(MakeWStringPiece(kBaz, kBaz + 3).size() == 3, "");
+  static_assert(MakeWStringPiece(kBaz + 3, kBaz + 3).empty(), "");
+  static_assert(MakeWStringPiece(kBaz + 4, kBaz + 4).empty(), "");
+
+  std::wstring baz = kBaz;
+  EXPECT_EQ(MakeWStringPiece(baz.begin(), baz.end()), baz);
+  EXPECT_EQ(MakeWStringPiece(baz.begin(), baz.end()).data(), baz.data());
+  EXPECT_EQ(MakeWStringPiece(baz.begin(), baz.end()).size(), baz.size());
+  EXPECT_TRUE(MakeWStringPiece(baz.end(), baz.end()).empty());
+}
+
 TEST(StringUtilTest, RemoveChars) {
   const char kRemoveChars[] = "-/+*";
   std::string input = "A-+bc/d!*";
diff --git a/base/strings/string_util_win.h b/base/strings/string_util_win.h
index 51a6a2b..3ddbc92 100644
--- a/base/strings/string_util_win.h
+++ b/base/strings/string_util_win.h
@@ -107,18 +107,6 @@
   return string16(as_u16cstr(str.data()), str.size());
 }
 
-// Compatibility shim for cross-platform code that passes a StringPieceType to a
-// cross platform string utility function. Most of these functions are only
-// implemented for gurl_base::StringPiece and gurl_base::StringPiece16, which is why
-// gurl_base::WStringPieces need to be converted on API boundaries.
-inline StringPiece16 AsCrossPlatformPiece(WStringPiece str) {
-  return AsStringPiece16(str);
-}
-
-inline WStringPiece AsNativeStringPiece(StringPiece16 str) {
-  return AsWStringPiece(str);
-}
-
 // The following section contains overloads of the cross-platform APIs for
 // std::wstring and gurl_base::WStringPiece. These are only enabled if std::wstring
 // and gurl_base::string16 are distinct types, as otherwise this would result in an
@@ -167,7 +155,7 @@
 BASE_EXPORT bool ContainsOnlyChars(WStringPiece input, WStringPiece characters);
 
 BASE_EXPORT bool LowerCaseEqualsASCII(WStringPiece str,
-                                      StringPiece lowecase_ascii);
+                                      StringPiece lowercase_ascii);
 
 BASE_EXPORT bool EqualsASCII(StringPiece16 str, StringPiece ascii);
 
diff --git a/build_config/build_config.bzl b/build_config/build_config.bzl
index 9357584..117bc96 100644
--- a/build_config/build_config.bzl
+++ b/build_config/build_config.bzl
@@ -10,11 +10,6 @@
     ],
 })
 
-_strings_srcs = select({
-    "//build_config:windows_x86_64": [],
-    "//conditions:default": ["string16.cc"],
-})
-
 _strings_hdrs = select({
     "//build_config:windows_x86_64": ["string_util_win.h"],
     "//conditions:default": ["string_util_posix.h"],
@@ -35,7 +30,6 @@
 build_config = struct(
     default_copts = _default_copts,
     url_linkopts = _url_linkopts,
-    strings_srcs = _strings_srcs,
     strings_hdrs = _strings_hdrs,
     icuuc_deps = _icuuc_deps,
 )
diff --git a/copy.bara.sky b/copy.bara.sky
index fefc63d..2ed782d 100644
--- a/copy.bara.sky
+++ b/copy.bara.sky
@@ -13,10 +13,12 @@
         "AUTHORS",
         "LICENSE",
         "base/compiler_specific.h",
+        "base/containers/contains.h",
         "base/containers/checked_iterators.h",
         "base/containers/contiguous_iterator.h",
         "base/containers/span.h",
         "base/containers/util.h",
+        "base/i18n/uchar.h",
         "base/functional/*.h",
         "base/ranges/*.h",
         "base/macros.h",
@@ -82,10 +84,10 @@
     # Ugly hack.  In Chromium, ICU is built with UChar = uint16_t.  We can't
     # really do that with the system ICU, so we have to work this around with a
     # cast.
-    core.replace(
-        "src, src_len, output->data(),",
-        "(UChar*)src, src_len, (UChar*)output->data(),",
-    ),
+    #core.replace(
+    #    "src, src_len, output->data(),",
+    #    "(UChar*)src, src_len, (UChar*)output->data(),",
+    #),
 
     # Use system ICU.
     core.replace(
diff --git a/url/gurl.cc b/url/gurl.cc
index 68f3f8c..3b7d9f5 100644
--- a/url/gurl.cc
+++ b/url/gurl.cc
@@ -485,17 +485,23 @@
   if (has_host() || has_username() || has_password() || has_port())
     return false;
 
-  if (!gurl_base::StartsWith(path_piece(), allowed_path))
+  return IsAboutPath(path_piece(), allowed_path);
+}
+
+// static
+bool GURL::IsAboutPath(gurl_base::StringPiece actual_path,
+                       gurl_base::StringPiece allowed_path) {
+  if (!gurl_base::StartsWith(actual_path, allowed_path))
     return false;
 
-  if (path_piece().size() == allowed_path.size()) {
-    GURL_DCHECK_EQ(path_piece(), allowed_path);
+  if (actual_path.size() == allowed_path.size()) {
+    GURL_DCHECK_EQ(actual_path, allowed_path);
     return true;
   }
 
-  if ((path_piece().size() == allowed_path.size() + 1) &&
-      path_piece().back() == '/') {
-    GURL_DCHECK_EQ(path_piece(), allowed_path.as_string() + '/');
+  if ((actual_path.size() == allowed_path.size() + 1) &&
+      actual_path.back() == '/') {
+    GURL_DCHECK_EQ(actual_path, allowed_path.as_string() + '/');
     return true;
   }
 
diff --git a/url/gurl.h b/url/gurl.h
index aa33094..37e1c8d 100644
--- a/url/gurl.h
+++ b/url/gurl.h
@@ -434,6 +434,10 @@
   // See base/trace_event/memory_usage_estimator.h for more info.
   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);
+
  private:
   // Variant of the string parsing constructor that allows the caller to elect
   // retain trailing whitespace, if any, on the passed URL spec, but only if
diff --git a/url/gurl_unittest.cc b/url/gurl_unittest.cc
index f0f72cd..6295d98 100644
--- a/url/gurl_unittest.cc
+++ b/url/gurl_unittest.cc
@@ -9,6 +9,7 @@
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
+#include "url/gurl_abstract_tests.h"
 #include "url/origin.h"
 #include "url/url_canon.h"
 #include "url/url_test_utils.h"
@@ -883,44 +884,6 @@
   }
 }
 
-TEST(GURLTest, IsAboutBlank) {
-  const std::string kAboutBlankUrls[] = {"about:blank", "about:blank?foo",
-                                         "about:blank/#foo",
-                                         "about:blank?foo#foo"};
-  for (const auto& url : kAboutBlankUrls)
-    EXPECT_TRUE(GURL(url).IsAboutBlank()) << url;
-
-  const std::string kNotAboutBlankUrls[] = {
-      "http:blank",      "about:blan",          "about://blank",
-      "about:blank/foo", "about://:8000/blank", "about://foo:foo@/blank",
-      "foo@about:blank", "foo:bar@about:blank", "about:blank:8000",
-      "about:blANk"};
-  for (const auto& url : kNotAboutBlankUrls)
-    EXPECT_FALSE(GURL(url).IsAboutBlank()) << url;
-}
-
-TEST(GURLTest, IsAboutSrcdoc) {
-  const std::string kAboutSrcdocUrls[] = {
-      "about:srcdoc", "about:srcdoc/", "about:srcdoc?foo", "about:srcdoc/#foo",
-      "about:srcdoc?foo#foo"};
-  for (const auto& url : kAboutSrcdocUrls)
-    EXPECT_TRUE(GURL(url).IsAboutSrcdoc()) << url;
-
-  const std::string kNotAboutSrcdocUrls[] = {"http:srcdoc",
-                                             "about:srcdo",
-                                             "about://srcdoc",
-                                             "about://srcdoc\\",
-                                             "about:srcdoc/foo",
-                                             "about://:8000/srcdoc",
-                                             "about://foo:foo@/srcdoc",
-                                             "foo@about:srcdoc",
-                                             "foo:bar@about:srcdoc",
-                                             "about:srcdoc:8000",
-                                             "about:srCDOc"};
-  for (const auto& url : kNotAboutSrcdocUrls)
-    EXPECT_FALSE(GURL(url).IsAboutSrcdoc()) << url;
-}
-
 TEST(GURLTest, EqualsIgnoringRef) {
   const struct {
     const char* url_a;
@@ -1029,4 +992,18 @@
   EXPECT_FALSE(default_port_origin.IsSameOriginWith(resolved_origin));
 }
 
+class GURLTestTraits {
+ public:
+  using UrlType = GURL;
+
+  static UrlType CreateUrlFromString(gurl_base::StringPiece s) { return GURL(s); }
+  static bool IsAboutBlank(const UrlType& url) { return url.IsAboutBlank(); }
+  static bool IsAboutSrcdoc(const UrlType& url) { return url.IsAboutSrcdoc(); }
+
+  // Only static members.
+  GURLTestTraits() = delete;
+};
+
+INSTANTIATE_TYPED_TEST_SUITE_P(GURL, AbstractUrlTest, GURLTestTraits);
+
 }  // namespace url
diff --git a/url/origin.cc b/url/origin.cc
index d04e557..ca37428 100644
--- a/url/origin.cc
+++ b/url/origin.cc
@@ -11,9 +11,9 @@
 
 #include "base/base64.h"
 #include "polyfills/base/check_op.h"
+#include "base/containers/contains.h"
 #include "base/containers/span.h"
 #include "base/pickle.h"
-#include "base/stl_util.h"
 #include "base/strings/strcat.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
diff --git a/url/origin_unittest.cc b/url/origin_unittest.cc
index 7793b9a..2f342c5 100644
--- a/url/origin_unittest.cc
+++ b/url/origin_unittest.cc
@@ -10,32 +10,11 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
+#include "url/origin_abstract_tests.h"
 #include "url/url_util.h"
 
 namespace url {
 
-void ExpectParsedUrlsEqual(const GURL& a, const GURL& b) {
-  EXPECT_EQ(a, b);
-  const Parsed& a_parsed = a.parsed_for_possibly_invalid_spec();
-  const Parsed& b_parsed = b.parsed_for_possibly_invalid_spec();
-  EXPECT_EQ(a_parsed.scheme.begin, b_parsed.scheme.begin);
-  EXPECT_EQ(a_parsed.scheme.len, b_parsed.scheme.len);
-  EXPECT_EQ(a_parsed.username.begin, b_parsed.username.begin);
-  EXPECT_EQ(a_parsed.username.len, b_parsed.username.len);
-  EXPECT_EQ(a_parsed.password.begin, b_parsed.password.begin);
-  EXPECT_EQ(a_parsed.password.len, b_parsed.password.len);
-  EXPECT_EQ(a_parsed.host.begin, b_parsed.host.begin);
-  EXPECT_EQ(a_parsed.host.len, b_parsed.host.len);
-  EXPECT_EQ(a_parsed.port.begin, b_parsed.port.begin);
-  EXPECT_EQ(a_parsed.port.len, b_parsed.port.len);
-  EXPECT_EQ(a_parsed.path.begin, b_parsed.path.begin);
-  EXPECT_EQ(a_parsed.path.len, b_parsed.path.len);
-  EXPECT_EQ(a_parsed.query.begin, b_parsed.query.begin);
-  EXPECT_EQ(a_parsed.query.len, b_parsed.query.len);
-  EXPECT_EQ(a_parsed.ref.begin, b_parsed.ref.begin);
-  EXPECT_EQ(a_parsed.ref.len, b_parsed.ref.len);
-}
-
 class OriginTest : public ::testing::Test {
  public:
   void SetUp() override {
@@ -197,68 +176,6 @@
   EXPECT_EQ(opaque_b, url::Origin::Resolve(GURL("about:srcdoc"), opaque_b));
   EXPECT_EQ(opaque_b,
             url::Origin::Resolve(GURL("about:blank?hello#whee"), opaque_b));
-
-  const char* const urls[] = {
-      "data:text/html,Hello!",
-      "javascript:alert(1)",
-      "about:blank",
-      "file://example.com:443/etc/passwd",
-      "unknown-scheme:foo",
-      "unknown-scheme://bar",
-      "http",
-      "http:",
-      "http:/",
-      "http://",
-      "http://:",
-      "http://:1",
-      "yay",
-      "http::///invalid.example.com/",
-      "blob:null/foo",                   // blob:null (actually a valid URL)
-      "blob:data:foo",                   // blob + data (which is nonstandard)
-      "blob:about://blank/",             // blob + about (which is nonstandard)
-      "blob:about:blank/",               // blob + about (which is nonstandard)
-      "filesystem:http://example.com/",  // Invalid (missing /type/)
-      "filesystem:local-but-nonstandard:baz./type/",  // fs requires standard
-      "filesystem:local-but-nonstandard://hostname/type/",
-      "filesystem:unknown-scheme://hostname/type/",
-      "local-but-nonstandar:foo",  // Prefix of registered scheme.
-      "but-nonstandard:foo",       // Suffix of registered scheme.
-      "local-and-standard:",       // Standard scheme needs a hostname.
-      "standard-but-noaccess:",    // Standard scheme needs a hostname.
-      "blob:blob:http://www.example.com/guid-goes-here",  // Double blob.
-  };
-
-  for (auto* test_url : urls) {
-    SCOPED_TRACE(test_url);
-    GURL url(test_url);
-    const url::Origin opaque_origin;
-
-    // Opaque origins returned by Origin::Create().
-    {
-      Origin origin = Origin::Create(url);
-      EXPECT_EQ("", origin.scheme());
-      EXPECT_EQ("", origin.host());
-      EXPECT_EQ(0, origin.port());
-      EXPECT_TRUE(origin.opaque());
-      // An origin is always same-origin with itself.
-      EXPECT_EQ(origin, origin);
-      EXPECT_NE(origin, url::Origin());
-      EXPECT_EQ(SchemeHostPort(), origin.GetTupleOrPrecursorTupleIfOpaque());
-      // A copy of |origin| should be same-origin as well.
-      Origin origin_copy = origin;
-      EXPECT_EQ("", origin_copy.scheme());
-      EXPECT_EQ("", origin_copy.host());
-      EXPECT_EQ(0, origin_copy.port());
-      EXPECT_TRUE(origin_copy.opaque());
-      EXPECT_EQ(origin, origin_copy);
-      // And it should always be cross-origin to another opaque Origin.
-      EXPECT_NE(origin, opaque_origin);
-      // Re-creating from the URL should also be cross-origin.
-      EXPECT_NE(origin, Origin::Create(url));
-
-      ExpectParsedUrlsEqual(GURL(origin.Serialize()), origin.GetURL());
-    }
-  }
 }
 
 TEST_F(OriginTest, ConstructFromTuple) {
@@ -286,132 +203,6 @@
   }
 }
 
-TEST_F(OriginTest, ConstructFromGURL) {
-  Origin different_origin =
-      Origin::Create(GURL("https://not-in-the-list.test/"));
-
-  struct TestCases {
-    const char* const url;
-    const char* const expected_scheme;
-    const char* const expected_host;
-    const uint16_t expected_port;
-  } cases[] = {
-      // IP Addresses
-      {"http://192.168.9.1/", "http", "192.168.9.1", 80},
-      {"http://[2001:db8::1]/", "http", "[2001:db8::1]", 80},
-      {"http://1/", "http", "0.0.0.1", 80},
-      {"http://1:1/", "http", "0.0.0.1", 1},
-      {"http://3232237825/", "http", "192.168.9.1", 80},
-
-      // Punycode
-      {"http://☃.net/", "http", "xn--n3h.net", 80},
-      {"blob:http://☃.net/", "http", "xn--n3h.net", 80},
-
-      // Generic URLs
-      {"http://example.com/", "http", "example.com", 80},
-      {"http://example.com:123/", "http", "example.com", 123},
-      {"https://example.com/", "https", "example.com", 443},
-      {"https://example.com:123/", "https", "example.com", 123},
-      {"http://user:pass@example.com/", "http", "example.com", 80},
-      {"http://example.com:123/?query", "http", "example.com", 123},
-      {"https://example.com/#1234", "https", "example.com", 443},
-      {"https://u:p@example.com:123/?query#1234", "https", "example.com", 123},
-
-      // Registered URLs
-      {"ftp://example.com/", "ftp", "example.com", 21},
-      {"ws://example.com/", "ws", "example.com", 80},
-      {"wss://example.com/", "wss", "example.com", 443},
-      {"wss://user:pass@example.com/", "wss", "example.com", 443},
-
-      // Scheme (registered in SetUp()) that's both local and standard.
-      // TODO: Is it really appropriate to do network-host canonicalization of
-      // schemes without ports?
-      {"local-and-standard:20", "local-and-standard", "0.0.0.20", 0},
-      {"local-and-standard:20.", "local-and-standard", "0.0.0.20", 0},
-      {"local-and-standard:↑↑↓↓←→←→ba.↑↑↓↓←→←→ba.0.bg", "local-and-standard",
-       "xn--ba-rzuadaibfa.xn--ba-rzuadaibfa.0.bg", 0},
-      {"local-and-standard:foo", "local-and-standard", "foo", 0},
-      {"local-and-standard://bar:20", "local-and-standard", "bar", 0},
-      {"local-and-standard:baz.", "local-and-standard", "baz.", 0},
-      {"local-and-standard:baz..", "local-and-standard", "baz..", 0},
-      {"local-and-standard:baz..bar", "local-and-standard", "baz..bar", 0},
-      {"local-and-standard:baz...", "local-and-standard", "baz...", 0},
-
-      // Scheme (registered in SetUp()) that's local but nonstandard. These
-      // always have empty hostnames, but are allowed to be url::Origins.
-      {"local-but-nonstandard:", "local-but-nonstandard", "", 0},
-      {"local-but-nonstandard:foo", "local-but-nonstandard", "", 0},
-      {"local-but-nonstandard://bar", "local-but-nonstandard", "", 0},
-      {"also-local-but-nonstandard://bar", "also-local-but-nonstandard", "", 0},
-
-      // Scheme (registered in SetUp()) that's standard but marked as noaccess.
-      // url::Origin doesn't currently take the noaccess property into account,
-      // so these aren't expected to result in opaque origins.
-      {"standard-but-noaccess:foo", "standard-but-noaccess", "foo", 0},
-      {"standard-but-noaccess://bar", "standard-but-noaccess", "bar", 0},
-
-      // file: URLs
-      {"file:///etc/passwd", "file", "", 0},
-      {"file://example.com/etc/passwd", "file", "example.com", 0},
-
-      // Filesystem:
-      {"filesystem:http://example.com/type/", "http", "example.com", 80},
-      {"filesystem:http://example.com:123/type/", "http", "example.com", 123},
-      {"filesystem:https://example.com/type/", "https", "example.com", 443},
-      {"filesystem:https://example.com:123/type/", "https", "example.com", 123},
-      {"filesystem:local-and-standard:baz./type/", "local-and-standard", "baz.",
-       0},
-
-      // Blob:
-      {"blob:http://example.com/guid-goes-here", "http", "example.com", 80},
-      {"blob:http://example.com:123/guid-goes-here", "http", "example.com",
-       123},
-      {"blob:https://example.com/guid-goes-here", "https", "example.com", 443},
-      {"blob:http://u:p@example.com/guid-goes-here", "http", "example.com", 80},
-  };
-
-  for (const auto& test_case : cases) {
-    SCOPED_TRACE(test_case.url);
-    GURL url(test_case.url);
-    EXPECT_TRUE(url.is_valid());
-    Origin origin = Origin::Create(url);
-    EXPECT_EQ(test_case.expected_scheme, origin.scheme());
-    EXPECT_EQ(test_case.expected_host, origin.host());
-    EXPECT_EQ(test_case.expected_port, origin.port());
-    EXPECT_FALSE(origin.opaque());
-    EXPECT_EQ(origin, origin);
-    EXPECT_NE(different_origin, origin);
-    EXPECT_NE(origin, different_origin);
-    EXPECT_EQ(origin, Origin::Resolve(GURL("about:blank"), origin));
-    EXPECT_EQ(origin, Origin::Resolve(GURL("about:blank?bar#foo"), origin));
-
-    ExpectParsedUrlsEqual(GURL(origin.Serialize()), origin.GetURL());
-
-    url::Origin derived_opaque =
-        Origin::Resolve(GURL("about:blank?bar#foo"), origin)
-            .DeriveNewOpaqueOrigin();
-    EXPECT_TRUE(derived_opaque.opaque());
-    EXPECT_NE(origin, derived_opaque);
-    EXPECT_TRUE(derived_opaque.GetTupleOrPrecursorTupleIfOpaque().IsValid());
-    EXPECT_EQ(origin.GetTupleOrPrecursorTupleIfOpaque(),
-              derived_opaque.GetTupleOrPrecursorTupleIfOpaque());
-    EXPECT_EQ(derived_opaque, derived_opaque);
-
-    url::Origin derived_opaque_via_data_url =
-        Origin::Resolve(GURL("data:text/html,baz"), origin);
-    EXPECT_TRUE(derived_opaque_via_data_url.opaque());
-    EXPECT_NE(origin, derived_opaque_via_data_url);
-    EXPECT_TRUE(derived_opaque_via_data_url.GetTupleOrPrecursorTupleIfOpaque()
-                    .IsValid());
-    EXPECT_EQ(origin.GetTupleOrPrecursorTupleIfOpaque(),
-              derived_opaque_via_data_url.GetTupleOrPrecursorTupleIfOpaque());
-    EXPECT_NE(derived_opaque, derived_opaque_via_data_url);
-    EXPECT_NE(derived_opaque_via_data_url, derived_opaque);
-    EXPECT_NE(derived_opaque.DeriveNewOpaqueOrigin(), derived_opaque);
-    EXPECT_EQ(derived_opaque_via_data_url, derived_opaque_via_data_url);
-  }
-}
-
 TEST_F(OriginTest, Serialization) {
   struct TestCases {
     const char* const url;
@@ -666,20 +457,6 @@
   EXPECT_STREQ("https://foo.com", origin1_debug_alias);
 }
 
-TEST_F(OriginTest, NonStandardScheme) {
-  Origin origin = Origin::Create(GURL("cow://"));
-  EXPECT_TRUE(origin.opaque());
-}
-
-TEST_F(OriginTest, NonStandardSchemeWithAndroidWebViewHack) {
-  EnableNonStandardSchemesForAndroidWebView();
-  Origin origin = Origin::Create(GURL("cow://"));
-  EXPECT_FALSE(origin.opaque());
-  EXPECT_EQ("cow", origin.scheme());
-  EXPECT_EQ("", origin.host());
-  EXPECT_EQ(0, origin.port());
-}
-
 TEST_F(OriginTest, CanBeDerivedFrom) {
   AddStandardScheme("new-standard", SchemeType::SCHEME_WITH_HOST);
   Origin opaque_unique_origin = Origin();
@@ -818,10 +595,10 @@
       {"standard-but-noaccess://a.com/foo", &regular_origin, false},
       {"standard-but-noaccess://a.com/foo", &opaque_precursor_origin, false},
       {"standard-but-noaccess://a.com/foo", &opaque_unique_origin, true},
-      {"standard-but-noaccess://a.com/foo", &no_access_origin, false},
+      {"standard-but-noaccess://a.com/foo", &no_access_origin, true},
       {"standard-but-noaccess://a.com/foo", &no_access_opaque_precursor_origin,
-       false},
-      {"standard-but-noaccess://b.com/foo", &no_access_origin, false},
+       true},
+      {"standard-but-noaccess://b.com/foo", &no_access_origin, true},
       {"standard-but-noaccess://b.com/foo", &no_access_opaque_precursor_origin,
        true},
 
@@ -967,4 +744,8 @@
   EXPECT_EQ(opaque.GetDebugString(), deserialized.value().GetDebugString());
 }
 
+INSTANTIATE_TYPED_TEST_SUITE_P(UrlOrigin,
+                               AbstractOriginTest,
+                               UrlOriginTestTraits);
+
 }  // namespace url
diff --git a/url/scheme_host_port.cc b/url/scheme_host_port.cc
index 265761b..21b473d 100644
--- a/url/scheme_host_port.cc
+++ b/url/scheme_host_port.cc
@@ -10,9 +10,9 @@
 #include <tuple>
 
 #include "polyfills/base/check_op.h"
+#include "base/containers/contains.h"
 #include "polyfills/base/notreached.h"
 #include "base/numerics/safe_conversions.h"
-#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "url/gurl.h"
 #include "url/third_party/mozilla/url_parse.h"
@@ -49,6 +49,10 @@
   return host == canon_host;
 }
 
+// Note: When changing IsValidInput, consider also updating
+// 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,
                   uint16_t port,
@@ -57,15 +61,21 @@
   if (scheme.empty())
     return false;
 
+  // about:blank and other no-access schemes translate into an opaque origin.
+  // This helps consistency with ShouldTreatAsOpaqueOrigin in Blink.
+  if (gurl_base::Contains(GetNoAccessSchemes(), scheme))
+    return false;
+
   SchemeType scheme_type = SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION;
   bool is_standard = GetStandardSchemeType(
       scheme.data(),
       Component(0, gurl_base::checked_cast<int>(scheme.length())),
       &scheme_type);
   if (!is_standard) {
-    // To be consistent with blink, local non-standard schemes are currently
-    // allowed to be tuple origins. Nonstandard schemes don't have hostnames,
-    // so their tuple is just ("protocol", "", 0).
+    // To be consistent with ShouldTreatAsOpaqueOrigin in Blink, local
+    // non-standard schemes are currently allowed to be tuple origins.
+    // Nonstandard schemes don't have hostnames, so their tuple is just
+    // ("protocol", "", 0).
     //
     // TODO: Migrate "content:" and "externalfile:" to be standard schemes, and
     // remove this local scheme exception.
diff --git a/url/scheme_host_port_unittest.cc b/url/scheme_host_port_unittest.cc
index a4cbdb3..a1f415d 100644
--- a/url/scheme_host_port_unittest.cc
+++ b/url/scheme_host_port_unittest.cc
@@ -55,8 +55,15 @@
   EXPECT_EQ(invalid, invalid);
 
   const char* urls[] = {
-      "data:text/html,Hello!", "javascript:alert(1)",
-      "file://example.com:443/etc/passwd",
+      // about:, data:, javascript: and other no-access schemes translate into
+      // an invalid SchemeHostPort
+      "about:blank", "about:blank#ref", "about:blank?query=123", "about:srcdoc",
+      "about:srcdoc#ref", "about:srcdoc?query=123", "data:text/html,Hello!",
+      "javascript:alert(1)",
+
+      // GURLs where GURL::is_valid returns false translate into an invalid
+      // SchemeHostPort.
+      "file://example.com:443/etc/passwd", "#!^%!$!&*",
 
       // These schemes do not follow the generic URL syntax, so make sure we
       // treat them as invalid (scheme, host, port) tuples (even though such
diff --git a/url/url_canon_icu.cc b/url/url_canon_icu.cc
index 614e338..93c9247 100644
--- a/url/url_canon_icu.cc
+++ b/url/url_canon_icu.cc
@@ -9,6 +9,7 @@
 #include <string.h>
 
 #include "polyfills/base/check.h"
+#include "base/i18n/uchar.h"
 #include <unicode/ucnv.h>
 #include <unicode/ucnv_cb.h>
 #include <unicode/utypes.h>
@@ -94,8 +95,9 @@
   do {
     UErrorCode err = U_ZERO_ERROR;
     char* dest = &output->data()[begin_offset];
-    int required_capacity = ucnv_fromUChars(converter_, dest, dest_capacity,
-                                            input, input_len, &err);
+    int required_capacity =
+        ucnv_fromUChars(converter_, dest, dest_capacity,
+                        gurl_base::i18n::ToUCharPtr(input), input_len, &err);
     if (err != U_BUFFER_OVERFLOW_ERROR) {
       output->set_length(begin_offset + required_capacity);
       return;
diff --git a/url/url_canon_path.cc b/url/url_canon_path.cc
index 22002b5..da32bd8 100644
--- a/url/url_canon_path.cc
+++ b/url/url_canon_path.cc
@@ -5,6 +5,7 @@
 #include <limits.h>
 
 #include "polyfills/base/check.h"
+#include "polyfills/base/check_op.h"
 #include "url/url_canon.h"
 #include "url/url_canon_internal.h"
 #include "url/url_parse_internal.h"
@@ -261,6 +262,7 @@
 
   bool success = true;
   for (int i = path.begin; i < end; i++) {
+    GURL_DCHECK_LT(last_invalid_percent_index, output->length());
     UCHAR uch = static_cast<UCHAR>(spec[i]);
     if (sizeof(CHAR) > 1 && uch >= 0x80) {
       // We only need to test wide input for having non-ASCII characters. For
@@ -303,6 +305,9 @@
                 break;
               case DIRECTORY_UP:
                 BackUpToPreviousSlash(path_begin_in_output, output);
+                if (last_invalid_percent_index >= output->length()) {
+                  last_invalid_percent_index = INT_MIN;
+                }
                 i += dotlen + consumed_len - 1;
                 break;
             }
diff --git a/url/url_canon_unittest.cc b/url/url_canon_unittest.cc
index 55ef089..e2469ca 100644
--- a/url/url_canon_unittest.cc
+++ b/url/url_canon_unittest.cc
@@ -1423,6 +1423,9 @@
       {"ws:)W\x1eW\xef\xb9\xaa"
        "81:80/",
        "ws://%29w%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/%3EA", true},
   };
 
   for (size_t i = 0; i < gurl_base::size(cases); i++) {
diff --git a/url/url_idna_icu.cc b/url/url_idna_icu.cc
index 18e1895..d9256a2 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/i18n/uchar.h"
 #include "base/no_destructor.h"
 #include <unicode/uidna.h>
 #include <unicode/utypes.h>
@@ -90,8 +91,10 @@
   while (true) {
     UErrorCode err = U_ZERO_ERROR;
     UIDNAInfo info = UIDNA_INFO_INITIALIZER;
-    int output_length = uidna_nameToASCII(uidna, (UChar*)src, src_len, (UChar*)output->data(),
-                                          output->capacity(), &info, &err);
+    int output_length =
+        uidna_nameToASCII(uidna, gurl_base::i18n::ToUCharPtr(src), src_len,
+                          gurl_base::i18n::ToUCharPtr(output->data()),
+                          output->capacity(), &info, &err);
     if (U_SUCCESS(err) && info.errors == 0) {
       output->set_length(output_length);
       return true;