diff --git a/AUTHORS b/AUTHORS
index 364df55..5941416 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -47,7 +47,9 @@
 Alec Petridis <alecthechop@gmail.com>
 Aleksandar Stojiljkovic <aleksandar.stojiljkovic@intel.com>
 Aleksei Gurianov <gurianov@gmail.com>
+Aleksey Khoroshilov <akhoroshilov@brave.com>
 Alesandro Ortiz <alesandro@alesandroortiz.com>
+Alessandro Astone <ales.astone@gmail.com>
 Alex Chronopoulos <achronop@gmail.com>
 Alex Gabriel <minilogo@gmail.com>
 Alex Gartrell <agartrell@cmu.edu>
@@ -90,6 +92,7 @@
 Ancil George <ancilgeorge@samsung.com>
 Andra Paraschiv <andra.paraschiv@intel.com>
 Andras Tokodi <a.tokodi@eyeo.com>
+Andreas Nazlidis <andreas221b@gmail.com>
 Andreas Papacharalampous <andreas@apap04.com>
 Andrei Borza <andrei.borza@gmail.com>
 Andrei Parvu <andrei.prv@gmail.com>
@@ -113,11 +116,13 @@
 Anshul Jain <anshul.jain@samsung.com>
 Anssi Hannula <anssi.hannula@iki.fi>
 Anthony Halliday <anth.halliday12@gmail.com>
-Anton Bershanskiy <bershanskiy@pm.me>
+Anton Bershanskiy <8knots@protonmail.com>
 Anton Obzhirov <a.obzhirov@samsung.com>
 Antonin Hildebrand <antonin.hildebrand@gmail.com>
 Antonio Gomes <a1.gomes@sisa.samsung.com>
 Anuj Kumar Sharma <anujk.sharma@samsung.com>
+Ao Sun <ntusunao@gmail.com>
+Ao Wang <wangao.james@bytedance.com>
 Arjun Karthik <arjunkar@amazon.com>
 Arman Ghotb <armanghotb@gmail.com>
 Armin Burgmeier <aburgmeier@bloomberg.net>
@@ -167,6 +172,7 @@
 Brendan Long <self@brendanlong.com>
 Brendon Tiszka <btiszka@gmail.com>
 Brian Clifton <clifton@brave.com>
+Brian Dunn <brian@theophil.us>
 Brian G. Merrell <bgmerrell@gmail.com>
 Brian Konzman, SJ <b.g.konzman@gmail.com>
 Brian Luft <brian@electroly.com>
@@ -245,6 +251,7 @@
 Daniel Carvalho Liedke <dliedke@gmail.com>
 Daniel Charles <daniel.charles@intel.com>
 Daniel Imms <daniimms@amazon.com>
+Daniel Izquierdo <daniel.izquierdo@gmail.com>
 Daniel Johnson <danielj41@gmail.com>
 Daniel Lockyer <thisisdaniellockyer@gmail.com>
 Daniel Nishi <dhnishi@gmail.com>
@@ -346,6 +353,7 @@
 Evgeny Agafonchikov <evgeny.agafonchikov@akvelon.com>
 Fabian Henneke <fabian.henneke@gmail.com>
 Fabien Tassin <fta@sofaraway.org>
+Feifei Wang <alexswang@tencent.com>
 Felipe Erias Morandeira <felipeerias@gmail.com>
 Felix H. Dahlke <fhd@ubercode.de>
 Felix Weilbach <feweilbach@gmail.com>
@@ -413,6 +421,7 @@
 Hautio Kari <khautio@gmail.com>
 Heejin R. Chung <heejin.r.chung@samsung.com>
 Heeyoun Lee <heeyoun.lee@samsung.com>
+Henrique de Carvalho <decarv.henrique@gmail.com>
 Henrique Limas <henrique.ramos.limas@gmail.com>
 Himanshu Joshi <h.joshi@samsung.com>
 Hiroyuki Matsuda <gsittyz@gmail.com>
@@ -572,6 +581,7 @@
 Joone Hur <joone.hur@intel.com>
 Joonghun Park <pjh0718@gmail.com>
 Jorge Villatoro <jorge@tomatocannon.com>
+Jorrit Jongma <jorrit@jongma.org>
 Joseph Gentle <josephg@gmail.com>
 Joseph Lolak <joseph.lolak@samsung.com>
 Josh Triplett <josh.triplett@intel.com>
@@ -599,6 +609,7 @@
 Jungkee Song <jungkee.song@samsung.com>
 Junmin Zhu <junmin.zhu@intel.com>
 Junsong Li <ljs.darkfish@gmail.com>
+Jun Wang <wangjuna@uniontech.com>
 Jun Zeng <hjunzeng6@gmail.com>
 Justin Okamoto <justmoto@amazon.com>
 Justin Ribeiro <justin@justinribeiro.com>
@@ -708,6 +719,7 @@
 Luke Zarko <lukezarko@gmail.com>
 Luoxi Pan <l.panpax@gmail.com>
 Lu Yahan <yahan@iscas.ac.cn>
+Ma Aiguo <maaiguo@uniontech.com>
 Maarten Lankhorst <m.b.lankhorst@gmail.com>
 Maciej Pawlowski <m.pawlowski@eyeo.com>
 Magnus Danielsson <fuzzac@gmail.com>
@@ -813,6 +825,7 @@
 Mohammed Wajahat Ali Siddiqui <wajahat.s@samsung.com>
 Mohan Reddy <mohan.reddy@samsung.com>
 Mohit Bhalla <bhallam@amazon.com>
+Moiseanu Rares-Marian <moiseanurares@gmail.com>
 Momoka Yamamoto <momoka.my6@gmail.com>
 Momoko Hattori <momohatt10@gmail.com>
 Mostafa Sedaghat joo <mostafa.sedaghat@gmail.com>
@@ -880,6 +893,7 @@
 Pavel Ivanov <paivanof@gmail.com>
 Pawel Forysiuk <p.forysiuk@samsung.com>
 Paweł Hajdan jr <phajdan.jr@gmail.com>
+Paweł Stanek <pawel@gener8ads.com>
 Piotr Zarycki <piotr.zarycki@gmail.com>
 Payal Pandey <payal.pandey@samsung.com>
 Pedro Tôrres <t0rr3s.p3dr0@gmail.com>
@@ -887,6 +901,7 @@
 Peng Jiang <leiyi.jp@gmail.com>
 Peng Xinchao <pxinchao@gmail.com>
 Peng-Yu Chen <pengyu@libstarrify.so>
+Pei Wang <wangpei@uniontech.com>
 Peter Bright <drpizza@quiscalusmexicanus.org>
 Peter Brophy <pbrophy@adobe.com>
 Peter Collingbourne <peter@pcc.me.uk>
@@ -942,6 +957,7 @@
 Ravi Phaneendra Kasibhatla <r.kasibhatla@samsung.com>
 Ravi Phaneendra Kasibhatla <ravi.kasibhatla@motorola.com>
 Raviraj Sitaram <raviraj.p.sitaram@intel.com>
+Rebecca Chang Swee Fun <rebecca.chang@starfivetech.com>
 Reda Tawfik <redatawfik@noogler.google.com>
 Réda Housni Alaoui <alaoui.rda@gmail.com>
 Refael Ackermann <refack@gmail.com>
@@ -995,6 +1011,7 @@
 Samuel Attard <samuel.r.attard@gmail.com>
 Sanggi Hong <sanggi.hong11@gmail.com>
 Sanghee Lee <sanghee.lee1992@gmail.com>
+Sangheon Kim <sangheon77.kim@samsung.com>
 Sanghyun Park <sh919.park@samsung.com>
 Sanghyup Lee <sh53.lee@samsung.com>
 Sangjoon Je <htamop@gmail.com>
@@ -1041,6 +1058,7 @@
 ShankarGanesh K <blr.bmlab@gmail.com>
 Shanmuga Pandi M <shanmuga.m@samsung.com>
 Shaobo Yan <shaobo.yan@intel.com>
+Shaotang Zhu <zhushaotang@uniontech.com>
 Shashi Kumar <sk.kumar@samsung.com>
 Shawn Anastasio <shawnanastasio@gmail.com>
 Shelley Vohr <shelley.vohr@gmail.com>
@@ -1064,6 +1082,7 @@
 Shubham Agrawal <shubag@amazon.com>
 Shubham Gupta <shubh.gupta@samsung.com>
 Siba Samal <siba.samal@samsung.com>
+Sida Zhu <zhusida@bytedance.com>
 Siddharth Bagai <b.siddharth@samsung.com>
 Siddharth Shankar <funkysidd@gmail.com>
 Simeon Kuran <simeon.kuran@gmail.com>
@@ -1151,6 +1170,7 @@
 Tibor Dusnoki <tdusnoki@inf.u-szeged.hu>
 Tim Ansell <mithro@mithis.com>
 Tim Niederhausen <tim@rnc-ag.de>
+Tim Steiner <twsteiner@gmail.com>
 Timo Gurr <timo.gurr@gmail.com>
 Timo Reimann <ttr314@googlemail.com>
 Timo Witte <timo.witte@gmail.com>
@@ -1200,6 +1220,7 @@
 Waihung Fu <fufranci@amazon.com>
 wafuwafu13 <mariobaske@i.softbank.jp>
 Wojciech Bielawski <wojciech.bielawski@gmail.com>
+Wang Weiwei <wangww@dingdao.com>
 Wanming Lin <wanming.lin@intel.com>
 Wei Li <wei.c.li@intel.com>
 Wen Fan <fanwen1@huawei.com>
@@ -1214,6 +1235,7 @@
 Will Watts <willwatts.ww@googlemail.com>
 William Xie <william.xie@intel.com>
 Winston Chen <winston.c1@samsung.com>
+Xialei Qin <qinxialei@uniontech.com>
 Xiang Long <xiang.long@intel.com>
 XiangYang <yangxiang12@huawei.com>
 Xiangze Zhang <xiangze.zhang@intel.com>
@@ -1223,6 +1245,7 @@
 Xiaoshu Zhang <xiaoshu@amazon.com>
 Xiaoyin Liu <xiaoyin.l@outlook.com>
 Xinchao He <hexinchao@gmail.com>
+Xinchao Tian <tianxinchao@360.cn>
 Xing Zhang <xzhang@adobe.com>
 Xinghua Cao <xinghua.cao@intel.com>
 Xu Samuel <samuel.xu@intel.com>
@@ -1236,6 +1259,7 @@
 Yael Aharon <yael.aharon@intel.com>
 Yan Wang <yan0422.wang@samsung.com>
 Yang Gu <yang.gu@intel.com>
+Yang Liu <jd9668954@gmail.com>
 Yannic Bonenberger <yannic.bonenberger@gmail.com>
 Yarin Kaul <yarin.kaul@gmail.com>
 Yash Vempati <vempatiy@amazon.com>
@@ -1250,6 +1274,7 @@
 Yizhou Jiang <yizhou.jiang@intel.com>
 Yoav Weiss <yoav@yoav.ws>
 Yoav Zilberberg <yoav.zilberberg@gmail.com>
+Yong Ling <yongling@tencent.com>
 Yong Shin <sy3620@gmail.com>
 Yong Wang <ccyongwang@tencent.com>
 Yongha Lee <yongha78.lee@samsung.com>
@@ -1321,6 +1346,7 @@
 CoSMo Software pvt ltd <*@cosmosoftware.io>
 Cosium <*@cosium.com>
 Dell Technologies Inc. <*@dell.corp-partner.google.com>
+Ding (Beijing) Intelligent Technology Co. Ltd <*@dingdao.com>
 Duck Duck Go, Inc. <*@duckduckgo.com>
 Endless Mobile, Inc. <*@endlessm.com>
 EngFlow, Inc. <*@engflow.com>
diff --git a/base/BUILD b/base/BUILD
index 9de3117..c77528b 100644
--- a/base/BUILD
+++ b/base/BUILD
@@ -38,7 +38,6 @@
         "ranges/ranges.h",
         "stl_util.h",
         "template_util.h",
-        "strings/char_traits.h",
         "strings/string_piece_forward.h",
         "strings/string_piece.h",
         "strings/string_util.h",
diff --git a/base/containers/contains.h b/base/containers/contains.h
index 55b1fb5..559ff2c 100644
--- a/base/containers/contains.h
+++ b/base/containers/contains.h
@@ -10,7 +10,6 @@
 
 #include "base/ranges/algorithm.h"
 #include "base/ranges/ranges.h"
-#include "base/template_util.h"
 
 namespace gurl_base {
 
@@ -22,7 +21,7 @@
 struct HasKeyType : std::false_type {};
 
 template <typename T>
-struct HasKeyType<T, void_t<typename T::key_type>> : std::true_type {};
+struct HasKeyType<T, std::void_t<typename T::key_type>> : std::true_type {};
 
 // Probe whether a `contains` member function exists and return the result of
 // `container.contains(value)` if this is a valid expression. This is the
diff --git a/base/containers/contiguous_iterator.h b/base/containers/contiguous_iterator.h
index ca8e7b3..f17a8ed 100644
--- a/base/containers/contiguous_iterator.h
+++ b/base/containers/contiguous_iterator.h
@@ -12,7 +12,6 @@
 #include <vector>
 
 #include "base/containers/checked_iterators.h"
-#include "base/template_util.h"
 
 namespace gurl_base {
 
@@ -28,8 +27,8 @@
 
 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>> {};
+    : std::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
@@ -38,22 +37,24 @@
 // `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>>, IsStringIterImpl<T>> {};
+    : std::conjunction<std::is_trivial<iter_value_t<T>>, IsStringIterImpl<T>> {
+};
 
 // An iterator to std::array is contiguous.
 // Reference: https://wg21.link/array.overview#1
 template <typename T, typename ArrayT = std::array<iter_value_t<T>, 1>>
 struct IsArrayIter
-    : disjunction<std::is_same<T, typename ArrayT::const_iterator>,
-                  std::is_same<T, typename ArrayT::iterator>> {};
+    : std::disjunction<std::is_same<T, typename ArrayT::const_iterator>,
+                       std::is_same<T, typename ArrayT::iterator>> {};
 
 // An iterator to a non-bool std::vector is contiguous.
 // Reference: https://wg21.link/vector.overview#2
 template <typename T, typename VectorT = std::vector<iter_value_t<T>>>
 struct IsVectorIter
-    : conjunction<negation<std::is_same<iter_value_t<T>, bool>>,
-                  disjunction<std::is_same<T, typename VectorT::const_iterator>,
-                              std::is_same<T, typename VectorT::iterator>>> {};
+    : std::conjunction<
+          std::negation<std::is_same<iter_value_t<T>, bool>>,
+          std::disjunction<std::is_same<T, typename VectorT::const_iterator>,
+                           std::is_same<T, typename VectorT::iterator>>> {};
 
 // The result of passing a std::valarray to std::begin is a contiguous iterator.
 // Note: Since all common standard library implementations (i.e. libc++,
@@ -67,20 +68,21 @@
 // base's CheckedContiguousIterator is a contiguous iterator.
 template <typename T, typename ValueT = iter_value_t<T>>
 struct IsCheckedContiguousIter
-    : disjunction<std::is_same<T, gurl_base::CheckedContiguousConstIterator<ValueT>>,
-                  std::is_same<T, gurl_base::CheckedContiguousIterator<ValueT>>> {};
+    : std::disjunction<
+          std::is_same<T, gurl_base::CheckedContiguousConstIterator<ValueT>>,
+          std::is_same<T, gurl_base::CheckedContiguousIterator<ValueT>>> {};
 
 // Check that the iterator points to an actual object, and is one of the
 // iterator types mentioned above.
 template <typename T>
 struct IsContiguousIteratorImpl
-    : conjunction<PointsToObject<T>,
-                  disjunction<IsPointer<T>,
-                              IsStringIter<T>,
-                              IsArrayIter<T>,
-                              IsVectorIter<T>,
-                              IsValueArrayIter<T>,
-                              IsCheckedContiguousIter<T>>> {};
+    : std::conjunction<PointsToObject<T>,
+                       std::disjunction<IsPointer<T>,
+                                        IsStringIter<T>,
+                                        IsArrayIter<T>,
+                                        IsVectorIter<T>,
+                                        IsValueArrayIter<T>,
+                                        IsCheckedContiguousIter<T>>> {};
 
 }  // namespace internal
 
diff --git a/base/containers/span.h b/base/containers/span.h
index 1ba60b1..c0fb0b6 100644
--- a/base/containers/span.h
+++ b/base/containers/span.h
@@ -14,13 +14,11 @@
 #include <type_traits>
 #include <utility>
 
-#include "polyfills/base/check_op.h"
+#include "polyfills/base/check.h"
 #include "base/compiler_specific.h"
 #include "base/containers/checked_iterators.h"
 #include "base/containers/contiguous_iterator.h"
-#include "base/cxx17_backports.h"
 #include "base/cxx20_to_address.h"
-#include "base/template_util.h"
 
 namespace gurl_base {
 
@@ -57,7 +55,7 @@
 struct IsSpanImpl<span<T, Extent>> : std::true_type {};
 
 template <typename T>
-using IsNotSpan = negation<IsSpanImpl<std::decay_t<T>>>;
+using IsNotSpan = std::negation<IsSpanImpl<std::decay_t<T>>>;
 
 template <typename T>
 struct IsStdArrayImpl : std::false_type {};
@@ -66,10 +64,10 @@
 struct IsStdArrayImpl<std::array<T, N>> : std::true_type {};
 
 template <typename T>
-using IsNotStdArray = negation<IsStdArrayImpl<std::decay_t<T>>>;
+using IsNotStdArray = std::negation<IsStdArrayImpl<std::decay_t<T>>>;
 
 template <typename T>
-using IsNotCArray = negation<std::is_array<std::remove_reference_t<T>>>;
+using IsNotCArray = std::negation<std::is_array<std::remove_reference_t<T>>>;
 
 template <typename From, typename To>
 using IsLegalDataConversion = std::is_convertible<From (*)[], To (*)[]>;
@@ -80,17 +78,17 @@
 
 template <typename Iter, typename T>
 using EnableIfCompatibleContiguousIterator = std::enable_if_t<
-    conjunction<IsContiguousIterator<Iter>,
-                IteratorHasConvertibleReferenceType<Iter, T>>::value>;
+    std::conjunction<IsContiguousIterator<Iter>,
+                     IteratorHasConvertibleReferenceType<Iter, T>>::value>;
 
 template <typename Container, typename T>
 using ContainerHasConvertibleData = IsLegalDataConversion<
-    std::remove_pointer_t<decltype(gurl_base::data(std::declval<Container>()))>,
+    std::remove_pointer_t<decltype(std::data(std::declval<Container>()))>,
     T>;
 
 template <typename Container>
 using ContainerHasIntegralSize =
-    std::is_integral<decltype(gurl_base::size(std::declval<Container>()))>;
+    std::is_integral<decltype(std::size(std::declval<Container>()))>;
 
 template <typename From, size_t FromExtent, typename To, size_t ToExtent>
 using EnableIfLegalSpanConversion =
@@ -107,11 +105,11 @@
 // SFINAE check if Container can be converted to a span<T>.
 template <typename Container, typename T>
 using IsSpanCompatibleContainer =
-    conjunction<IsNotSpan<Container>,
-                IsNotStdArray<Container>,
-                IsNotCArray<Container>,
-                ContainerHasConvertibleData<Container, T>,
-                ContainerHasIntegralSize<Container>>;
+    std::conjunction<IsNotSpan<Container>,
+                     IsNotStdArray<Container>,
+                     IsNotCArray<Container>,
+                     ContainerHasConvertibleData<Container, T>,
+                     ContainerHasIntegralSize<Container>>;
 
 template <typename Container, typename T>
 using EnableIfSpanCompatibleContainer =
@@ -297,7 +295,7 @@
   template <
       size_t N,
       typename = internal::EnableIfSpanCompatibleArray<T (&)[N], T, Extent>>
-  constexpr span(T (&array)[N]) noexcept : span(gurl_base::data(array), N) {}
+  constexpr span(T (&array)[N]) noexcept : span(std::data(array), N) {}
 
   template <
       typename U,
@@ -305,17 +303,17 @@
       typename =
           internal::EnableIfSpanCompatibleArray<std::array<U, N>&, T, Extent>>
   constexpr span(std::array<U, N>& array) noexcept
-      : span(gurl_base::data(array), N) {}
+      : span(std::data(array), N) {}
 
   template <typename U,
             size_t N,
             typename = internal::
                 EnableIfSpanCompatibleArray<const std::array<U, N>&, T, Extent>>
   constexpr span(const std::array<U, N>& array) noexcept
-      : span(gurl_base::data(array), N) {}
+      : span(std::data(array), N) {}
 
-  // Conversion from a container that has compatible gurl_base::data() and integral
-  // gurl_base::size().
+  // Conversion from a container that has compatible std::data() and integral
+  // std::size().
   template <
       typename Container,
       typename =
@@ -323,7 +321,7 @@
                                                                     T,
                                                                     Extent>>
   constexpr span(Container& container) noexcept
-      : span(gurl_base::data(container), gurl_base::size(container)) {}
+      : span(std::data(container), std::size(container)) {}
 
   template <
       typename Container,
@@ -332,7 +330,7 @@
           T,
           Extent>>
   constexpr span(const Container& container) noexcept
-      : span(gurl_base::data(container), gurl_base::size(container)) {}
+      : span(std::data(container), std::size(container)) {}
 
   constexpr span(const span& other) noexcept = default;
 
@@ -485,7 +483,7 @@
 template <int&... ExplicitArgumentBarrier, typename Container>
 constexpr auto make_span(Container&& container) noexcept {
   using T =
-      std::remove_pointer_t<decltype(gurl_base::data(std::declval<Container>()))>;
+      std::remove_pointer_t<decltype(std::data(std::declval<Container>()))>;
   using Extent = internal::Extent<Container>;
   return span<T, Extent::value>(std::forward<Container>(container));
 }
@@ -510,8 +508,8 @@
 template <size_t N, int&... ExplicitArgumentBarrier, typename Container>
 constexpr auto make_span(Container&& container) noexcept {
   using T =
-      std::remove_pointer_t<decltype(gurl_base::data(std::declval<Container>()))>;
-  return span<T, N>(gurl_base::data(container), gurl_base::size(container));
+      std::remove_pointer_t<decltype(std::data(std::declval<Container>()))>;
+  return span<T, N>(std::data(container), std::size(container));
 }
 
 }  // namespace base
@@ -520,7 +518,7 @@
 // with definite extent, i.e. everything that is a contiguous storage of some
 // sort with static size. Specifically, this works for std::array in a constexpr
 // context. Note:
-//   * |gurl_base::size| should be preferred for plain arrays.
+//   * |std::size| should be preferred for plain arrays.
 //   * In run-time contexts, functions such as |std::array::size| should be
 //     preferred.
 #define EXTENT(x)                                        \
diff --git a/base/cxx17_backports.h b/base/cxx17_backports.h
index 81e573f..86976d4 100644
--- a/base/cxx17_backports.h
+++ b/base/cxx17_backports.h
@@ -5,11 +5,7 @@
 #ifndef BASE_CXX17_BACKPORTS_H_
 #define BASE_CXX17_BACKPORTS_H_
 
-#include <array>
 #include <functional>
-#include <initializer_list>
-#include <memory>
-#include <string>
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -19,83 +15,6 @@
 
 namespace gurl_base {
 
-// C++14 implementation of C++17's std::size():
-// http://en.cppreference.com/w/cpp/iterator/size
-template <typename Container>
-constexpr auto size(const Container& c) -> decltype(c.size()) {
-  return c.size();
-}
-
-template <typename T, size_t N>
-constexpr size_t size(const T (&array)[N]) noexcept {
-  return N;
-}
-
-// C++14 implementation of C++17's std::empty():
-// http://en.cppreference.com/w/cpp/iterator/empty
-template <typename Container>
-constexpr auto empty(const Container& c) -> decltype(c.empty()) {
-  return c.empty();
-}
-
-template <typename T, size_t N>
-constexpr bool empty(const T (&array)[N]) noexcept {
-  return false;
-}
-
-template <typename T>
-constexpr bool empty(std::initializer_list<T> il) noexcept {
-  return il.size() == 0;
-}
-
-// C++14 implementation of C++17's std::data():
-// http://en.cppreference.com/w/cpp/iterator/data
-template <typename Container>
-constexpr auto data(Container& c) -> decltype(c.data()) {
-  return c.data();
-}
-
-// std::basic_string::data() had no mutable overload prior to C++17 [1].
-// Hence this overload is provided.
-// Note: str[0] is safe even for empty strings, as they are guaranteed to be
-// null-terminated [2].
-//
-// [1] http://en.cppreference.com/w/cpp/string/basic_string/data
-// [2] http://en.cppreference.com/w/cpp/string/basic_string/operator_at
-template <typename CharT, typename Traits, typename Allocator>
-CharT* data(std::basic_string<CharT, Traits, Allocator>& str) {
-  return std::addressof(str[0]);
-}
-
-template <typename Container>
-constexpr auto data(const Container& c) -> decltype(c.data()) {
-  return c.data();
-}
-
-template <typename T, size_t N>
-constexpr T* data(T (&array)[N]) noexcept {
-  return array;
-}
-
-template <typename T>
-constexpr const T* data(std::initializer_list<T> il) noexcept {
-  return il.begin();
-}
-
-// std::array::data() was not constexpr prior to C++17 [1].
-// Hence these overloads are provided.
-//
-// [1] https://en.cppreference.com/w/cpp/container/array/data
-template <typename T, size_t N>
-constexpr T* data(std::array<T, N>& array) noexcept {
-  return !array.empty() ? &array[0] : nullptr;
-}
-
-template <typename T, size_t N>
-constexpr const T* data(const std::array<T, N>& array) noexcept {
-  return !array.empty() ? &array[0] : nullptr;
-}
-
 // C++14 implementation of C++17's std::clamp():
 // https://en.cppreference.com/w/cpp/algorithm/clamp
 // Please note that the C++ spec makes it undefined behavior to call std::clamp
diff --git a/base/debug/crash_logging.cc b/base/debug/crash_logging.cc
index f6bad4f..a6e3719 100644
--- a/base/debug/crash_logging.cc
+++ b/base/debug/crash_logging.cc
@@ -35,7 +35,7 @@
   g_crash_key_impl->Clear(crash_key);
 }
 
-BASE_EXPORT void OutputCrashKeysToStream(std::ostream& out) {
+void OutputCrashKeysToStream(std::ostream& out) {
   if (!g_crash_key_impl)
     return;
 
diff --git a/base/debug/crash_logging.h b/base/debug/crash_logging.h
index fdc5343..98f40c1 100644
--- a/base/debug/crash_logging.h
+++ b/base/debug/crash_logging.h
@@ -12,7 +12,6 @@
 #include <type_traits>
 
 #include "polyfills/base/base_export.h"
-#include "base/cxx17_backports.h"
 #include "base/memory/raw_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
@@ -125,7 +124,7 @@
 // that restricts the name of a crash key to 40 characters.
 #define SCOPED_CRASH_KEY_STRING_INTERNAL2(category, name, nonce, data,  \
                                           key_size)                     \
-  static_assert(::gurl_base::size(category "-" name) < 40,                   \
+  static_assert(::std::size(category "-" name) < 40,                    \
                 "Crash key names must be shorter than 40 characters."); \
   ::gurl_base::debug::ScopedCrashKeyString scoped_crash_key_helper##nonce(   \
       [] {                                                              \
diff --git a/base/memory/raw_ptr.h b/base/memory/raw_ptr.h
index 16094d3..ad53dc5 100644
--- a/base/memory/raw_ptr.h
+++ b/base/memory/raw_ptr.h
@@ -14,29 +14,44 @@
 #include <utility>
 
 #include "polyfills/base/allocator/buildflags.h"
+
 #include "polyfills/base/check.h"
 #include "base/compiler_specific.h"
 #include "polyfills/base/dcheck_is_on.h"
+#include "polyfills/third_party/perfetto/include/perfetto/tracing/traced_value.h"
 #include "build/build_config.h"
 #include "build/buildflag.h"
 
-#if BUILDFLAG(USE_BACKUP_REF_PTR)
+#if BUILDFLAG(USE_BACKUP_REF_PTR) || \
+    defined(PA_USE_MTE_CHECKED_PTR_WITH_64_BITS_POINTERS)
 // USE_BACKUP_REF_PTR implies USE_PARTITION_ALLOC, needed for code under
 // allocator/partition_allocator/ to be built.
 #include "base/allocator/partition_allocator/address_pool_manager_bitmap.h"
 #include "base/allocator/partition_allocator/partition_address_space.h"
-#include "base/allocator/partition_allocator/partition_alloc_config.h"
 #include "base/allocator/partition_allocator/partition_alloc_constants.h"
 #include "polyfills/base/base_export.h"
-#endif  // BUILDFLAG(USE_BACKUP_REF_PTR)
+#endif  // BUILDFLAG(USE_BACKUP_REF_PTR) ||
+        // defined(PA_USE_MTE_CHECKED_PTR_WITH_64_BITS_POINTERS)
+
+#if defined(PA_USE_MTE_CHECKED_PTR_WITH_64_BITS_POINTERS)
+#include "base/allocator/partition_allocator/partition_tag.h"
+#include "base/allocator/partition_allocator/tagging.h"
+#endif  // defined(PA_USE_MTE_CHECKED_PTR_WITH_64_BITS_POINTERS)
 
 #if BUILDFLAG(IS_WIN)
 #include <windows.h>
 #endif
 
+#if defined(OFFICIAL_BUILD)
+// The annotation changed compiler output and increased binary size so disable
+// for official builds.
+// TODO(crbug.com/1320670): Remove when issue is resolved.
+#define RAW_PTR_EXCLUSION
+#else
 // Marks a field as excluded from the raw_ptr usage enforcement clang plugin.
 // Example: RAW_PTR_EXCLUSION Foo* foo_;
 #define RAW_PTR_EXCLUSION __attribute__((annotate("raw_ptr_exclusion")))
+#endif
 
 namespace cc {
 class Scheduler;
@@ -50,13 +65,8 @@
 
 namespace gurl_base {
 
-// NOTE: All methods should be `ALWAYS_INLINE NO_STACK_PROTECTOR`.
-// ALWAYS_INLINE: raw_ptr is meant to be a lightweight replacement of a raw
-// pointer, hence performance is critical.
-// NO_STACK_PROTECTOR: This annotation is required to avoid failures when a
-// raw_ptr is inside a NO_STACK_PROTECTOR function.
-// TODO(https://crbug.com/1274129): Remove NO_STACK_PROTECTOR.
-#define RAW_PTR_FUNC_ATTRIBUTES ALWAYS_INLINE NO_STACK_PROTECTOR
+// NOTE: All methods should be `ALWAYS_INLINE`. raw_ptr is meant to be a
+// lightweight replacement of a raw pointer, hence performance is critical.
 
 namespace internal {
 // These classes/structures are part of the raw_ptr implementation.
@@ -65,41 +75,38 @@
 struct RawPtrNoOpImpl {
   // Wraps a pointer.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* WrapRawPtr(T* ptr) {
+  static ALWAYS_INLINE T* WrapRawPtr(T* ptr) {
     return ptr;
   }
 
   // Notifies the allocator when a wrapped pointer is being removed or replaced.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES void ReleaseWrappedPtr(T*) {}
+  static ALWAYS_INLINE void ReleaseWrappedPtr(T*) {}
 
   // Unwraps the pointer, while asserting that memory hasn't been freed. The
   // function is allowed to crash on nullptr.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* SafelyUnwrapPtrForDereference(
-      T* wrapped_ptr) {
+  static ALWAYS_INLINE T* SafelyUnwrapPtrForDereference(T* wrapped_ptr) {
     return wrapped_ptr;
   }
 
   // Unwraps the pointer, while asserting that memory hasn't been freed. The
   // function must handle nullptr gracefully.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* SafelyUnwrapPtrForExtraction(
-      T* wrapped_ptr) {
+  static ALWAYS_INLINE T* SafelyUnwrapPtrForExtraction(T* wrapped_ptr) {
     return wrapped_ptr;
   }
 
   // Unwraps the pointer, without making an assertion on whether memory was
   // freed or not.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* UnsafelyUnwrapPtrForComparison(
-      T* wrapped_ptr) {
+  static ALWAYS_INLINE T* UnsafelyUnwrapPtrForComparison(T* wrapped_ptr) {
     return wrapped_ptr;
   }
 
   // Upcasts the wrapped pointer.
   template <typename To, typename From>
-  static RAW_PTR_FUNC_ATTRIBUTES constexpr To* Upcast(From* wrapped_ptr) {
+  static ALWAYS_INLINE constexpr To* Upcast(From* wrapped_ptr) {
     static_assert(std::is_convertible<From*, To*>::value,
                   "From must be convertible to To.");
     // Note, this cast may change the address if upcasting to base that lies in
@@ -109,24 +116,180 @@
 
   // Advance the wrapped pointer by |delta| bytes.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* Advance(T* wrapped_ptr,
-                                            ptrdiff_t delta_elems) {
+  static ALWAYS_INLINE T* Advance(T* wrapped_ptr, ptrdiff_t delta_elems) {
     return wrapped_ptr + delta_elems;
   }
 
   // Returns a copy of a wrapped pointer, without making an assertion on whether
   // memory was freed or not.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* Duplicate(T* wrapped_ptr) {
+  static ALWAYS_INLINE T* Duplicate(T* wrapped_ptr) {
     return wrapped_ptr;
   }
 
   // This is for accounting only, used by unit tests.
-  static RAW_PTR_FUNC_ATTRIBUTES void IncrementSwapCountForTest() {}
-  static RAW_PTR_FUNC_ATTRIBUTES void
-  IncrementPointerToMemberOperatorCountForTest() {}
+  static ALWAYS_INLINE void IncrementSwapCountForTest() {}
+  static ALWAYS_INLINE void IncrementPointerToMemberOperatorCountForTest() {}
 };
 
+#if defined(PA_USE_MTE_CHECKED_PTR_WITH_64_BITS_POINTERS)
+
+constexpr int kValidAddressBits = 48;
+constexpr uintptr_t kAddressMask = (1ull << kValidAddressBits) - 1;
+constexpr int kTagBits = sizeof(uintptr_t) * 8 - kValidAddressBits;
+
+// MTECheckedPtr has no business with the topmost bits reserved for the
+// tag used by true ARM MTE, so we strip it out here.
+constexpr uintptr_t kTagMask =
+    ~kAddressMask & partition_alloc::internal::kMemTagUnmask;
+
+constexpr int kTopBitShift = 63;
+constexpr uintptr_t kTopBit = 1ull << kTopBitShift;
+static_assert(kTopBit << 1 == 0, "kTopBit should really be the top bit");
+static_assert((kTopBit & kTagMask) > 0,
+              "kTopBit bit must be inside the tag region");
+
+// This functionality is outside of MTECheckedPtrImpl, so that it can be
+// overridden by tests.
+struct MTECheckedPtrImplPartitionAllocSupport {
+  // Checks if the necessary support is enabled in PartitionAlloc for `ptr`.
+  template <typename T>
+  static ALWAYS_INLINE bool EnabledForPtr(T* ptr) {
+    auto as_uintptr =
+        partition_alloc::internal::UnmaskPtr(reinterpret_cast<uintptr_t>(ptr));
+    // MTECheckedPtr algorithms work only when memory is
+    // allocated by PartitionAlloc, from normal buckets pool.
+    //
+    // TODO(crbug.com/1307514): Allow direct-map buckets.
+    return IsManagedByPartitionAlloc(as_uintptr) &&
+           IsManagedByNormalBuckets(as_uintptr);
+  }
+
+  // Returns pointer to the tag that protects are pointed by |ptr|.
+  static ALWAYS_INLINE void* TagPointer(uintptr_t ptr) {
+    return partition_alloc::PartitionTagPointer(ptr);
+  }
+};
+
+template <typename PartitionAllocSupport>
+struct MTECheckedPtrImpl {
+  // This implementation assumes that pointers are 64 bits long and at least 16
+  // top bits are unused. The latter is harder to verify statically, but this is
+  // true for all currently supported 64-bit architectures (GURL_DCHECK when wrapping
+  // will verify that).
+  static_assert(sizeof(void*) >= 8, "Need 64-bit pointers");
+
+  // Wraps a pointer, and returns its uintptr_t representation.
+  template <typename T>
+  static ALWAYS_INLINE T* WrapRawPtr(T* ptr) {
+    uintptr_t addr = reinterpret_cast<uintptr_t>(ptr);
+    GURL_DCHECK_EQ(ExtractTag(addr), 0ull);
+
+    // Return a not-wrapped |addr|, if it's either nullptr or if the protection
+    // for this pointer is disabled.
+    if (!PartitionAllocSupport::EnabledForPtr(ptr)) {
+      return reinterpret_cast<T*>(addr);
+    }
+
+    // Read the tag and place it in the top bits of the address.
+    // Even if PartitionAlloc's tag has less than kTagBits, we'll read
+    // what's given and pad the rest with 0s.
+    static_assert(sizeof(partition_alloc::PartitionTag) * 8 <= kTagBits, "");
+    uintptr_t tag = *(static_cast<volatile partition_alloc::PartitionTag*>(
+        PartitionAllocSupport::TagPointer(addr)));
+
+    tag <<= kValidAddressBits;
+    addr |= tag;
+    return reinterpret_cast<T*>(addr);
+  }
+
+  // Notifies the allocator when a wrapped pointer is being removed or replaced.
+  // No-op for MTECheckedPtrImpl.
+  template <typename T>
+  static ALWAYS_INLINE void ReleaseWrappedPtr(T*) {}
+
+  // Unwraps the pointer's uintptr_t representation, while asserting that memory
+  // hasn't been freed. The function is allowed to crash on nullptr.
+  template <typename T>
+  static ALWAYS_INLINE T* SafelyUnwrapPtrForDereference(T* wrapped_ptr) {
+    uintptr_t wrapped_addr = reinterpret_cast<uintptr_t>(wrapped_ptr);
+    uintptr_t tag = ExtractTag(wrapped_addr);
+    if (tag > 0) {
+      // Read the tag provided by PartitionAlloc.
+      //
+      // Cast to volatile to ensure memory is read. E.g. in a tight loop, the
+      // compiler could cache the value in a register and thus could miss that
+      // another thread freed memory and changed tag.
+      uintptr_t read_tag =
+          *static_cast<volatile partition_alloc::PartitionTag*>(
+              PartitionAllocSupport::TagPointer(ExtractAddress(wrapped_addr)));
+      if (UNLIKELY(tag != read_tag))
+        IMMEDIATE_CRASH();
+      return reinterpret_cast<T*>(ExtractAddress(wrapped_addr));
+    }
+    return wrapped_ptr;
+  }
+
+  // Unwraps the pointer's uintptr_t representation, while asserting that memory
+  // hasn't been freed. The function must handle nullptr gracefully.
+  template <typename T>
+  static ALWAYS_INLINE T* SafelyUnwrapPtrForExtraction(T* wrapped_ptr) {
+    // SafelyUnwrapPtrForDereference handles nullptr case well.
+    return SafelyUnwrapPtrForDereference(wrapped_ptr);
+  }
+
+  // Unwraps the pointer's uintptr_t representation, without making an assertion
+  // on whether memory was freed or not.
+  template <typename T>
+  static ALWAYS_INLINE T* UnsafelyUnwrapPtrForComparison(T* wrapped_ptr) {
+    return ExtractPtr(wrapped_ptr);
+  }
+
+  // Upcasts the wrapped pointer.
+  template <typename To, typename From>
+  static ALWAYS_INLINE constexpr To* Upcast(From* wrapped_ptr) {
+    static_assert(std::is_convertible<From*, To*>::value,
+                  "From must be convertible to To.");
+
+    // The top-bit tag must not affect the result of upcast.
+    return static_cast<To*>(wrapped_ptr);
+  }
+
+  // Advance the wrapped pointer by |delta| bytes.
+  template <typename T>
+  static ALWAYS_INLINE T* Advance(T* wrapped_ptr, ptrdiff_t delta_elem) {
+    return wrapped_ptr + delta_elem;
+  }
+
+  // Returns a copy of a wrapped pointer, without making an assertion
+  // on whether memory was freed or not.
+  template <typename T>
+  static ALWAYS_INLINE T* Duplicate(T* wrapped_ptr) {
+    return wrapped_ptr;
+  }
+
+  // This is for accounting only, used by unit tests.
+  static ALWAYS_INLINE void IncrementSwapCountForTest() {}
+  static ALWAYS_INLINE void IncrementPointerToMemberOperatorCountForTest() {}
+
+ private:
+  static ALWAYS_INLINE uintptr_t ExtractAddress(uintptr_t wrapped_ptr) {
+    return wrapped_ptr & kAddressMask;
+  }
+
+  template <typename T>
+  static ALWAYS_INLINE T* ExtractPtr(T* wrapped_ptr) {
+    return reinterpret_cast<T*>(
+        ExtractAddress(reinterpret_cast<uintptr_t>(wrapped_ptr)));
+  }
+
+  static ALWAYS_INLINE uintptr_t ExtractTag(uintptr_t wrapped_ptr) {
+    return (wrapped_ptr & kTagMask) >> kValidAddressBits;
+  }
+};
+
+#endif  // defined(PA_USE_MTE_CHECKED_PTR_WITH_64_BITS_POINTERS)
+
 #if BUILDFLAG(USE_BACKUP_REF_PTR)
 
 #if GURL_DCHECK_IS_ON() || BUILDFLAG(ENABLE_BACKUP_REF_PTR_SLOW_CHECKS)
@@ -134,12 +297,13 @@
     uintptr_t address);
 #endif
 
+template <bool AllowDangling = false>
 struct BackupRefPtrImpl {
   // Note that `BackupRefPtrImpl` itself is not thread-safe. If multiple threads
   // modify the same smart pointer object without synchronization, a data race
   // will occur.
 
-  static RAW_PTR_FUNC_ATTRIBUTES bool IsSupportedAndNotNull(uintptr_t address) {
+  static ALWAYS_INLINE bool IsSupportedAndNotNull(uintptr_t address) {
     // This covers the nullptr case, as address 0 is never in GigaCage.
     bool is_in_brp_pool = IsManagedByPartitionAllocBRPPool(address);
 
@@ -192,7 +356,7 @@
 
   // Wraps a pointer.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* WrapRawPtr(T* ptr) {
+  static ALWAYS_INLINE T* WrapRawPtr(T* ptr) {
     uintptr_t address = reinterpret_cast<uintptr_t>(ptr);
     if (IsSupportedAndNotNull(address)) {
 #if GURL_DCHECK_IS_ON() || BUILDFLAG(ENABLE_BACKUP_REF_PTR_SLOW_CHECKS)
@@ -211,7 +375,7 @@
 
   // Notifies the allocator when a wrapped pointer is being removed or replaced.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES void ReleaseWrappedPtr(T* wrapped_ptr) {
+  static ALWAYS_INLINE void ReleaseWrappedPtr(T* wrapped_ptr) {
     uintptr_t address = reinterpret_cast<uintptr_t>(wrapped_ptr);
     if (IsSupportedAndNotNull(address)) {
 #if GURL_DCHECK_IS_ON() || BUILDFLAG(ENABLE_BACKUP_REF_PTR_SLOW_CHECKS)
@@ -231,8 +395,7 @@
   // Unwraps the pointer, while asserting that memory hasn't been freed. The
   // function is allowed to crash on nullptr.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* SafelyUnwrapPtrForDereference(
-      T* wrapped_ptr) {
+  static ALWAYS_INLINE T* SafelyUnwrapPtrForDereference(T* wrapped_ptr) {
 #if GURL_DCHECK_IS_ON() || BUILDFLAG(ENABLE_BACKUP_REF_PTR_SLOW_CHECKS)
     uintptr_t address = reinterpret_cast<uintptr_t>(wrapped_ptr);
     if (IsSupportedAndNotNull(address)) {
@@ -246,22 +409,20 @@
   // Unwraps the pointer, while asserting that memory hasn't been freed. The
   // function must handle nullptr gracefully.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* SafelyUnwrapPtrForExtraction(
-      T* wrapped_ptr) {
+  static ALWAYS_INLINE T* SafelyUnwrapPtrForExtraction(T* wrapped_ptr) {
     return wrapped_ptr;
   }
 
   // Unwraps the pointer, without making an assertion on whether memory was
   // freed or not.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* UnsafelyUnwrapPtrForComparison(
-      T* wrapped_ptr) {
+  static ALWAYS_INLINE T* UnsafelyUnwrapPtrForComparison(T* wrapped_ptr) {
     return wrapped_ptr;
   }
 
   // Upcasts the wrapped pointer.
   template <typename To, typename From>
-  static RAW_PTR_FUNC_ATTRIBUTES constexpr To* Upcast(From* wrapped_ptr) {
+  static ALWAYS_INLINE constexpr To* Upcast(From* wrapped_ptr) {
     static_assert(std::is_convertible<From*, To*>::value,
                   "From must be convertible to To.");
     // Note, this cast may change the address if upcasting to base that lies in
@@ -271,8 +432,7 @@
 
   // Advance the wrapped pointer by |delta| bytes.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* Advance(T* wrapped_ptr,
-                                            ptrdiff_t delta_elem) {
+  static ALWAYS_INLINE T* Advance(T* wrapped_ptr, ptrdiff_t delta_elem) {
 #if GURL_DCHECK_IS_ON() || BUILDFLAG(ENABLE_BACKUP_REF_PTR_SLOW_CHECKS)
     uintptr_t address = reinterpret_cast<uintptr_t>(wrapped_ptr);
     if (IsSupportedAndNotNull(address))
@@ -287,14 +447,13 @@
   // memory was freed or not.
   // This method increments the reference count of the allocation slot.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* Duplicate(T* wrapped_ptr) {
+  static ALWAYS_INLINE T* Duplicate(T* wrapped_ptr) {
     return WrapRawPtr(wrapped_ptr);
   }
 
   // This is for accounting only, used by unit tests.
-  static RAW_PTR_FUNC_ATTRIBUTES void IncrementSwapCountForTest() {}
-  static RAW_PTR_FUNC_ATTRIBUTES void
-  IncrementPointerToMemberOperatorCountForTest() {}
+  static ALWAYS_INLINE void IncrementSwapCountForTest() {}
+  static ALWAYS_INLINE void IncrementPointerToMemberOperatorCountForTest() {}
 
  private:
   // We've evaluated several strategies (inline nothing, various parts, or
@@ -316,20 +475,19 @@
 struct AsanBackupRefPtrImpl {
   // Wraps a pointer.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* WrapRawPtr(T* ptr) {
+  static ALWAYS_INLINE T* WrapRawPtr(T* ptr) {
     AsanCheckIfValidInstantiation(ptr);
     return ptr;
   }
 
   // Notifies the allocator when a wrapped pointer is being removed or replaced.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES void ReleaseWrappedPtr(T*) {}
+  static ALWAYS_INLINE void ReleaseWrappedPtr(T*) {}
 
   // Unwraps the pointer, while asserting that memory hasn't been freed. The
   // function is allowed to crash on nullptr.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* SafelyUnwrapPtrForDereference(
-      T* wrapped_ptr) {
+  static ALWAYS_INLINE T* SafelyUnwrapPtrForDereference(T* wrapped_ptr) {
     AsanCheckIfValidDereference(wrapped_ptr);
     return wrapped_ptr;
   }
@@ -337,8 +495,7 @@
   // Unwraps the pointer, while asserting that memory hasn't been freed. The
   // function must handle nullptr gracefully.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* SafelyUnwrapPtrForExtraction(
-      T* wrapped_ptr) {
+  static ALWAYS_INLINE T* SafelyUnwrapPtrForExtraction(T* wrapped_ptr) {
     AsanCheckIfValidExtraction(wrapped_ptr);
     return wrapped_ptr;
   }
@@ -346,14 +503,13 @@
   // Unwraps the pointer, without making an assertion on whether memory was
   // freed or not.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* UnsafelyUnwrapPtrForComparison(
-      T* wrapped_ptr) {
+  static ALWAYS_INLINE T* UnsafelyUnwrapPtrForComparison(T* wrapped_ptr) {
     return wrapped_ptr;
   }
 
   // Upcasts the wrapped pointer.
   template <typename To, typename From>
-  static RAW_PTR_FUNC_ATTRIBUTES constexpr To* Upcast(From* wrapped_ptr) {
+  static ALWAYS_INLINE constexpr To* Upcast(From* wrapped_ptr) {
     static_assert(std::is_convertible<From*, To*>::value,
                   "From must be convertible to To.");
     // Note, this cast may change the address if upcasting to base that lies in
@@ -363,22 +519,20 @@
 
   // Advance the wrapped pointer by |delta| bytes.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* Advance(T* wrapped_ptr,
-                                            ptrdiff_t delta_elems) {
+  static ALWAYS_INLINE T* Advance(T* wrapped_ptr, ptrdiff_t delta_elems) {
     return wrapped_ptr + delta_elems;
   }
 
   // Returns a copy of a wrapped pointer, without making an assertion on whether
   // memory was freed or not.
   template <typename T>
-  static RAW_PTR_FUNC_ATTRIBUTES T* Duplicate(T* wrapped_ptr) {
+  static ALWAYS_INLINE T* Duplicate(T* wrapped_ptr) {
     return wrapped_ptr;
   }
 
   // This is for accounting only, used by unit tests.
-  static RAW_PTR_FUNC_ATTRIBUTES void IncrementSwapCountForTest() {}
-  static RAW_PTR_FUNC_ATTRIBUTES void
-  IncrementPointerToMemberOperatorCountForTest() {}
+  static ALWAYS_INLINE void IncrementSwapCountForTest() {}
+  static ALWAYS_INLINE void IncrementPointerToMemberOperatorCountForTest() {}
 
  private:
   static BASE_EXPORT NOINLINE void AsanCheckIfValidInstantiation(
@@ -494,14 +648,24 @@
 // non-default move constructor/assignment. Thus, it's possible to get an error
 // where the pointer is not actually dangling, and have to work around the
 // compiler. We have not managed to construct such an example in Chromium yet.
-template <typename T,
 #if BUILDFLAG(USE_BACKUP_REF_PTR)
-          typename Impl = internal::BackupRefPtrImpl>
+using RawPtrMayDangle = internal::BackupRefPtrImpl</*AllowDangling=*/true>;
+using RawPtrBanDanglingIfSupported =
+    internal::BackupRefPtrImpl</*AllowDangling=*/false>;
 #elif BUILDFLAG(USE_ASAN_BACKUP_REF_PTR)
-          typename Impl = internal::AsanBackupRefPtrImpl>
+using RawPtrMayDangle = internal::AsanBackupRefPtrImpl;
+using RawPtrBanDanglingIfSupported = internal::AsanBackupRefPtrImpl;
+#elif defined(PA_USE_MTE_CHECKED_PTR_WITH_64_BITS_POINTERS)
+using RawPtrMayDangle = internal::MTECheckedPtrImpl<
+    internal::MTECheckedPtrImplPartitionAllocSupport>;
+using RawPtrBanDanglingIfSupported = internal::MTECheckedPtrImpl<
+    internal::MTECheckedPtrImplPartitionAllocSupport>;
 #else
-          typename Impl = internal::RawPtrNoOpImpl>
+using RawPtrMayDangle = internal::RawPtrNoOpImpl;
+using RawPtrBanDanglingIfSupported = internal::RawPtrNoOpImpl;
 #endif
+
+template <typename T, typename Impl = RawPtrBanDanglingIfSupported>
 class TRIVIAL_ABI GSL_POINTER raw_ptr {
  public:
   static_assert(raw_ptr_traits::IsSupportedType<T>::value,
@@ -509,18 +673,17 @@
 
 #if BUILDFLAG(USE_BACKUP_REF_PTR)
   // BackupRefPtr requires a non-trivial default constructor, destructor, etc.
-  constexpr RAW_PTR_FUNC_ATTRIBUTES raw_ptr() noexcept
-      : wrapped_ptr_(nullptr) {}
+  constexpr ALWAYS_INLINE raw_ptr() noexcept : wrapped_ptr_(nullptr) {}
 
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr(const raw_ptr& p) noexcept
+  ALWAYS_INLINE raw_ptr(const raw_ptr& p) noexcept
       : wrapped_ptr_(Impl::Duplicate(p.wrapped_ptr_)) {}
 
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr(raw_ptr&& p) noexcept {
+  ALWAYS_INLINE raw_ptr(raw_ptr&& p) noexcept {
     wrapped_ptr_ = p.wrapped_ptr_;
     p.wrapped_ptr_ = nullptr;
   }
 
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr& operator=(const raw_ptr& p) {
+  ALWAYS_INLINE raw_ptr& operator=(const raw_ptr& p) {
     // Duplicate before releasing, in case the pointer is assigned to itself.
     T* new_ptr = Impl::Duplicate(p.wrapped_ptr_);
     Impl::ReleaseWrappedPtr(wrapped_ptr_);
@@ -528,7 +691,7 @@
     return *this;
   }
 
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr& operator=(raw_ptr&& p) {
+  ALWAYS_INLINE raw_ptr& operator=(raw_ptr&& p) {
     if (LIKELY(this != &p)) {
       Impl::ReleaseWrappedPtr(wrapped_ptr_);
       wrapped_ptr_ = p.wrapped_ptr_;
@@ -537,7 +700,7 @@
     return *this;
   }
 
-  RAW_PTR_FUNC_ATTRIBUTES ~raw_ptr() noexcept {
+  ALWAYS_INLINE ~raw_ptr() noexcept {
     Impl::ReleaseWrappedPtr(wrapped_ptr_);
     // Work around external issues where raw_ptr is used after destruction.
     wrapped_ptr_ = nullptr;
@@ -550,31 +713,30 @@
   //
   // TODO(lukasza): Always initialize |wrapped_ptr_|.  Fix resulting build
   // errors.  Analyze performance impact.
-  constexpr RAW_PTR_FUNC_ATTRIBUTES raw_ptr() noexcept = default;
+  constexpr ALWAYS_INLINE raw_ptr() noexcept = default;
 
   // In addition to nullptr_t ctor above, raw_ptr needs to have these
   // as |=default| or |constexpr| to avoid hitting -Wglobal-constructors in
   // cases like this:
   //     struct SomeStruct { int int_field; raw_ptr<int> ptr_field; };
   //     SomeStruct g_global_var = { 123, nullptr };
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr(const raw_ptr&) noexcept = default;
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr(raw_ptr&&) noexcept = default;
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr& operator=(const raw_ptr&) noexcept = default;
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr& operator=(raw_ptr&&) noexcept = default;
+  ALWAYS_INLINE raw_ptr(const raw_ptr&) noexcept = default;
+  ALWAYS_INLINE raw_ptr(raw_ptr&&) noexcept = default;
+  ALWAYS_INLINE raw_ptr& operator=(const raw_ptr&) noexcept = default;
+  ALWAYS_INLINE raw_ptr& operator=(raw_ptr&&) noexcept = default;
 
-  RAW_PTR_FUNC_ATTRIBUTES ~raw_ptr() = default;
+  ALWAYS_INLINE ~raw_ptr() = default;
 
 #endif  // BUILDFLAG(USE_BACKUP_REF_PTR)
 
   // Deliberately implicit, because raw_ptr is supposed to resemble raw ptr.
   // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr RAW_PTR_FUNC_ATTRIBUTES raw_ptr(std::nullptr_t) noexcept
+  constexpr ALWAYS_INLINE raw_ptr(std::nullptr_t) noexcept
       : wrapped_ptr_(nullptr) {}
 
   // Deliberately implicit, because raw_ptr is supposed to resemble raw ptr.
   // NOLINTNEXTLINE(google-explicit-constructor)
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr(T* p) noexcept
-      : wrapped_ptr_(Impl::WrapRawPtr(p)) {}
+  ALWAYS_INLINE raw_ptr(T* p) noexcept : wrapped_ptr_(Impl::WrapRawPtr(p)) {}
 
   // Deliberately implicit in order to support implicit upcast.
   template <typename U,
@@ -582,7 +744,7 @@
                 std::is_convertible<U*, T*>::value &&
                 !std::is_void<typename std::remove_cv<T>::type>::value>>
   // NOLINTNEXTLINE(google-explicit-constructor)
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr(const raw_ptr<U, Impl>& ptr) noexcept
+  ALWAYS_INLINE raw_ptr(const raw_ptr<U, Impl>& ptr) noexcept
       : wrapped_ptr_(
             Impl::Duplicate(Impl::template Upcast<T, U>(ptr.wrapped_ptr_))) {}
   // Deliberately implicit in order to support implicit upcast.
@@ -591,19 +753,19 @@
                 std::is_convertible<U*, T*>::value &&
                 !std::is_void<typename std::remove_cv<T>::type>::value>>
   // NOLINTNEXTLINE(google-explicit-constructor)
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr(raw_ptr<U, Impl>&& ptr) noexcept
+  ALWAYS_INLINE raw_ptr(raw_ptr<U, Impl>&& ptr) noexcept
       : wrapped_ptr_(Impl::template Upcast<T, U>(ptr.wrapped_ptr_)) {
 #if BUILDFLAG(USE_BACKUP_REF_PTR)
     ptr.wrapped_ptr_ = nullptr;
 #endif
   }
 
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr& operator=(std::nullptr_t) noexcept {
+  ALWAYS_INLINE raw_ptr& operator=(std::nullptr_t) noexcept {
     Impl::ReleaseWrappedPtr(wrapped_ptr_);
     wrapped_ptr_ = nullptr;
     return *this;
   }
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr& operator=(T* p) noexcept {
+  ALWAYS_INLINE raw_ptr& operator=(T* p) noexcept {
     Impl::ReleaseWrappedPtr(wrapped_ptr_);
     wrapped_ptr_ = Impl::WrapRawPtr(p);
     return *this;
@@ -614,8 +776,7 @@
             typename Unused = std::enable_if_t<
                 std::is_convertible<U*, T*>::value &&
                 !std::is_void<typename std::remove_cv<T>::type>::value>>
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr& operator=(
-      const raw_ptr<U, Impl>& ptr) noexcept {
+  ALWAYS_INLINE raw_ptr& operator=(const raw_ptr<U, Impl>& ptr) noexcept {
     // Make sure that pointer isn't assigned to itself (look at pointer address,
     // not its value).
 #if GURL_DCHECK_IS_ON() || BUILDFLAG(ENABLE_BACKUP_REF_PTR_SLOW_CHECKS)
@@ -631,7 +792,7 @@
             typename Unused = std::enable_if_t<
                 std::is_convertible<U*, T*>::value &&
                 !std::is_void<typename std::remove_cv<T>::type>::value>>
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr& operator=(raw_ptr<U, Impl>&& ptr) noexcept {
+  ALWAYS_INLINE raw_ptr& operator=(raw_ptr<U, Impl>&& ptr) noexcept {
     // Make sure that pointer isn't assigned to itself (look at pointer address,
     // not its value).
 #if GURL_DCHECK_IS_ON() || BUILDFLAG(ENABLE_BACKUP_REF_PTR_SLOW_CHECKS)
@@ -648,19 +809,17 @@
 
   // Avoid using. The goal of raw_ptr is to be as close to raw pointer as
   // possible, so use it only if absolutely necessary (e.g. for const_cast).
-  RAW_PTR_FUNC_ATTRIBUTES T* get() const { return GetForExtraction(); }
+  ALWAYS_INLINE T* get() const { return GetForExtraction(); }
 
-  explicit RAW_PTR_FUNC_ATTRIBUTES operator bool() const {
-    return !!wrapped_ptr_;
-  }
+  explicit ALWAYS_INLINE operator bool() const { return !!wrapped_ptr_; }
 
   template <typename U = T,
             typename Unused = std::enable_if_t<
                 !std::is_void<typename std::remove_cv<U>::type>::value>>
-  RAW_PTR_FUNC_ATTRIBUTES U& operator*() const {
+  ALWAYS_INLINE U& operator*() const {
     return *GetForDereference();
   }
-  RAW_PTR_FUNC_ATTRIBUTES T* operator->() const { return GetForDereference(); }
+  ALWAYS_INLINE T* operator->() const { return GetForDereference(); }
 
   // Disables `(my_raw_ptr->*pmf)(...)` as a workaround for
   // the ICE in GCC parsing the code, reported at
@@ -670,37 +829,37 @@
 
   // Deliberately implicit, because raw_ptr is supposed to resemble raw ptr.
   // NOLINTNEXTLINE(runtime/explicit)
-  RAW_PTR_FUNC_ATTRIBUTES operator T*() const { return GetForExtraction(); }
+  ALWAYS_INLINE operator T*() const { return GetForExtraction(); }
   template <typename U>
-  explicit RAW_PTR_FUNC_ATTRIBUTES operator U*() const {
+  explicit ALWAYS_INLINE operator U*() const {
     // This operator may be invoked from static_cast, meaning the types may not
     // be implicitly convertible, hence the need for static_cast here.
     return static_cast<U*>(GetForExtraction());
   }
 
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr& operator++() {
+  ALWAYS_INLINE raw_ptr& operator++() {
     wrapped_ptr_ = Impl::Advance(wrapped_ptr_, 1);
     return *this;
   }
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr& operator--() {
+  ALWAYS_INLINE raw_ptr& operator--() {
     wrapped_ptr_ = Impl::Advance(wrapped_ptr_, -1);
     return *this;
   }
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr operator++(int /* post_increment */) {
+  ALWAYS_INLINE raw_ptr operator++(int /* post_increment */) {
     raw_ptr result = *this;
     ++(*this);
     return result;
   }
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr operator--(int /* post_decrement */) {
+  ALWAYS_INLINE raw_ptr operator--(int /* post_decrement */) {
     raw_ptr result = *this;
     --(*this);
     return result;
   }
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr& operator+=(ptrdiff_t delta_elems) {
+  ALWAYS_INLINE raw_ptr& operator+=(ptrdiff_t delta_elems) {
     wrapped_ptr_ = Impl::Advance(wrapped_ptr_, delta_elems);
     return *this;
   }
-  RAW_PTR_FUNC_ATTRIBUTES raw_ptr& operator-=(ptrdiff_t delta_elems) {
+  ALWAYS_INLINE raw_ptr& operator-=(ptrdiff_t delta_elems) {
     return *this += -delta_elems;
   }
 
@@ -708,13 +867,25 @@
   // raw delete calls, this avoids the raw_ptr to be temporarily dangling
   // during the free operation, which will lead to taking the slower path that
   // involves quarantine.
-  RAW_PTR_FUNC_ATTRIBUTES void ClearAndDelete() noexcept {
+  ALWAYS_INLINE void ClearAndDelete() noexcept {
+#if defined(PA_USE_MTE_CHECKED_PTR_WITH_64_BITS_POINTERS)
+    // We cannot directly `delete` a wrapped pointer, since the tag bits
+    // atop will lead PA totally astray.
+    T* ptr = Impl::SafelyUnwrapPtrForExtraction(wrapped_ptr_);
+#else
     T* ptr = wrapped_ptr_;
+#endif  // defined(PA_USE_MTE_CHECKED_PTR_WITH_64_BITS_POINTERS)
     operator=(nullptr);
     delete ptr;
   }
-  RAW_PTR_FUNC_ATTRIBUTES void ClearAndDeleteArray() noexcept {
+  ALWAYS_INLINE void ClearAndDeleteArray() noexcept {
+#if defined(PA_USE_MTE_CHECKED_PTR_WITH_64_BITS_POINTERS)
+    // We cannot directly `delete` a wrapped pointer, since the tag bits
+    // atop will lead PA totally astray.
+    T* ptr = Impl::SafelyUnwrapPtrForExtraction(wrapped_ptr_);
+#else
     T* ptr = wrapped_ptr_;
+#endif  // defined(PA_USE_MTE_CHECKED_PTR_WITH_64_BITS_POINTERS)
     operator=(nullptr);
     delete[] ptr;
   }
@@ -733,118 +904,121 @@
   // because a comparison operator defined inline would not be allowed to call
   // `raw_ptr<U>`'s private `GetForComparison()` method.
   template <typename U, typename V, typename I>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator==(const raw_ptr<U, I>& lhs,
-                                                 const raw_ptr<V, I>& rhs);
+  friend ALWAYS_INLINE bool operator==(const raw_ptr<U, I>& lhs,
+                                       const raw_ptr<V, I>& rhs);
   template <typename U>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator!=(const raw_ptr& lhs,
-                                                 const raw_ptr<U, Impl>& rhs) {
+  friend ALWAYS_INLINE bool operator!=(const raw_ptr& lhs,
+                                       const raw_ptr<U, Impl>& rhs) {
     return !(lhs == rhs);
   }
   template <typename U, typename V, typename I>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator<(const raw_ptr<U, I>& lhs,
-                                                const raw_ptr<V, I>& rhs);
+  friend ALWAYS_INLINE bool operator<(const raw_ptr<U, I>& lhs,
+                                      const raw_ptr<V, I>& rhs);
   template <typename U, typename V, typename I>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator>(const raw_ptr<U, I>& lhs,
-                                                const raw_ptr<V, I>& rhs);
+  friend ALWAYS_INLINE bool operator>(const raw_ptr<U, I>& lhs,
+                                      const raw_ptr<V, I>& rhs);
   template <typename U, typename V, typename I>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator<=(const raw_ptr<U, I>& lhs,
-                                                 const raw_ptr<V, I>& rhs);
+  friend ALWAYS_INLINE bool operator<=(const raw_ptr<U, I>& lhs,
+                                       const raw_ptr<V, I>& rhs);
   template <typename U, typename V, typename I>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator>=(const raw_ptr<U, I>& lhs,
-                                                 const raw_ptr<V, I>& rhs);
+  friend ALWAYS_INLINE bool operator>=(const raw_ptr<U, I>& lhs,
+                                       const raw_ptr<V, I>& rhs);
 
   // Comparisons with U*. These operators also handle the case where the RHS is
   // T*.
   template <typename U>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator==(const raw_ptr& lhs, U* rhs) {
+  friend ALWAYS_INLINE bool operator==(const raw_ptr& lhs, U* rhs) {
     return lhs.GetForComparison() == rhs;
   }
   template <typename U>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator!=(const raw_ptr& lhs, U* rhs) {
+  friend ALWAYS_INLINE bool operator!=(const raw_ptr& lhs, U* rhs) {
     return !(lhs == rhs);
   }
   template <typename U>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator==(U* lhs, const raw_ptr& rhs) {
+  friend ALWAYS_INLINE bool operator==(U* lhs, const raw_ptr& rhs) {
     return rhs == lhs;  // Reverse order to call the operator above.
   }
   template <typename U>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator!=(U* lhs, const raw_ptr& rhs) {
+  friend ALWAYS_INLINE bool operator!=(U* lhs, const raw_ptr& rhs) {
     return rhs != lhs;  // Reverse order to call the operator above.
   }
   template <typename U>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator<(const raw_ptr& lhs, U* rhs) {
+  friend ALWAYS_INLINE bool operator<(const raw_ptr& lhs, U* rhs) {
     return lhs.GetForComparison() < rhs;
   }
   template <typename U>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator<=(const raw_ptr& lhs, U* rhs) {
+  friend ALWAYS_INLINE bool operator<=(const raw_ptr& lhs, U* rhs) {
     return lhs.GetForComparison() <= rhs;
   }
   template <typename U>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator>(const raw_ptr& lhs, U* rhs) {
+  friend ALWAYS_INLINE bool operator>(const raw_ptr& lhs, U* rhs) {
     return lhs.GetForComparison() > rhs;
   }
   template <typename U>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator>=(const raw_ptr& lhs, U* rhs) {
+  friend ALWAYS_INLINE bool operator>=(const raw_ptr& lhs, U* rhs) {
     return lhs.GetForComparison() >= rhs;
   }
   template <typename U>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator<(U* lhs, const raw_ptr& rhs) {
+  friend ALWAYS_INLINE bool operator<(U* lhs, const raw_ptr& rhs) {
     return lhs < rhs.GetForComparison();
   }
   template <typename U>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator<=(U* lhs, const raw_ptr& rhs) {
+  friend ALWAYS_INLINE bool operator<=(U* lhs, const raw_ptr& rhs) {
     return lhs <= rhs.GetForComparison();
   }
   template <typename U>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator>(U* lhs, const raw_ptr& rhs) {
+  friend ALWAYS_INLINE bool operator>(U* lhs, const raw_ptr& rhs) {
     return lhs > rhs.GetForComparison();
   }
   template <typename U>
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator>=(U* lhs, const raw_ptr& rhs) {
+  friend ALWAYS_INLINE bool operator>=(U* lhs, const raw_ptr& rhs) {
     return lhs >= rhs.GetForComparison();
   }
 
   // Comparisons with `std::nullptr_t`.
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator==(const raw_ptr& lhs,
-                                                 std::nullptr_t) {
+  friend ALWAYS_INLINE bool operator==(const raw_ptr& lhs, std::nullptr_t) {
     return !lhs;
   }
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator!=(const raw_ptr& lhs,
-                                                 std::nullptr_t) {
+  friend ALWAYS_INLINE bool operator!=(const raw_ptr& lhs, std::nullptr_t) {
     return !!lhs;  // Use !! otherwise the costly implicit cast will be used.
   }
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator==(std::nullptr_t,
-                                                 const raw_ptr& rhs) {
+  friend ALWAYS_INLINE bool operator==(std::nullptr_t, const raw_ptr& rhs) {
     return !rhs;
   }
-  friend RAW_PTR_FUNC_ATTRIBUTES bool operator!=(std::nullptr_t,
-                                                 const raw_ptr& rhs) {
+  friend ALWAYS_INLINE bool operator!=(std::nullptr_t, const raw_ptr& rhs) {
     return !!rhs;  // Use !! otherwise the costly implicit cast will be used.
   }
 
-  friend RAW_PTR_FUNC_ATTRIBUTES void swap(raw_ptr& lhs,
-                                           raw_ptr& rhs) noexcept {
+  friend ALWAYS_INLINE void swap(raw_ptr& lhs, raw_ptr& rhs) noexcept {
     Impl::IncrementSwapCountForTest();
     std::swap(lhs.wrapped_ptr_, rhs.wrapped_ptr_);
   }
 
+  // If T can be serialised into trace, its alias is also
+  // serialisable.
+  template <class U = T>
+  typename perfetto::check_traced_value_support<U>::type WriteIntoTrace(
+      perfetto::TracedValue&& context) const {
+    perfetto::WriteIntoTracedValue(std::move(context), get());
+  }
+
  private:
   // This getter is meant for situations where the pointer is meant to be
   // dereferenced. It is allowed to crash on nullptr (it may or may not),
   // because it knows that the caller will crash on nullptr.
-  RAW_PTR_FUNC_ATTRIBUTES T* GetForDereference() const {
+  ALWAYS_INLINE T* GetForDereference() const {
     return Impl::SafelyUnwrapPtrForDereference(wrapped_ptr_);
   }
   // This getter is meant for situations where the raw pointer is meant to be
   // extracted outside of this class, but not necessarily with an intention to
   // dereference. It mustn't crash on nullptr.
-  RAW_PTR_FUNC_ATTRIBUTES T* GetForExtraction() const {
+  ALWAYS_INLINE T* GetForExtraction() const {
     return Impl::SafelyUnwrapPtrForExtraction(wrapped_ptr_);
   }
   // This getter is meant *only* for situations where the pointer is meant to be
   // compared (guaranteeing no dereference or extraction outside of this class).
   // Any verifications can and should be skipped for performance reasons.
-  RAW_PTR_FUNC_ATTRIBUTES T* GetForComparison() const {
+  ALWAYS_INLINE T* GetForComparison() const {
     return Impl::UnsafelyUnwrapPtrForComparison(wrapped_ptr_);
   }
 
@@ -855,32 +1029,32 @@
 };
 
 template <typename U, typename V, typename I>
-RAW_PTR_FUNC_ATTRIBUTES bool operator==(const raw_ptr<U, I>& lhs,
-                                        const raw_ptr<V, I>& rhs) {
+ALWAYS_INLINE bool operator==(const raw_ptr<U, I>& lhs,
+                              const raw_ptr<V, I>& rhs) {
   return lhs.GetForComparison() == rhs.GetForComparison();
 }
 
 template <typename U, typename V, typename I>
-RAW_PTR_FUNC_ATTRIBUTES bool operator<(const raw_ptr<U, I>& lhs,
-                                       const raw_ptr<V, I>& rhs) {
+ALWAYS_INLINE bool operator<(const raw_ptr<U, I>& lhs,
+                             const raw_ptr<V, I>& rhs) {
   return lhs.GetForComparison() < rhs.GetForComparison();
 }
 
 template <typename U, typename V, typename I>
-RAW_PTR_FUNC_ATTRIBUTES bool operator>(const raw_ptr<U, I>& lhs,
-                                       const raw_ptr<V, I>& rhs) {
+ALWAYS_INLINE bool operator>(const raw_ptr<U, I>& lhs,
+                             const raw_ptr<V, I>& rhs) {
   return lhs.GetForComparison() > rhs.GetForComparison();
 }
 
 template <typename U, typename V, typename I>
-RAW_PTR_FUNC_ATTRIBUTES bool operator<=(const raw_ptr<U, I>& lhs,
-                                        const raw_ptr<V, I>& rhs) {
+ALWAYS_INLINE bool operator<=(const raw_ptr<U, I>& lhs,
+                              const raw_ptr<V, I>& rhs) {
   return lhs.GetForComparison() <= rhs.GetForComparison();
 }
 
 template <typename U, typename V, typename I>
-RAW_PTR_FUNC_ATTRIBUTES bool operator>=(const raw_ptr<U, I>& lhs,
-                                        const raw_ptr<V, I>& rhs) {
+ALWAYS_INLINE bool operator>=(const raw_ptr<U, I>& lhs,
+                              const raw_ptr<V, I>& rhs) {
   return lhs.GetForComparison() >= rhs.GetForComparison();
 }
 
@@ -888,6 +1062,17 @@
 
 using gurl_base::raw_ptr;
 
+// DisableDanglingPtrDetection option for raw_ptr annotates
+// "intentional-and-safe" dangling pointers. It is meant to be used at the
+// margin, only if there is no better way to re-architecture the code.
+//
+// Usage:
+// raw_ptr<T, DisableDanglingPtrDetection> dangling_ptr;
+//
+// When using it, please provide a justification about what guarantees it will
+// never be dereferenced after becoming dangling.
+using DisableDanglingPtrDetection = gurl_base::RawPtrMayDangle;
+
 namespace std {
 
 // Override so set/map lookups do not create extra raw_ptr. This also allows
diff --git a/base/ranges/algorithm.h b/base/ranges/algorithm.h
index b405d2f..f7a23c4 100644
--- a/base/ranges/algorithm.h
+++ b/base/ranges/algorithm.h
@@ -63,9 +63,9 @@
 
  private:
   template <typename ProjT, typename ProjU, typename T, typename U>
-  using InvokeResult = invoke_result_t<Pred&,
-                                       invoke_result_t<ProjT&, T&&>,
-                                       invoke_result_t<ProjU&, U&&>>;
+  using InvokeResult = std::invoke_result_t<Pred&,
+                                            std::invoke_result_t<ProjT&, T&&>,
+                                            std::invoke_result_t<ProjU&, U&&>>;
 
   template <typename T, typename U, typename = InvokeResult<Proj1, Proj2, T, U>>
   constexpr std::pair<Proj1&, Proj2&> GetProjs(priority_tag<3>) const {
diff --git a/base/strings/abseil_string_number_conversions.cc b/base/strings/abseil_string_number_conversions.cc
index 9ab1303..aab4905 100644
--- a/base/strings/abseil_string_number_conversions.cc
+++ b/base/strings/abseil_string_number_conversions.cc
@@ -10,6 +10,10 @@
 
 namespace gurl_base {
 
+bool StringToUint128(StringPiece input, absl::uint128* output) {
+  return internal::StringToIntImpl(input, *output);
+}
+
 bool HexStringToUInt128(StringPiece input, absl::uint128* output) {
   return internal::HexStringToIntImpl(input, *output);
 }
diff --git a/base/strings/abseil_string_number_conversions.h b/base/strings/abseil_string_number_conversions.h
index 7eb927d..85d6d29 100644
--- a/base/strings/abseil_string_number_conversions.h
+++ b/base/strings/abseil_string_number_conversions.h
@@ -15,7 +15,11 @@
 namespace gurl_base {
 
 // Best effort conversion, see `gurl_base::StringToInt()` for restrictions.
-// Will only successfully parse hex values that will fit into |output|.
+// Will only successfully parse values that will fit into `output`.
+BASE_EXPORT bool StringToUint128(StringPiece input, absl::uint128* output);
+
+// Best effort conversion, see `gurl_base::StringToInt()` for restrictions.
+// Will only successfully parse hex values that will fit into `output`.
 // The string is not required to start with 0x.
 BASE_EXPORT bool HexStringToUInt128(StringPiece input, absl::uint128* output);
 
diff --git a/base/strings/abseil_string_number_conversions_unittest.cc b/base/strings/abseil_string_number_conversions_unittest.cc
index 3c68cde..5873e79 100644
--- a/base/strings/abseil_string_number_conversions_unittest.cc
+++ b/base/strings/abseil_string_number_conversions_unittest.cc
@@ -8,13 +8,89 @@
 
 #include <limits>
 
-#include "base/cxx17_backports.h"
 #include "base/strings/string_piece.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "absl/numeric/int128.h"
 
 namespace gurl_base {
 
+TEST(AbseilStringNumberConversionsTest, StringToUint128) {
+  // Test cases adapted from `StringNumberConversionsTest.StringToUint64`.
+  static const struct {
+    std::string input;
+    absl::uint128 output;
+    bool success;
+  } cases[] = {
+      {"0", 0, true},
+      {"42", 42, true},
+      {"-2147483648", 0, false},
+      {"2147483647", INT_MAX, true},
+      {"-2147483649", 0, false},
+      {"-99999999999", 0, false},
+      {"2147483648", UINT64_C(2147483648), true},
+      {"99999999999", UINT64_C(99999999999), true},
+      {"9223372036854775807", std::numeric_limits<int64_t>::max(), true},
+      {"-9223372036854775808", 0, false},
+      {"09", 9, true},
+      {"-09", 0, false},
+      {"", 0, false},
+      {" 42", 42, false},
+      {"42 ", 42, false},
+      {"0x42", 0, false},
+      {"\t\n\v\f\r 42", 42, false},
+      {"blah42", 0, false},
+      {"42blah", 42, false},
+      {"blah42blah", 0, false},
+      {"-273.15", 0, false},
+      {"+98.6", 98, false},
+      {"--123", 0, false},
+      {"++123", 0, false},
+      {"-+123", 0, false},
+      {"+-123", 0, false},
+      {"-", 0, false},
+      {"-9223372036854775809", 0, false},
+      {"-99999999999999999999", 0, false},
+      {"9223372036854775808", UINT64_C(9223372036854775808), true},
+      {"99999999999999999999",
+       absl::MakeUint128(/*high=*/5, /*low=*/UINT64_C(7766279631452241919)),
+       true},
+      {"18446744073709551615", std::numeric_limits<uint64_t>::max(), true},
+      {"18446744073709551616", absl::MakeUint128(/*high=*/1, /*low=*/0), true},
+      {"123456789012345678901234567890123456789",
+       absl::MakeUint128(/*high=*/UINT64_C(6692605942763486917),
+                         /*low=*/UINT64_C(12312739301371248917)),
+       true},
+      {"-170141183460469231731687303715884105728", 0, false},
+      {"-170141183460469231731687303715884105729", 0, false},
+      {"-999999999999999999999999999999999999999", 0, false},
+      {"170141183460469231731687303715884105727",
+       std::numeric_limits<absl::int128>::max(), true},
+      {"340282366920938463463374607431768211455",
+       std::numeric_limits<absl::uint128>::max(), true},
+      {"340282366920938463463374607431768211456",
+       std::numeric_limits<absl::uint128>::max(), false},
+      {"999999999999999999999999999999999999999",
+       std::numeric_limits<absl::uint128>::max(), false},
+  };
+
+  for (const auto& i : cases) {
+    absl::uint128 output = 0;
+    EXPECT_EQ(i.success, StringToUint128(i.input, &output)) << i.input;
+    EXPECT_EQ(i.output, output);
+  }
+
+  // One additional test to verify that conversion of numbers in strings with
+  // embedded NUL characters.  The NUL and extra data after it should be
+  // interpreted as junk after the number.
+  const char input[] =
+      "6\0"
+      "6";
+  std::string input_string(input, std::size(input) - 1);
+  absl::uint128 output;
+  EXPECT_FALSE(StringToUint128(input_string, &output));
+  EXPECT_EQ(6U, output);
+}
+
 TEST(AbseilStringNumberConversionsTest, HexStringToUInt128) {
   // Test cases adapted from `StringNumberConversionsTest.HexStringToUint64`.
   static const struct {
@@ -93,7 +169,7 @@
   const char input[] =
       "0xc0ffee\0"
       "9";
-  std::string input_string(input, gurl_base::size(input) - 1);
+  std::string input_string(input, std::size(input) - 1);
   absl::uint128 output;
   EXPECT_FALSE(HexStringToUInt128(input_string, &output));
   EXPECT_EQ(0xc0ffeeU, output);
diff --git a/base/strings/char_traits.h b/base/strings/char_traits.h
deleted file mode 100644
index fe01c53..0000000
--- a/base/strings/char_traits.h
+++ /dev/null
@@ -1,112 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_STRINGS_CHAR_TRAITS_H_
-#define BASE_STRINGS_CHAR_TRAITS_H_
-
-#include <stddef.h>
-
-#include <string>
-
-#include "base/compiler_specific.h"
-
-namespace gurl_base {
-
-// constexpr version of http://en.cppreference.com/w/cpp/string/char_traits.
-// This currently just implements the bits needed to support a (mostly)
-// constexpr StringPiece.
-//
-// TODO(dcheng): Once we switch to C++17, most methods will become constexpr and
-// we can switch over to using the one in the standard library.
-template <typename T>
-struct CharTraits {
-  // Performs a lexographical comparison of the first N characters of |s1| and
-  // |s2|. Returns 0 if equal, -1 if |s1| is less than |s2|, and 1 if |s1| is
-  // greater than |s2|.
-  static constexpr int compare(const T* s1, const T* s2, size_t n) noexcept;
-
-  // Returns the length of |s|, assuming null termination (and not including the
-  // terminating null).
-  static constexpr size_t length(const T* s) noexcept;
-
-  // Searches for character |c| within the first |n| characters of the sequence
-  // pointed to by |s|.
-  static constexpr const T* find(const T* s, size_t n, T c);
-};
-
-template <typename T>
-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 (std::char_traits<T>::lt(*s1, *s2))
-      return -1;
-    if (std::char_traits<T>::lt(*s2, *s1))
-      return 1;
-  }
-  return 0;
-}
-
-template <typename T>
-constexpr size_t CharTraits<T>::length(const T* s) noexcept {
-  size_t i = 0;
-  for (; *s; ++s)
-    ++i;
-  return i;
-}
-
-template <typename T>
-constexpr const T* CharTraits<T>::find(const T* s, size_t n, T c) {
-  for (; n; --n, ++s) {
-    if (std::char_traits<T>::eq(*s, c))
-      return s;
-  }
-  return nullptr;
-}
-
-// 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 {
-    return __builtin_memcmp(s1, s2, n);
-  }
-
-  static constexpr size_t length(const char* s) noexcept {
-    return __builtin_strlen(s);
-  }
-
-  static constexpr const char* find(const char* s, size_t n, char c) {
-    return __builtin_char_memchr(s, c, n);
-  }
-};
-
-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);
-  }
-
-  static constexpr size_t length(const wchar_t* s) noexcept {
-    return __builtin_wcslen(s);
-  }
-
-  static constexpr const wchar_t* find(const wchar_t* s, size_t n, wchar_t c) {
-    return __builtin_wmemchr(s, c, n);
-  }
-};
-#endif
-
-}  // namespace base
-
-#endif  // BASE_STRINGS_CHAR_TRAITS_H_
diff --git a/base/strings/char_traits_unittest.cc b/base/strings/char_traits_unittest.cc
deleted file mode 100644
index d735d4a..0000000
--- a/base/strings/char_traits_unittest.cc
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2018 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/char_traits.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace gurl_base {
-
-TEST(CharTraitsTest, CharCompare) {
-  static_assert(CharTraits<char>::compare("abc", "def", 3) == -1, "");
-  static_assert(CharTraits<char>::compare("def", "def", 3) == 0, "");
-  static_assert(CharTraits<char>::compare("ghi", "def", 3) == 1, "");
-}
-
-TEST(CharTraitsTest, CharLength) {
-  static_assert(CharTraits<char>::length("") == 0, "");
-  static_assert(CharTraits<char>::length("abc") == 3, "");
-}
-
-TEST(CharTraitsTest, Char16TCompare) {
-  static_assert(CharTraits<char16_t>::compare(u"abc", u"def", 3) == -1, "");
-  static_assert(CharTraits<char16_t>::compare(u"def", u"def", 3) == 0, "");
-  static_assert(CharTraits<char16_t>::compare(u"ghi", u"def", 3) == 1, "");
-}
-
-TEST(CharTraitsTest, Char16TLength) {
-  static_assert(CharTraits<char16_t>::length(u"abc") == 3, "");
-}
-
-}  // namespace base
diff --git a/base/strings/escape.cc b/base/strings/escape.cc
index ff6f6d8..8324aae 100644
--- a/base/strings/escape.cc
+++ b/base/strings/escape.cc
@@ -4,15 +4,145 @@
 
 #include "base/strings/escape.h"
 
+#include <ostream>
+
+#include "polyfills/base/check_op.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversion_utils.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/third_party/icu/icu_utf.h"
 
 namespace gurl_base {
 
 namespace {
 
+const char kHexString[] = "0123456789ABCDEF";
+inline char IntToHex(int i) {
+  GURL_DCHECK_GE(i, 0) << i << " not a hex value";
+  GURL_DCHECK_LE(i, 15) << i << " not a hex value";
+  return kHexString[i];
+}
+
+// A fast bit-vector map for ascii characters.
+//
+// Internally stores 256 bits in an array of 8 ints.
+// Does quick bit-flicking to lookup needed characters.
+struct Charmap {
+  bool Contains(unsigned char c) const {
+    return ((map[c >> 5] & (1 << (c & 31))) != 0);
+  }
+
+  uint32_t map[8];
+};
+
+// Given text to escape and a Charmap defining which values to escape,
+// return an escaped string.  If use_plus is true, spaces are converted
+// to +, otherwise, if spaces are in the charmap, they are converted to
+// %20. And if keep_escaped is true, %XX will be kept as it is, otherwise, if
+// '%' is in the charmap, it is converted to %25.
+std::string Escape(StringPiece text,
+                   const Charmap& charmap,
+                   bool use_plus,
+                   bool keep_escaped = false) {
+  std::string escaped;
+  escaped.reserve(text.length() * 3);
+  for (unsigned int i = 0; i < text.length(); ++i) {
+    unsigned char c = static_cast<unsigned char>(text[i]);
+    if (use_plus && ' ' == c) {
+      escaped.push_back('+');
+    } else if (keep_escaped && '%' == c && i + 2 < text.length() &&
+               IsHexDigit(text[i + 1]) && IsHexDigit(text[i + 2])) {
+      escaped.push_back('%');
+    } else if (charmap.Contains(c)) {
+      escaped.push_back('%');
+      escaped.push_back(IntToHex(c >> 4));
+      escaped.push_back(IntToHex(c & 0xf));
+    } else {
+      escaped.push_back(c);
+    }
+  }
+  return escaped;
+}
+
+// Convert a character |c| to a form that will not be mistaken as HTML.
+template <class str>
+void AppendEscapedCharForHTMLImpl(typename str::value_type c, str* output) {
+  static constexpr struct {
+    char key;
+    StringPiece replacement;
+  } kCharsToEscape[] = {
+      {'<', "&lt;"},   {'>', "&gt;"},   {'&', "&amp;"},
+      {'"', "&quot;"}, {'\'', "&#39;"},
+  };
+  for (const auto& char_to_escape : kCharsToEscape) {
+    if (c == char_to_escape.key) {
+      output->append(std::begin(char_to_escape.replacement),
+                     std::end(char_to_escape.replacement));
+      return;
+    }
+  }
+  output->push_back(c);
+}
+
+// Convert |input| string to a form that will not be interpreted as HTML.
+template <typename T, typename CharT = typename T::value_type>
+std::basic_string<CharT> EscapeForHTMLImpl(T input) {
+  std::basic_string<CharT> result;
+  result.reserve(input.size());  // Optimize for no escaping.
+
+  for (auto c : input) {
+    AppendEscapedCharForHTMLImpl(c, &result);
+  }
+
+  return result;
+}
+
+// Everything except alphanumerics and -._~
+// See RFC 3986 for the list of unreserved characters.
+static const Charmap kUnreservedCharmap = {
+    {0xffffffffL, 0xfc009fffL, 0x78000001L, 0xb8000001L, 0xffffffffL,
+     0xffffffffL, 0xffffffffL, 0xffffffffL}};
+
+// Everything except alphanumerics and !'()*-._~
+// See RFC 2396 for the list of reserved characters.
+static const Charmap kQueryCharmap = {{0xffffffffL, 0xfc00987dL, 0x78000001L,
+                                       0xb8000001L, 0xffffffffL, 0xffffffffL,
+                                       0xffffffffL, 0xffffffffL}};
+
+// non-printable, non-7bit, and (including space)  "#%:<>?[\]^`{|}
+static const Charmap kPathCharmap = {{0xffffffffL, 0xd400002dL, 0x78000000L,
+                                      0xb8000001L, 0xffffffffL, 0xffffffffL,
+                                      0xffffffffL, 0xffffffffL}};
+
+#if BUILDFLAG(IS_APPLE)
+// non-printable, non-7bit, and (including space)  "#%<>[\]^`{|}
+static const Charmap kNSURLCharmap = {{0xffffffffL, 0x5000002dL, 0x78000000L,
+                                       0xb8000001L, 0xffffffffL, 0xffffffffL,
+                                       0xffffffffL, 0xffffffffL}};
+#endif  // BUILDFLAG(IS_APPLE)
+
+// non-printable, non-7bit, and (including space) ?>=<;+'&%$#"![\]^`{|}
+static const Charmap kUrlEscape = {{0xffffffffL, 0xf80008fdL, 0x78000001L,
+                                    0xb8000001L, 0xffffffffL, 0xffffffffL,
+                                    0xffffffffL, 0xffffffffL}};
+
+// non-7bit, as well as %.
+static const Charmap kNonASCIICharmapAndPercent = {
+    {0x00000000L, 0x00000020L, 0x00000000L, 0x00000000L, 0xffffffffL,
+     0xffffffffL, 0xffffffffL, 0xffffffffL}};
+
+// non-7bit
+static const Charmap kNonASCIICharmap = {{0x00000000L, 0x00000000L, 0x00000000L,
+                                          0x00000000L, 0xffffffffL, 0xffffffffL,
+                                          0xffffffffL, 0xffffffffL}};
+
+// Everything except alphanumerics, the reserved characters(;/?:@&=+$,) and
+// !'()*-._~#[]
+static const Charmap kExternalHandlerCharmap = {
+    {0xffffffffL, 0x50000025L, 0x50000000L, 0xb8000001L, 0xffffffffL,
+     0xffffffffL, 0xffffffffL, 0xffffffffL}};
+
 // Contains nonzero when the corresponding character is unescapable for normal
 // URLs. These characters are the ones that may change the parsing of a URL, so
 // we don't want to unescape them sometimes. In many case we won't want to
@@ -96,7 +226,7 @@
     // reach max character length number of bytes, or hit an unescaped
     // character. No need to check length of escaped_text, as
     // UnescapeUnsignedByteAtIndex checks lengths.
-    while (num_bytes < size(bytes) &&
+    while (num_bytes < std::size(bytes) &&
            UnescapeUnsignedByteAtIndex(escaped_text, index + num_bytes * 3,
                                        &bytes[num_bytes]) &&
            CBU8_IS_TRAIL(bytes[num_bytes])) {
@@ -331,6 +461,52 @@
 
 }  // namespace
 
+std::string EscapeAllExceptUnreserved(StringPiece text) {
+  return Escape(text, kUnreservedCharmap, false);
+}
+
+std::string EscapeQueryParamValue(StringPiece text, bool use_plus) {
+  return Escape(text, kQueryCharmap, use_plus);
+}
+
+std::string EscapePath(StringPiece path) {
+  return Escape(path, kPathCharmap, false);
+}
+
+#if BUILDFLAG(IS_APPLE)
+std::string EscapeNSURLPrecursor(StringPiece precursor) {
+  return Escape(precursor, kNSURLCharmap, false, true);
+}
+#endif  // BUILDFLAG(IS_APPLE)
+
+std::string EscapeUrlEncodedData(StringPiece path, bool use_plus) {
+  return Escape(path, kUrlEscape, use_plus);
+}
+
+std::string EscapeNonASCIIAndPercent(StringPiece input) {
+  return Escape(input, kNonASCIICharmapAndPercent, false);
+}
+
+std::string EscapeNonASCII(StringPiece input) {
+  return Escape(input, kNonASCIICharmap, false);
+}
+
+std::string EscapeExternalHandlerValue(StringPiece text) {
+  return Escape(text, kExternalHandlerCharmap, false, true);
+}
+
+void AppendEscapedCharForHTML(char c, std::string* output) {
+  AppendEscapedCharForHTMLImpl(c, output);
+}
+
+std::string EscapeForHTML(StringPiece input) {
+  return EscapeForHTMLImpl(input);
+}
+
+std::u16string EscapeForHTML(StringPiece16 input) {
+  return EscapeForHTMLImpl(input);
+}
+
 std::string UnescapeURLComponent(StringPiece escaped_text,
                                  UnescapeRule::Type rules) {
   return UnescapeURLWithAdjustmentsImpl(escaped_text, rules, nullptr);
@@ -441,4 +617,39 @@
   return false;
 }
 
-}  // namespace base
\ No newline at end of file
+std::u16string UnescapeForHTML(StringPiece16 input) {
+  static const struct {
+    const char* ampersand_code;
+    const char replacement;
+  } kEscapeToChars[] = {
+      {"&lt;", '<'},   {"&gt;", '>'},   {"&amp;", '&'},
+      {"&quot;", '"'}, {"&#39;", '\''},
+  };
+  constexpr size_t kEscapeToCharsCount = std::size(kEscapeToChars);
+
+  if (input.find(u"&") == std::string::npos)
+    return std::u16string(input);
+
+  std::u16string ampersand_chars[kEscapeToCharsCount];
+  std::u16string text(input);
+  for (std::u16string::iterator iter = text.begin(); iter != text.end();
+       ++iter) {
+    if (*iter == '&') {
+      // Potential ampersand encode char.
+      size_t index = iter - text.begin();
+      for (size_t i = 0; i < std::size(kEscapeToChars); i++) {
+        if (ampersand_chars[i].empty()) {
+          ampersand_chars[i] = ASCIIToUTF16(kEscapeToChars[i].ampersand_code);
+        }
+        if (text.find(ampersand_chars[i], index) == index) {
+          text.replace(iter, iter + ampersand_chars[i].length(), 1,
+                       kEscapeToChars[i].replacement);
+          break;
+        }
+      }
+    }
+  }
+  return text;
+}
+
+}  // namespace base
diff --git a/base/strings/escape.h b/base/strings/escape.h
index 96ce110..57f2f9a 100644
--- a/base/strings/escape.h
+++ b/base/strings/escape.h
@@ -16,6 +16,58 @@
 
 namespace gurl_base {
 
+// Escaping --------------------------------------------------------------------
+
+// Escapes all characters except unreserved characters. Unreserved characters,
+// as defined in RFC 3986, include alphanumerics and -._~
+BASE_EXPORT std::string EscapeAllExceptUnreserved(StringPiece text);
+
+// Escapes characters in text suitable for use as a query parameter value.
+// We %XX everything except alphanumerics and -_.!~*'()
+// Spaces change to "+" unless you pass usePlus=false.
+// This is basically the same as encodeURIComponent in javascript.
+BASE_EXPORT std::string EscapeQueryParamValue(StringPiece text, bool use_plus);
+
+// Escapes a partial or complete file/pathname.  This includes:
+// non-printable, non-7bit, and (including space)  "#%:<>?[\]^`{|}
+BASE_EXPORT std::string EscapePath(StringPiece path);
+
+#if BUILDFLAG(IS_APPLE)
+// Escapes characters as per expectations of NSURL. This includes:
+// non-printable, non-7bit, and (including space)  "#%<>[\]^`{|}
+BASE_EXPORT std::string EscapeNSURLPrecursor(StringPiece precursor);
+#endif  // BUILDFLAG(IS_APPLE)
+
+// Escapes application/x-www-form-urlencoded content.  This includes:
+// non-printable, non-7bit, and (including space)  ?>=<;+'&%$#"![\]^`{|}
+// Space is escaped as + (if use_plus is true) and other special characters
+// as %XX (hex).
+BASE_EXPORT std::string EscapeUrlEncodedData(StringPiece path, bool use_plus);
+
+// Escapes all non-ASCII input, as well as escaping % to %25.
+BASE_EXPORT std::string EscapeNonASCIIAndPercent(StringPiece input);
+
+// Escapes all non-ASCII input. Note this function leaves % unescaped, which
+// means the unescaping the resulting string will not give back the original
+// input.
+BASE_EXPORT std::string EscapeNonASCII(StringPiece input);
+
+// Escapes characters in text suitable for use as an external protocol handler
+// command.
+// We %XX everything except alphanumerics and -_.!~*'() and the restricted
+// characters (;/?:@&=+$,#[]) and a valid percent escape sequence (%XX).
+BASE_EXPORT std::string EscapeExternalHandlerValue(StringPiece text);
+
+// Appends the given character to the output string, escaping the character if
+// the character would be interpreted as an HTML delimiter.
+BASE_EXPORT void AppendEscapedCharForHTML(char c, std::string* output);
+
+// Escapes chars that might cause this text to be interpreted as HTML tags.
+BASE_EXPORT std::string EscapeForHTML(StringPiece text);
+BASE_EXPORT std::u16string EscapeForHTML(StringPiece16 text);
+
+// Unescaping ------------------------------------------------------------------
+
 class UnescapeRule {
  public:
   // A combination of the following flags that is passed to the unescaping
@@ -115,6 +167,10 @@
 BASE_EXPORT bool ContainsEncodedBytes(StringPiece escaped_text,
                                       const std::set<unsigned char>& bytes);
 
+// Unescapes the following ampersand character codes from |text|:
+// &lt; &gt; &amp; &quot; &#39;
+BASE_EXPORT std::u16string UnescapeForHTML(StringPiece16 text);
+
 }  // namespace base
 
 #endif  // BASE_STRINGS_ESCAPE_H_
diff --git a/base/strings/escape_unittest.cc b/base/strings/escape_unittest.cc
index 923eb5a..182e83f 100644
--- a/base/strings/escape_unittest.cc
+++ b/base/strings/escape_unittest.cc
@@ -8,10 +8,22 @@
 #include "base/strings/escape.h"
 
 #include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gurl_base {
+namespace {
+
+struct EscapeCase {
+  const char* input;
+  const char* output;
+};
+
+struct EscapeForHTMLCase {
+  const char* input;
+  const char* expected_output;
+};
 
 struct UnescapeURLCase {
   const char* input;
@@ -38,6 +50,155 @@
   size_t output_offset;
 };
 
+TEST(EscapeTest, EscapeTextForFormSubmission) {
+  const EscapeCase escape_cases[] = {
+      {"foo", "foo"}, {"foo bar", "foo+bar"}, {"foo++", "foo%2B%2B"}};
+  for (const auto& escape_case : escape_cases) {
+    EXPECT_EQ(escape_case.output,
+              EscapeQueryParamValue(escape_case.input, true));
+  }
+
+  const EscapeCase escape_cases_no_plus[] = {
+      {"foo", "foo"}, {"foo bar", "foo%20bar"}, {"foo++", "foo%2B%2B"}};
+  for (const auto& escape_case : escape_cases_no_plus) {
+    EXPECT_EQ(escape_case.output,
+              EscapeQueryParamValue(escape_case.input, false));
+  }
+
+  // Test all the values in we're supposed to be escaping.
+  const std::string no_escape(
+      "abcdefghijklmnopqrstuvwxyz"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+      "0123456789"
+      "!'()*-._~");
+  for (int i = 0; i < 256; ++i) {
+    std::string in;
+    in.push_back(i);
+    std::string out = EscapeQueryParamValue(in, true);
+    if (0 == i) {
+      EXPECT_EQ(out, std::string("%00"));
+    } else if (32 == i) {
+      // Spaces are plus escaped like web forms.
+      EXPECT_EQ(out, std::string("+"));
+    } else if (no_escape.find(in) == std::string::npos) {
+      // Check %hex escaping
+      std::string expected = StringPrintf("%%%02X", i);
+      EXPECT_EQ(expected, out);
+    } else {
+      // No change for things in the no_escape list.
+      EXPECT_EQ(out, in);
+    }
+  }
+}
+
+TEST(EscapeTest, EscapePath) {
+  ASSERT_EQ(
+      // Most of the character space we care about, un-escaped
+      EscapePath("\x02\n\x1d !\"#$%&'()*+,-./0123456789:;"
+                 "<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                 "[\\]^_`abcdefghijklmnopqrstuvwxyz"
+                 "{|}~\x7f\x80\xff"),
+      // Escaped
+      "%02%0A%1D%20!%22%23$%25&'()*+,-./0123456789%3A;"
+      "%3C=%3E%3F@ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+      "%5B%5C%5D%5E_%60abcdefghijklmnopqrstuvwxyz"
+      "%7B%7C%7D~%7F%80%FF");
+}
+
+TEST(EscapeTest, EscapeUrlEncodedData) {
+  ASSERT_EQ(
+      // Most of the character space we care about, un-escaped
+      EscapeUrlEncodedData("\x02\n\x1d !\"#$%&'()*+,-./0123456789:;"
+                           "<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                           "[\\]^_`abcdefghijklmnopqrstuvwxyz"
+                           "{|}~\x7f\x80\xff",
+                           true),
+      // Escaped
+      "%02%0A%1D+!%22%23%24%25%26%27()*%2B,-./0123456789:%3B"
+      "%3C%3D%3E%3F%40ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+      "%5B%5C%5D%5E_%60abcdefghijklmnopqrstuvwxyz"
+      "%7B%7C%7D~%7F%80%FF");
+}
+
+TEST(EscapeTest, EscapeUrlEncodedDataSpace) {
+  ASSERT_EQ(EscapeUrlEncodedData("a b", true), "a+b");
+  ASSERT_EQ(EscapeUrlEncodedData("a b", false), "a%20b");
+}
+
+TEST(EscapeTest, EscapeForHTML) {
+  const EscapeForHTMLCase tests[] = {
+      {"hello", "hello"},
+      {"<hello>", "&lt;hello&gt;"},
+      {"don\'t mess with me", "don&#39;t mess with me"},
+  };
+  for (const auto& test : tests) {
+    std::string result = EscapeForHTML(std::string(test.input));
+    EXPECT_EQ(std::string(test.expected_output), result);
+  }
+}
+
+TEST(EscapeTest, UnescapeForHTML) {
+  const EscapeForHTMLCase tests[] = {
+      {"", ""},
+      {"&lt;hello&gt;", "<hello>"},
+      {"don&#39;t mess with me", "don\'t mess with me"},
+      {"&lt;&gt;&amp;&quot;&#39;", "<>&\"'"},
+      {"& lt; &amp ; &; '", "& lt; &amp ; &; '"},
+      {"&amp;", "&"},
+      {"&quot;", "\""},
+      {"&#39;", "'"},
+      {"&lt;", "<"},
+      {"&gt;", ">"},
+      {"&amp; &", "& &"},
+  };
+  for (const auto& test : tests) {
+    std::u16string result = UnescapeForHTML(ASCIIToUTF16(test.input));
+    EXPECT_EQ(ASCIIToUTF16(test.expected_output), result);
+  }
+}
+
+TEST(EscapeTest, EscapeExternalHandlerValue) {
+  ASSERT_EQ(
+      // Escaped
+      "%02%0A%1D%20!%22#$%25&'()*+,-./0123456789:;"
+      "%3C=%3E?@ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+      "[%5C]%5E_%60abcdefghijklmnopqrstuvwxyz"
+      "%7B%7C%7D~%7F%80%FF",
+      // Most of the character space we care about, un-escaped
+      EscapeExternalHandlerValue("\x02\n\x1d !\"#$%&'()*+,-./0123456789:;"
+                                 "<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                 "[\\]^_`abcdefghijklmnopqrstuvwxyz"
+                                 "{|}~\x7f\x80\xff"));
+
+  ASSERT_EQ(
+      "!#$&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]_"
+      "abcdefghijklmnopqrstuvwxyz~",
+      EscapeExternalHandlerValue(
+          "!#$&'()*+,-./0123456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]_"
+          "abcdefghijklmnopqrstuvwxyz~"));
+
+  ASSERT_EQ("%258k", EscapeExternalHandlerValue("%8k"));
+  ASSERT_EQ("a%25", EscapeExternalHandlerValue("a%"));
+  ASSERT_EQ("%25a", EscapeExternalHandlerValue("%a"));
+  ASSERT_EQ("a%258", EscapeExternalHandlerValue("a%8"));
+  ASSERT_EQ("%ab", EscapeExternalHandlerValue("%ab"));
+  ASSERT_EQ("%AB", EscapeExternalHandlerValue("%AB"));
+
+  ASSERT_EQ("http://example.com/path/sub?q=a%7Cb%7Cc&q=1%7C2%7C3#ref%7C",
+            EscapeExternalHandlerValue(
+                "http://example.com/path/sub?q=a|b|c&q=1|2|3#ref|"));
+  ASSERT_EQ("http://example.com/path/sub?q=a%7Cb%7Cc&q=1%7C2%7C3#ref%7C",
+            EscapeExternalHandlerValue(
+                "http://example.com/path/sub?q=a%7Cb%7Cc&q=1%7C2%7C3#ref%7C"));
+  ASSERT_EQ("http://[2001:db8:0:1]:80",
+            EscapeExternalHandlerValue("http://[2001:db8:0:1]:80"));
+}
+
+TEST(EscapeTest, EscapeNonASCII) {
+  EXPECT_EQ("abc\n%2580%80", EscapeNonASCIIAndPercent("abc\n%80\x80"));
+  EXPECT_EQ("abc\n%80%80", EscapeNonASCII("abc\n%80\x80"));
+}
+
 TEST(EscapeTest, DataURLWithAccentedCharacters) {
   const std::string url =
       "text/html;charset=utf-8,%3Chtml%3E%3Cbody%3ETonton,%20ton%20th%C3"
@@ -427,4 +588,5 @@
       ContainsEncodedBytes("caf%C3%A9", {static_cast<uint8_t>('\xe9')}));
 }
 
+}  // namespace
 }  // namespace base
diff --git a/base/strings/string_number_conversions_internal.h b/base/strings/string_number_conversions_internal.h
index 8c45d1b..6de9e2e 100644
--- a/base/strings/string_number_conversions_internal.h
+++ b/base/strings/string_number_conversions_internal.h
@@ -12,7 +12,7 @@
 
 #include <limits>
 
-#include "polyfills/base/check_op.h"
+#include "polyfills/base/check.h"
 #include "polyfills/base/logging.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/string_util.h"
diff --git a/base/strings/string_number_conversions_unittest.cc b/base/strings/string_number_conversions_unittest.cc
index b5a23a1..34f811e 100644
--- a/base/strings/string_number_conversions_unittest.cc
+++ b/base/strings/string_number_conversions_unittest.cc
@@ -14,7 +14,6 @@
 #include <limits>
 
 #include "base/bit_cast.h"
-#include "base/cxx17_backports.h"
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ -154,8 +153,10 @@
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
-  const char input[] = "6\06";
-  std::string input_string(input, gurl_base::size(input) - 1);
+  const char input[] =
+      "6\0"
+      "6";
+  std::string input_string(input, std::size(input) - 1);
   int output;
   EXPECT_FALSE(StringToInt(input_string, &output));
   EXPECT_EQ(6, output);
@@ -220,8 +221,10 @@
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
-  const char input[] = "6\06";
-  std::string input_string(input, gurl_base::size(input) - 1);
+  const char input[] =
+      "6\0"
+      "6";
+  std::string input_string(input, std::size(input) - 1);
   unsigned output;
   EXPECT_FALSE(StringToUint(input_string, &output));
   EXPECT_EQ(6U, output);
@@ -290,8 +293,10 @@
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
-  const char input[] = "6\06";
-  std::string input_string(input, gurl_base::size(input) - 1);
+  const char input[] =
+      "6\0"
+      "6";
+  std::string input_string(input, std::size(input) - 1);
   int64_t output;
   EXPECT_FALSE(StringToInt64(input_string, &output));
   EXPECT_EQ(6, output);
@@ -357,8 +362,10 @@
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
-  const char input[] = "6\06";
-  std::string input_string(input, gurl_base::size(input) - 1);
+  const char input[] =
+      "6\0"
+      "6";
+  std::string input_string(input, std::size(input) - 1);
   uint64_t output;
   EXPECT_FALSE(StringToUint64(input_string, &output));
   EXPECT_EQ(6U, output);
@@ -426,8 +433,10 @@
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
-  const char input[] = "6\06";
-  std::string input_string(input, gurl_base::size(input) - 1);
+  const char input[] =
+      "6\0"
+      "6";
+  std::string input_string(input, std::size(input) - 1);
   size_t output;
   EXPECT_FALSE(StringToSizeT(input_string, &output));
   EXPECT_EQ(6U, output);
@@ -486,7 +495,7 @@
   const char input[] =
       "0xc0ffee\0"
       "9";
-  std::string input_string(input, gurl_base::size(input) - 1);
+  std::string input_string(input, std::size(input) - 1);
   int output;
   EXPECT_FALSE(HexStringToInt(input_string, &output));
   EXPECT_EQ(0xc0ffee, output);
@@ -553,7 +562,7 @@
   const char input[] =
       "0xc0ffee\0"
       "9";
-  std::string input_string(input, gurl_base::size(input) - 1);
+  std::string input_string(input, std::size(input) - 1);
   uint32_t output;
   EXPECT_FALSE(HexStringToUInt(input_string, &output));
   EXPECT_EQ(0xc0ffeeU, output);
@@ -614,7 +623,7 @@
   const char input[] =
       "0xc0ffee\0"
       "9";
-  std::string input_string(input, gurl_base::size(input) - 1);
+  std::string input_string(input, std::size(input) - 1);
   int64_t output;
   EXPECT_FALSE(HexStringToInt64(input_string, &output));
   EXPECT_EQ(0xc0ffee, output);
@@ -679,7 +688,7 @@
   const char input[] =
       "0xc0ffee\0"
       "9";
-  std::string input_string(input, gurl_base::size(input) - 1);
+  std::string input_string(input, std::size(input) - 1);
   uint64_t output;
   EXPECT_FALSE(HexStringToUInt64(input_string, &output));
   EXPECT_EQ(0xc0ffeeU, output);
@@ -712,7 +721,7 @@
        11, true},
   };
 
-  for (size_t test_i = 0; test_i < gurl_base::size(cases); ++test_i) {
+  for (size_t test_i = 0; test_i < std::size(cases); ++test_i) {
     const auto& test = cases[test_i];
 
     std::string expected_output(test.output, test.output_len);
@@ -855,7 +864,7 @@
        -1.0000000000000001e-259, true},
   };
 
-  for (size_t i = 0; i < gurl_base::size(cases); ++i) {
+  for (size_t i = 0; i < std::size(cases); ++i) {
     SCOPED_TRACE(
         StringPrintf("case %" PRIuS " \"%s\"", i, cases[i].input.c_str()));
     double output;
@@ -872,7 +881,7 @@
   const char input[] =
       "3.14\0"
       "159";
-  std::string input_string(input, gurl_base::size(input) - 1);
+  std::string input_string(input, std::size(input) - 1);
   double output;
   EXPECT_FALSE(StringToDouble(input_string, &output));
   EXPECT_DOUBLE_EQ(3.14, output);
@@ -901,12 +910,12 @@
   // The following two values were seen in crashes in the wild.
   const char input_bytes[8] = {0, 0, 0, 0, '\xee', '\x6d', '\x73', '\x42'};
   double input = 0;
-  memcpy(&input, input_bytes, gurl_base::size(input_bytes));
+  memcpy(&input, input_bytes, std::size(input_bytes));
   EXPECT_EQ("1.335179083776e+12", NumberToString(input));
   const char input_bytes2[8] = {0,      0,      0,      '\xa0',
                                 '\xda', '\x6c', '\x73', '\x42'};
   input = 0;
-  memcpy(&input, input_bytes2, gurl_base::size(input_bytes2));
+  memcpy(&input, input_bytes2, std::size(input_bytes2));
   EXPECT_EQ("1.33489033216e+12", NumberToString(input));
 }
 
diff --git a/base/strings/string_piece.h b/base/strings/string_piece.h
index 8d7f2c5..21ee624 100644
--- a/base/strings/string_piece.h
+++ b/base/strings/string_piece.h
@@ -30,9 +30,9 @@
 #include <type_traits>
 
 #include "polyfills/base/base_export.h"
+#include "polyfills/base/check.h"
 #include "polyfills/base/check_op.h"
 #include "base/compiler_specific.h"
-#include "base/strings/char_traits.h"
 #include "base/strings/string_piece_forward.h"
 #include "build/build_config.h"
 
@@ -118,10 +118,8 @@
       default;
   constexpr BasicStringPiece(const CharT* s, size_type count)
       : ptr_(s), length_(count) {}
-  // Note: This doesn't just use traits_type::length(), since that
-  // isn't constexpr until C++17.
   constexpr BasicStringPiece(const CharT* s)
-      : ptr_(s), length_(s ? CharTraits<CharT>::length(s) : 0) {
+      : ptr_(s), length_(s ? traits_type::length(s) : 0) {
     // Intentional STL deviation: Null-check instead of UB.
     GURL_CHECK(s);
   }
@@ -229,7 +227,7 @@
 
   constexpr int compare(BasicStringPiece v) const noexcept {
     const size_type rlen = std::min(size(), v.size());
-    const int result = CharTraits<CharT>::compare(data(), v.data(), rlen);
+    const int result = traits_type::compare(data(), v.data(), rlen);
     if (result != 0)
       return result;
     if (size() == v.size())
@@ -282,7 +280,7 @@
       return npos;
 
     const const_pointer result =
-        gurl_base::CharTraits<CharT>::find(data() + pos, size() - pos, ch);
+        traits_type::find(data() + pos, size() - pos, ch);
     return result ? static_cast<size_type>(result - data()) : npos;
   }
   constexpr size_type find(const CharT* s,
diff --git a/base/strings/string_tokenizer.h b/base/strings/string_tokenizer.h
index 14db1e1..e85bf45 100644
--- a/base/strings/string_tokenizer.h
+++ b/base/strings/string_tokenizer.h
@@ -8,6 +8,7 @@
 #include <algorithm>
 #include <string>
 
+#include "polyfills/base/check.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 
diff --git a/base/strings/string_util.cc b/base/strings/string_util.cc
index 2adfa94..937c603 100644
--- a/base/strings/string_util.cc
+++ b/base/strings/string_util.cc
@@ -22,7 +22,6 @@
 #include <vector>
 
 #include "polyfills/base/check_op.h"
-#include "base/cxx17_backports.h"
 #include "base/no_destructor.h"
 #include "base/strings/string_util_internal.h"
 #include "base/strings/utf_string_conversion_utils.h"
@@ -336,17 +335,17 @@
   size_t dimension = 0;
   const int kKilo = 1024;
   while (unit_amount >= kKilo &&
-         dimension < gurl_base::size(kByteStringsUnlocalized) - 1) {
+         dimension < std::size(kByteStringsUnlocalized) - 1) {
     unit_amount /= kKilo;
     dimension++;
   }
 
   char buf[64];
   if (bytes != 0 && dimension > 0 && unit_amount < 100) {
-    gurl_base::snprintf(buf, gurl_base::size(buf), "%.1lf%s", unit_amount,
+    gurl_base::snprintf(buf, std::size(buf), "%.1lf%s", unit_amount,
                    kByteStringsUnlocalized[dimension]);
   } else {
-    gurl_base::snprintf(buf, gurl_base::size(buf), "%.0lf%s", unit_amount,
+    gurl_base::snprintf(buf, std::size(buf), "%.0lf%s", unit_amount,
                    kByteStringsUnlocalized[dimension]);
   }
 
diff --git a/base/strings/string_util.h b/base/strings/string_util.h
index 5d570e2..cd90a94 100644
--- a/base/strings/string_util.h
+++ b/base/strings/string_util.h
@@ -18,6 +18,7 @@
 #include <vector>
 
 #include "polyfills/base/base_export.h"
+#include "polyfills/base/check_op.h"
 #include "base/compiler_specific.h"
 #include "base/containers/span.h"
 #include "base/cxx20_to_address.h"
diff --git a/base/strings/string_util_internal.h b/base/strings/string_util_internal.h
index 07f4930..2497c8d 100644
--- a/base/strings/string_util_internal.h
+++ b/base/strings/string_util_internal.h
@@ -7,6 +7,8 @@
 
 #include <algorithm>
 
+#include "polyfills/base/check.h"
+#include "polyfills/base/check_op.h"
 #include "polyfills/base/logging.h"
 #include "polyfills/base/notreached.h"
 #include "base/ranges/algorithm.h"
@@ -523,7 +525,7 @@
           typename T,
           typename CharT = typename T::value_type>
 static std::basic_string<CharT> JoinStringT(list_type parts, T sep) {
-  if (gurl_base::empty(parts))
+  if (std::empty(parts))
     return std::basic_string<CharT>();
 
   // Pre-allocate the eventual size of the string. Start with the size of all of
diff --git a/base/strings/string_util_unittest.cc b/base/strings/string_util_unittest.cc
index 231c3c8..b5d9a67 100644
--- a/base/strings/string_util_unittest.cc
+++ b/base/strings/string_util_unittest.cc
@@ -14,7 +14,6 @@
 #include <type_traits>
 
 #include "base/bits.h"
-#include "base/cxx17_backports.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
@@ -218,14 +217,14 @@
 
   {
     const char array[] = "\x00\x00\xc2\x81\xc2\x81";
-    const std::string array_string(array, gurl_base::size(array));
+    const std::string array_string(array, std::size(array));
     EXPECT_TRUE(Truncated(array_string, 4, &output));
     EXPECT_EQ(output.compare(std::string("\x00\x00\xc2\x81", 4)), 0);
   }
 
   {
     const char array[] = "\x00\xc2\x81\xc2\x81";
-    const std::string array_string(array, gurl_base::size(array));
+    const std::string array_string(array, std::size(array));
     EXPECT_TRUE(Truncated(array_string, 4, &output));
     EXPECT_EQ(output.compare(std::string("\x00\xc2\x81", 3)), 0);
   }
@@ -292,7 +291,7 @@
 
   {
     const char array[] = "\x00\x00\xfe\xff";
-    const std::string array_string(array, gurl_base::size(array));
+    const std::string array_string(array, std::size(array));
     EXPECT_TRUE(Truncated(array_string, 4, &output));
     EXPECT_EQ(output.compare(std::string("\x00\x00", 2)), 0);
   }
@@ -306,7 +305,7 @@
   }
   {
     const char array[] = "\xff\x00\x00\xfe";
-    const std::string array_string(array, gurl_base::size(array));
+    const std::string array_string(array, std::size(array));
     EXPECT_TRUE(Truncated(array_string, 4, &output));
     EXPECT_EQ(output.compare(std::string("\xff\x00\x00", 3)), 0);
   }
@@ -536,7 +535,7 @@
   // Also, test that a non-ASCII character will be detected regardless of its
   // position inside the string.
   {
-    const size_t string_length = gurl_base::size(char_ascii) - 1;
+    const size_t string_length = std::size(char_ascii) - 1;
     for (size_t offset = 0; offset < 8; ++offset) {
       for (size_t len = 0, max_len = string_length - offset; len < max_len;
            ++len) {
@@ -551,7 +550,7 @@
   }
 
   {
-    const size_t string_length = gurl_base::size(char16_ascii) - 1;
+    const size_t string_length = std::size(char16_ascii) - 1;
     for (size_t offset = 0; offset < 4; ++offset) {
       for (size_t len = 0, max_len = string_length - offset; len < max_len;
            ++len) {
@@ -605,7 +604,7 @@
     L"0123ABCDwxyz \a\b\t\r\n!+,.~"
   };
 
-  for (size_t i = 0; i < gurl_base::size(char_cases); ++i) {
+  for (size_t i = 0; i < std::size(char_cases); ++i) {
     EXPECT_TRUE(IsStringASCII(char_cases[i]));
     std::u16string utf16 = ASCIIToUTF16(char_cases[i]);
     EXPECT_EQ(WideToUTF16(wchar_cases[i]), utf16);
@@ -624,7 +623,7 @@
 
   // Convert strings with an embedded NUL character.
   const char chars_with_nul[] = "test\0string";
-  const int length_with_nul = gurl_base::size(chars_with_nul) - 1;
+  const int length_with_nul = std::size(chars_with_nul) - 1;
   std::string string_with_nul(chars_with_nul, length_with_nul);
   std::u16string string16_with_nul = ASCIIToUTF16(string_with_nul);
   EXPECT_EQ(static_cast<std::u16string::size_type>(length_with_nul),
@@ -1219,9 +1218,9 @@
   {
     char dst[10];
     wchar_t wdst[10];
-    EXPECT_EQ(7U, strlcpy(dst, "abcdefg", gurl_base::size(dst)));
+    EXPECT_EQ(7U, strlcpy(dst, "abcdefg", std::size(dst)));
     EXPECT_EQ(0, memcmp(dst, "abcdefg", 8));
-    EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", gurl_base::size(wdst)));
+    EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", std::size(wdst)));
     EXPECT_EQ(0, memcmp(wdst, L"abcdefg", sizeof(wchar_t) * 8));
   }
 
@@ -1242,9 +1241,9 @@
   {
     char dst[8];
     wchar_t wdst[8];
-    EXPECT_EQ(7U, strlcpy(dst, "abcdefg", gurl_base::size(dst)));
+    EXPECT_EQ(7U, strlcpy(dst, "abcdefg", std::size(dst)));
     EXPECT_EQ(0, memcmp(dst, "abcdefg", 8));
-    EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", gurl_base::size(wdst)));
+    EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", std::size(wdst)));
     EXPECT_EQ(0, memcmp(wdst, L"abcdefg", sizeof(wchar_t) * 8));
   }
 
@@ -1252,9 +1251,9 @@
   {
     char dst[7];
     wchar_t wdst[7];
-    EXPECT_EQ(7U, strlcpy(dst, "abcdefg", gurl_base::size(dst)));
+    EXPECT_EQ(7U, strlcpy(dst, "abcdefg", std::size(dst)));
     EXPECT_EQ(0, memcmp(dst, "abcdef", 7));
-    EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", gurl_base::size(wdst)));
+    EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", std::size(wdst)));
     EXPECT_EQ(0, memcmp(wdst, L"abcdef", sizeof(wchar_t) * 7));
   }
 
@@ -1262,9 +1261,9 @@
   {
     char dst[3];
     wchar_t wdst[3];
-    EXPECT_EQ(7U, strlcpy(dst, "abcdefg", gurl_base::size(dst)));
+    EXPECT_EQ(7U, strlcpy(dst, "abcdefg", std::size(dst)));
     EXPECT_EQ(0, memcmp(dst, "ab", 3));
-    EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", gurl_base::size(wdst)));
+    EXPECT_EQ(7U, wcslcpy(wdst, L"abcdefg", std::size(wdst)));
     EXPECT_EQ(0, memcmp(wdst, L"ab", sizeof(wchar_t) * 3));
   }
 }
@@ -1504,7 +1503,7 @@
     // Using std::string(buffer.c_str()) instead of |buffer| truncates the
     // string at the first \0.
     EXPECT_EQ(
-        std::string(kOriginal, std::min(num_chars, gurl_base::size(kOriginal) - 1)),
+        std::string(kOriginal, std::min(num_chars, std::size(kOriginal) - 1)),
         std::string(buffer.c_str()));
     EXPECT_EQ(num_chars, buffer.size());
   }
diff --git a/base/strings/stringprintf.cc b/base/strings/stringprintf.cc
index aed9b04..e0c5e20 100644
--- a/base/strings/stringprintf.cc
+++ b/base/strings/stringprintf.cc
@@ -9,11 +9,9 @@
 
 #include <vector>
 
-#include "base/cxx17_backports.h"
 #include "polyfills/base/logging.h"
 #include "base/scoped_clear_last_error.h"
 #include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 
 namespace gurl_base {
@@ -64,17 +62,17 @@
   va_copy(ap_copy, ap);
 
   gurl_base::ScopedClearLastError last_error;
-  int result = vsnprintfT(stack_buf, gurl_base::size(stack_buf), format, ap_copy);
+  int result = vsnprintfT(stack_buf, std::size(stack_buf), format, ap_copy);
   va_end(ap_copy);
 
-  if (result >= 0 && result < static_cast<int>(gurl_base::size(stack_buf))) {
+  if (result >= 0 && result < static_cast<int>(std::size(stack_buf))) {
     // It fit.
     dst->append(stack_buf, result);
     return;
   }
 
   // Repeatedly increase buffer size until it fits.
-  int mem_length = gurl_base::size(stack_buf);
+  int mem_length = std::size(stack_buf);
   while (true) {
     if (result < 0) {
 #if BUILDFLAG(IS_WIN)
diff --git a/base/strings/utf_offset_string_conversions_unittest.cc b/base/strings/utf_offset_string_conversions_unittest.cc
index f50fa3f..83bbc35 100644
--- a/base/strings/utf_offset_string_conversions_unittest.cc
+++ b/base/strings/utf_offset_string_conversions_unittest.cc
@@ -2,13 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "base/strings/utf_offset_string_conversions.h"
+
 #include <stddef.h>
 
 #include <algorithm>
 
-#include "base/cxx17_backports.h"
 #include "base/strings/string_piece.h"
-#include "base/strings/utf_offset_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gurl_base {
@@ -66,7 +66,7 @@
       {{'A', 0xd800, 0xdf00, 'z'}, 3, 5},
       {{'A', 0xd800, 0xdf00, 'z'}, 4, 6},
   };
-  for (size_t i = 0; i < gurl_base::size(utf16_to_utf8_cases); ++i) {
+  for (size_t i = 0; i < std::size(utf16_to_utf8_cases); ++i) {
     size_t offset = utf16_to_utf8_cases[i].input_offset;
     std::vector<size_t> offsets;
     offsets.push_back(offset);
@@ -117,8 +117,8 @@
     adjustments.push_back(OffsetAdjuster::Adjustment(3, 3, 1));
     OffsetAdjuster::AdjustOffsets(adjustments, &offsets);
     size_t expected_1[] = {0, 1, 2, 3, kNpos, kNpos, 4, 5, 6, 7};
-    EXPECT_EQ(offsets.size(), gurl_base::size(expected_1));
-    for (size_t i = 0; i < gurl_base::size(expected_1); ++i)
+    EXPECT_EQ(offsets.size(), std::size(expected_1));
+    for (size_t i = 0; i < std::size(expected_1); ++i)
       EXPECT_EQ(expected_1[i], offsets[i]);
   }
 
@@ -137,8 +137,8 @@
       0, kNpos, kNpos, 1, 2, kNpos, kNpos, kNpos, 4, 5, 6, kNpos, kNpos, kNpos,
       kNpos, kNpos, kNpos, 10, 11, 12, 13, kNpos, kNpos, 14
     };
-    EXPECT_EQ(offsets.size(), gurl_base::size(expected_2));
-    for (size_t i = 0; i < gurl_base::size(expected_2); ++i)
+    EXPECT_EQ(offsets.size(), std::size(expected_2));
+    for (size_t i = 0; i < std::size(expected_2); ++i)
       EXPECT_EQ(expected_2[i], offsets[i]);
   }
 
@@ -157,8 +157,8 @@
       0, kNpos, kNpos, 0, 1, kNpos, kNpos, kNpos, 5, 6, 7, 8, kNpos, kNpos, 11,
       12, kNpos, 12
     };
-    EXPECT_EQ(offsets.size(), gurl_base::size(expected_3));
-    for (size_t i = 0; i < gurl_base::size(expected_3); ++i)
+    EXPECT_EQ(offsets.size(), std::size(expected_3));
+    for (size_t i = 0; i < std::size(expected_3); ++i)
       EXPECT_EQ(expected_3[i], offsets[i]);
   }
 }
@@ -175,8 +175,8 @@
     adjustments.push_back(OffsetAdjuster::Adjustment(3, 3, 1));
     OffsetAdjuster::UnadjustOffsets(adjustments, &offsets);
     size_t expected_1[] = {0, 1, 2, 3, 6, 7, 8, 9};
-    EXPECT_EQ(offsets.size(), gurl_base::size(expected_1));
-    for (size_t i = 0; i < gurl_base::size(expected_1); ++i)
+    EXPECT_EQ(offsets.size(), std::size(expected_1));
+    for (size_t i = 0; i < std::size(expected_1); ++i)
       EXPECT_EQ(expected_1[i], offsets[i]);
   }
 
@@ -194,8 +194,8 @@
     size_t expected_2[] = {
       0, 3, 4, kNpos, 8, 9, 10, kNpos, kNpos, kNpos, 17, 18, 19, 20, 23
     };
-    EXPECT_EQ(offsets.size(), gurl_base::size(expected_2));
-    for (size_t i = 0; i < gurl_base::size(expected_2); ++i)
+    EXPECT_EQ(offsets.size(), std::size(expected_2));
+    for (size_t i = 0; i < std::size(expected_2); ++i)
       EXPECT_EQ(expected_2[i], offsets[i]);
   }
 
@@ -215,8 +215,8 @@
       4, kNpos, kNpos, kNpos, 8, 9, 10, 11, kNpos, kNpos, 14,
       15  // this could just as easily be 17
     };
-    EXPECT_EQ(offsets.size(), gurl_base::size(expected_3));
-    for (size_t i = 0; i < gurl_base::size(expected_3); ++i)
+    EXPECT_EQ(offsets.size(), std::size(expected_3));
+    for (size_t i = 0; i < std::size(expected_3); ++i)
       EXPECT_EQ(expected_3[i], offsets[i]);
   }
 }
diff --git a/base/strings/utf_string_conversions_unittest.cc b/base/strings/utf_string_conversions_unittest.cc
index 3b26fa8..f738da4 100644
--- a/base/strings/utf_string_conversions_unittest.cc
+++ b/base/strings/utf_string_conversions_unittest.cc
@@ -2,12 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "base/strings/utf_string_conversions.h"
+
 #include <stddef.h>
 
-#include "base/cxx17_backports.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -189,14 +189,14 @@
     '\0'
   };
   std::u16string multistring16;
-  memcpy(WriteInto(&multistring16, gurl_base::size(multi16)), multi16,
+  memcpy(WriteInto(&multistring16, std::size(multi16)), multi16,
          sizeof(multi16));
-  EXPECT_EQ(gurl_base::size(multi16) - 1, multistring16.length());
+  EXPECT_EQ(std::size(multi16) - 1, multistring16.length());
   std::string expected;
-  memcpy(WriteInto(&expected, gurl_base::size(multi)), multi, sizeof(multi));
-  EXPECT_EQ(gurl_base::size(multi) - 1, expected.length());
+  memcpy(WriteInto(&expected, std::size(multi)), multi, sizeof(multi));
+  EXPECT_EQ(std::size(multi) - 1, expected.length());
   const std::string& converted = UTF16ToUTF8(multistring16);
-  EXPECT_EQ(gurl_base::size(multi) - 1, converted.length());
+  EXPECT_EQ(std::size(multi) - 1, converted.length());
   EXPECT_EQ(expected, converted);
 }
 
diff --git a/base/template_util.h b/base/template_util.h
index 3d954fd..c00791b 100644
--- a/base/template_util.h
+++ b/base/template_util.h
@@ -13,32 +13,6 @@
 
 #include "base/compiler_specific.h"
 
-#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 7
-#include <vector>
-#endif
-
-// Some versions of libstdc++ have partial support for type_traits, but misses
-// a smaller subset while removing some of the older non-standard stuff. Assume
-// that all versions below 5.0 fall in this category, along with one 5.0
-// experimental release. Test for this by consulting compiler major version,
-// the only reliable option available, so theoretically this could fail should
-// you attempt to mix an earlier version of libstdc++ with >= GCC5. But
-// that's unlikely to work out, especially as GCC5 changed ABI.
-#define CR_GLIBCXX_5_0_0 20150123
-#if (defined(__GNUC__) && __GNUC__ < 5) || \
-    (defined(__GLIBCXX__) && __GLIBCXX__ == CR_GLIBCXX_5_0_0)
-#define CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX
-#endif
-
-// This hacks around using gcc with libc++ which has some incompatibilies.
-// - is_trivially_* doesn't work: https://llvm.org/bugs/show_bug.cgi?id=27538
-// TODO(danakj): Remove this when android builders are all using a newer version
-// of gcc, or the android ndk is updated to a newer libc++ that works with older
-// gcc versions.
-#if !defined(__clang__) && defined(_LIBCPP_VERSION)
-#define CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX
-#endif
-
 namespace gurl_base {
 
 template <class T> struct is_non_const_reference : std::false_type {};
@@ -47,25 +21,6 @@
 
 namespace internal {
 
-// Implementation detail of gurl_base::void_t below.
-template <typename...>
-struct make_void {
-  using type = void;
-};
-
-}  // namespace internal
-
-// gurl_base::void_t is an implementation of std::void_t from C++17.
-//
-// We use |gurl_base::internal::make_void| as a helper struct to avoid a C++14
-// defect:
-//   http://en.cppreference.com/w/cpp/types/void_t
-//   http://open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#1558
-template <typename... Ts>
-using void_t = typename ::gurl_base::internal::make_void<Ts...>::type;
-
-namespace internal {
-
 // Uses expression SFINAE to detect whether using operator<< would work.
 template <typename T, typename = void>
 struct SupportsOstreamOperator : std::false_type {};
@@ -88,8 +43,9 @@
 struct is_iterator : std::false_type {};
 
 template <typename T>
-struct is_iterator<T,
-                   void_t<typename std::iterator_traits<T>::iterator_category>>
+struct is_iterator<
+    T,
+    std::void_t<typename std::iterator_traits<T>::iterator_category>>
     : std::true_type {};
 
 // Helper to express preferences in an overload set. If more than one overload
@@ -103,67 +59,6 @@
 
 }  // namespace internal
 
-// is_trivially_copyable is especially hard to get right.
-// - Older versions of libstdc++ will fail to have it like they do for other
-//   type traits. This has become a subset of the second point, but used to be
-//   handled independently.
-// - An experimental release of gcc includes most of type_traits but misses
-//   is_trivially_copyable, so we still have to avoid using libstdc++ in this
-//   case, which is covered by CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX.
-// - When compiling libc++ from before r239653, with a gcc compiler, the
-//   std::is_trivially_copyable can fail. So we need to work around that by not
-//   using the one in libc++ in this case. This is covered by the
-//   CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX define, and is discussed in
-//   https://llvm.org/bugs/show_bug.cgi?id=27538#c1 where they point out that
-//   in libc++'s commit r239653 this is fixed by libc++ checking for gcc 5.1.
-// - In both of the above cases we are using the gcc compiler. When defining
-//   this ourselves on compiler intrinsics, the __is_trivially_copyable()
-//   intrinsic is not available on gcc before version 5.1 (see the discussion in
-//   https://llvm.org/bugs/show_bug.cgi?id=27538#c1 again), so we must check for
-//   that version.
-// - When __is_trivially_copyable() is not available because we are on gcc older
-//   than 5.1, we need to fall back to something, so we use __has_trivial_copy()
-//   instead based on what was done one-off in bit_cast() previously.
-
-// TODO(crbug.com/554293): Remove this when all platforms have this in the std
-// namespace and it works with gcc as needed.
-#if defined(CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX) || \
-    defined(CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX)
-template <typename T>
-struct is_trivially_copyable {
-// TODO(danakj): Remove this when android builders are all using a newer version
-// of gcc, or the android ndk is updated to a newer libc++ that does this for
-// us.
-#if _GNUC_VER >= 501
-  static constexpr bool value = __is_trivially_copyable(T);
-#else
-  static constexpr bool value =
-      __has_trivial_copy(T) && __has_trivial_destructor(T);
-#endif
-};
-#else
-template <class T>
-using is_trivially_copyable = std::is_trivially_copyable<T>;
-#endif
-
-#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 7
-// Workaround for g++7 and earlier family.
-// Due to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80654, without this
-// absl::optional<std::vector<T>> where T is non-copyable causes a compile
-// error.  As we know it is not trivially copy constructible, explicitly declare
-// so.
-template <typename T>
-struct is_trivially_copy_constructible
-    : std::is_trivially_copy_constructible<T> {};
-
-template <typename... T>
-struct is_trivially_copy_constructible<std::vector<T...>> : std::false_type {};
-#else
-// Otherwise use std::is_trivially_copy_constructible as is.
-template <typename T>
-using is_trivially_copy_constructible = std::is_trivially_copy_constructible<T>;
-#endif
-
 // gurl_base::in_place_t is an implementation of std::in_place_t from
 // C++17. A tag type used to request in-place construction in template vararg
 // constructors.
@@ -193,102 +88,6 @@
   static constexpr bool value = true;
 };
 
-// C++14 implementation of C++17's std::bool_constant.
-//
-// Reference: https://en.cppreference.com/w/cpp/types/integral_constant
-// Specification: https://wg21.link/meta.type.synop
-template <bool B>
-using bool_constant = std::integral_constant<bool, B>;
-
-// C++14 implementation of C++17's std::conjunction.
-//
-// Reference: https://en.cppreference.com/w/cpp/types/conjunction
-// Specification: https://wg21.link/meta.logical#1.itemdecl:1
-template <typename...>
-struct conjunction : std::true_type {};
-
-template <typename B1>
-struct conjunction<B1> : B1 {};
-
-template <typename B1, typename... Bn>
-struct conjunction<B1, Bn...>
-    : std::conditional_t<static_cast<bool>(B1::value), conjunction<Bn...>, B1> {
-};
-
-// C++14 implementation of C++17's std::disjunction.
-//
-// Reference: https://en.cppreference.com/w/cpp/types/disjunction
-// Specification: https://wg21.link/meta.logical#itemdecl:2
-template <typename...>
-struct disjunction : std::false_type {};
-
-template <typename B1>
-struct disjunction<B1> : B1 {};
-
-template <typename B1, typename... Bn>
-struct disjunction<B1, Bn...>
-    : std::conditional_t<static_cast<bool>(B1::value), B1, disjunction<Bn...>> {
-};
-
-// C++14 implementation of C++17's std::negation.
-//
-// Reference: https://en.cppreference.com/w/cpp/types/negation
-// Specification: https://wg21.link/meta.logical#itemdecl:3
-template <typename B>
-struct negation : bool_constant<!static_cast<bool>(B::value)> {};
-
-// Implementation of C++17's invoke_result.
-//
-// This implementation adds references to `Functor` and `Args` to work around
-// some quirks of std::result_of. See the #Notes section of [1] for details.
-//
-// References:
-// [1] https://en.cppreference.com/w/cpp/types/result_of
-// [2] https://wg21.link/meta.trans.other#lib:invoke_result
-template <typename Functor, typename... Args>
-using invoke_result = std::invoke_result<Functor, Args...>;
-
-// Implementation of C++17's std::invoke_result_t.
-//
-// Reference: https://wg21.link/meta.type.synop#lib:invoke_result_t
-template <typename Functor, typename... Args>
-using invoke_result_t = typename invoke_result<Functor, Args...>::type;
-
-namespace internal {
-
-// Base case, `InvokeResult` does not have a nested type member. This means `F`
-// could not be invoked with `Args...` and thus is not invocable.
-template <typename InvokeResult, typename R, typename = void>
-struct IsInvocableImpl : std::false_type {};
-
-// Happy case, `InvokeResult` does have a nested type member. Now check whether
-// `InvokeResult::type` is convertible to `R`. Short circuit in case
-// `std::is_void<R>`.
-template <typename InvokeResult, typename R>
-struct IsInvocableImpl<InvokeResult, R, void_t<typename InvokeResult::type>>
-    : disjunction<std::is_void<R>,
-                  std::is_convertible<typename InvokeResult::type, R>> {};
-
-}  // namespace internal
-
-// Implementation of C++17's std::is_invocable_r.
-//
-// Returns whether `F` can be invoked with `Args...` and the result is
-// convertible to `R`.
-//
-// Reference: https://wg21.link/meta.rel#lib:is_invocable_r
-template <typename R, typename F, typename... Args>
-struct is_invocable_r
-    : internal::IsInvocableImpl<invoke_result<F, Args...>, R> {};
-
-// Implementation of C++17's std::is_invocable.
-//
-// Returns whether `F` can be invoked with `Args...`.
-//
-// Reference: https://wg21.link/meta.rel#lib:is_invocable
-template <typename F, typename... Args>
-struct is_invocable : is_invocable_r<void, F, Args...> {};
-
 namespace internal {
 
 // The indirection with std::is_enum<T> is required, because instantiating
@@ -298,7 +97,7 @@
 
 template <typename T>
 struct IsScopedEnumImpl<T, /*std::is_enum<T>::value=*/true>
-    : negation<std::is_convertible<T, std::underlying_type_t<T>>> {};
+    : std::negation<std::is_convertible<T, std::underlying_type_t<T>>> {};
 
 }  // namespace internal
 
@@ -363,7 +162,8 @@
 //
 // Reference: https://wg21.link/iterator.synopsis#:~:text=indirect_result_t
 template <typename Func, typename... Iters>
-using indirect_result_t = invoke_result_t<Func, iter_reference_t<Iters>...>;
+using indirect_result_t =
+    std::invoke_result_t<Func, iter_reference_t<Iters>...>;
 
 // Simplified implementation of C++20's std::projected. As opposed to
 // std::projected, this implementation does not explicitly restrict the type of
@@ -383,7 +183,4 @@
 
 }  // namespace base
 
-#undef CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX
-#undef CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX
-
 #endif  // BASE_TEMPLATE_UTIL_H_
diff --git a/copy.bara.sky b/copy.bara.sky
index 44173d6..9741b8b 100644
--- a/copy.bara.sky
+++ b/copy.bara.sky
@@ -103,6 +103,8 @@
 
     core.replace("#include \"base/win/windows_types.h\"", "#include <windows.h>"),
     core.replace("#include \"base/strings/string_number_conversions_win.h\"", ""),
+    core.replace("#include \"base/allocator/partition_allocator/partition_alloc_config.h\"", ""),
+    core.replace("base/trace_event/base_tracing_forward.h", "polyfills/third_party/perfetto/include/perfetto/tracing/traced_value.h"),
 
     # Use system ICU.
     core.replace(
diff --git a/polyfills/third_party/perfetto/include/perfetto/tracing/traced_value.h b/polyfills/third_party/perfetto/include/perfetto/tracing/traced_value.h
index b2f0286..6d059f7 100644
--- a/polyfills/third_party/perfetto/include/perfetto/tracing/traced_value.h
+++ b/polyfills/third_party/perfetto/include/perfetto/tracing/traced_value.h
@@ -12,6 +12,15 @@
   void WriteString(const std::string&) && {}
 };
 
+template <typename T>
+void WriteIntoTracedValue(TracedValue context, T&& value) {}
+
+template <typename T, typename ResultType = void, class = void>
+struct check_traced_value_support {
+  static constexpr bool value = true;
+  using type = ResultType;
+};
+
 }  // namespace perfetto
 
 #endif  // POLYFILLS_THIRD_PARTY_PERFETTO_INCLUDE_PERFETTO_TRACING_TRACED_VALUE_H_
diff --git a/url/gurl.cc b/url/gurl.cc
index 3dd0228..5c6b76c 100644
--- a/url/gurl.cc
+++ b/url/gurl.cc
@@ -110,17 +110,17 @@
       // removed from a "foo:hello #ref" URL (see http://crbug.com/291747).
       GURL test_url(spec_, RETAIN_TRAILING_PATH_WHITEPACE);
 
-      GURL_DCHECK(test_url.is_valid_ == is_valid_);
-      GURL_DCHECK(test_url.spec_ == spec_);
+      GURL_DCHECK_EQ(test_url.is_valid_, is_valid_);
+      GURL_DCHECK_EQ(test_url.spec_, spec_);
 
-      GURL_DCHECK(test_url.parsed_.scheme == parsed_.scheme);
-      GURL_DCHECK(test_url.parsed_.username == parsed_.username);
-      GURL_DCHECK(test_url.parsed_.password == parsed_.password);
-      GURL_DCHECK(test_url.parsed_.host == parsed_.host);
-      GURL_DCHECK(test_url.parsed_.port == parsed_.port);
-      GURL_DCHECK(test_url.parsed_.path == parsed_.path);
-      GURL_DCHECK(test_url.parsed_.query == parsed_.query);
-      GURL_DCHECK(test_url.parsed_.ref == parsed_.ref);
+      GURL_DCHECK_EQ(test_url.parsed_.scheme, parsed_.scheme);
+      GURL_DCHECK_EQ(test_url.parsed_.username, parsed_.username);
+      GURL_DCHECK_EQ(test_url.parsed_.password, parsed_.password);
+      GURL_DCHECK_EQ(test_url.parsed_.host, parsed_.host);
+      GURL_DCHECK_EQ(test_url.parsed_.port, parsed_.port);
+      GURL_DCHECK_EQ(test_url.parsed_.path, parsed_.path);
+      GURL_DCHECK_EQ(test_url.parsed_.query, parsed_.query);
+      GURL_DCHECK_EQ(test_url.parsed_.ref, parsed_.ref);
     }
   }
 #endif
@@ -223,8 +223,7 @@
 }
 
 // Note: code duplicated below (it's inconvenient to use a template here).
-GURL GURL::ReplaceComponents(
-    const url::Replacements<char>& replacements) const {
+GURL GURL::ReplaceComponents(const Replacements& replacements) const {
   GURL result;
 
   // Not allowed for invalid URLs.
@@ -243,8 +242,7 @@
 }
 
 // Note: code duplicated above (it's inconvenient to use a template here).
-GURL GURL::ReplaceComponents(
-    const url::Replacements<char16_t>& replacements) const {
+GURL GURL::ReplaceComponents(const ReplacementsW& replacements) const {
   GURL result;
 
   // Not allowed for invalid URLs.
@@ -281,7 +279,7 @@
   if (SchemeIsFileSystem())
     return inner_url_->DeprecatedGetOriginAsURL();
 
-  url::Replacements<char> replacements;
+  Replacements replacements;
   replacements.ClearUsername();
   replacements.ClearPassword();
   replacements.ClearPath();
@@ -298,7 +296,7 @@
   if (!has_ref() && !has_username() && !has_password())
     return GURL(*this);
 
-  url::Replacements<char> replacements;
+  Replacements replacements;
   replacements.ClearRef();
   replacements.ClearUsername();
   replacements.ClearPassword();
diff --git a/url/gurl.h b/url/gurl.h
index ee009de..63729ee 100644
--- a/url/gurl.h
+++ b/url/gurl.h
@@ -164,10 +164,10 @@
   // It is an error to replace components of an invalid URL. The result will
   // be the empty URL.
   //
-  // Note that we use the more general url::Replacements type to give
-  // callers extra flexibility rather than our override.
-  GURL ReplaceComponents(const url::Replacements<char>& replacements) const;
-  GURL ReplaceComponents(const url::Replacements<char16_t>& replacements) const;
+  // Note that this intentionally disallows direct use of url::Replacements,
+  // which is harder to use correctly.
+  GURL ReplaceComponents(const Replacements& replacements) const;
+  GURL ReplaceComponents(const ReplacementsW& replacements) const;
 
   // A helper function that is equivalent to replacing the path with a slash
   // and clearing out everything after that. We sometimes need to know just the
diff --git a/url/gurl_unittest.cc b/url/gurl_unittest.cc
index e793542..6dd1fc0 100644
--- a/url/gurl_unittest.cc
+++ b/url/gurl_unittest.cc
@@ -2,13 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "url/gurl.h"
+
 #include <stddef.h>
 
-#include "base/cxx17_backports.h"
 #include "base/strings/string_number_conversions.h"
 #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"
@@ -222,7 +222,7 @@
       "http:/path",
       "http:path",
   };
-  for (size_t i = 0; i < gurl_base::size(valid_cases); i++) {
+  for (size_t i = 0; i < std::size(valid_cases); i++) {
     EXPECT_TRUE(GURL(valid_cases[i]).is_valid())
         << "Case: " << valid_cases[i];
   }
@@ -237,7 +237,7 @@
       "://google.com",
       "path",
   };
-  for (size_t i = 0; i < gurl_base::size(invalid_cases); i++) {
+  for (size_t i = 0; i < std::size(invalid_cases); i++) {
     EXPECT_FALSE(GURL(invalid_cases[i]).is_valid())
         << "Case: " << invalid_cases[i];
   }
@@ -346,7 +346,7 @@
       {"file:///some/dir/", "://host", true, "file:///some/dir/://host"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(resolve_cases); i++) {
+  for (size_t i = 0; i < std::size(resolve_cases); i++) {
     // 8-bit code path.
     GURL input(resolve_cases[i].base);
     GURL output = input.Resolve(resolve_cases[i].relative);
@@ -383,7 +383,7 @@
       {"blob:null/guid-goes-here", ""},
       {"blob:http://origin/guid-goes-here", "" /* should be http://origin/ */},
   };
-  for (size_t i = 0; i < gurl_base::size(cases); i++) {
+  for (size_t i = 0; i < std::size(cases); i++) {
     GURL url(cases[i].input);
     GURL origin = url.DeprecatedGetOriginAsURL();
     EXPECT_EQ(cases[i].expected, origin.spec());
@@ -406,7 +406,7 @@
     {"file:///tmp/test.html", ""},
     {"https://www.google.com", "https://www.google.com/"},
   };
-  for (size_t i = 0; i < gurl_base::size(cases); i++) {
+  for (size_t i = 0; i < std::size(cases); i++) {
     GURL url(cases[i].input);
     GURL origin = url.GetAsReferrer();
     EXPECT_EQ(cases[i].expected, origin.spec());
@@ -425,7 +425,7 @@
     {"filesystem:file:///temporary/bar.html?baz=22", "filesystem:file:///temporary/"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(cases); i++) {
+  for (size_t i = 0; i < std::size(cases); i++) {
     GURL url(cases[i].input);
     GURL empty_path = url.GetWithEmptyPath();
     EXPECT_EQ(cases[i].expected, empty_path.spec());
@@ -471,7 +471,7 @@
     {"foobar", ""},
   };
 
-  for (size_t i = 0; i < gurl_base::size(cases); i++) {
+  for (size_t i = 0; i < std::size(cases); i++) {
     GURL url(cases[i].input);
     GURL without_filename = url.GetWithoutFilename();
     EXPECT_EQ(cases[i].expected, without_filename.spec()) << i;
@@ -636,7 +636,7 @@
        "/foo/bar.html?query", "/temporary"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(cases); i++) {
+  for (size_t i = 0; i < std::size(cases); i++) {
     GURL url(cases[i].input);
     EXPECT_EQ(cases[i].expected, url.PathForRequest());
     EXPECT_EQ(cases[i].expected, url.PathForRequestPiece());
@@ -682,7 +682,7 @@
     {"filesystem:file:///t/foo", PORT_UNSPECIFIED},
   };
 
-  for (size_t i = 0; i < gurl_base::size(port_tests); i++) {
+  for (size_t i = 0; i < std::size(port_tests); i++) {
     GURL url(port_tests[i].spec);
     EXPECT_EQ(port_tests[i].expected_int_port, url.EffectiveIntPort());
   }
@@ -703,7 +703,7 @@
     {"some random input!", false},
   };
 
-  for (size_t i = 0; i < gurl_base::size(ip_tests); i++) {
+  for (size_t i = 0; i < std::size(ip_tests); i++) {
     GURL url(ip_tests[i].spec);
     EXPECT_EQ(ip_tests[i].expected_ip, url.HostIsIPAddress());
   }
@@ -728,7 +728,7 @@
     {"http://]/", "]", "]"},
     {"", "", ""},
   };
-  for (size_t i = 0; i < gurl_base::size(cases); i++) {
+  for (size_t i = 0; i < std::size(cases); i++) {
     GURL url(cases[i].input);
     EXPECT_EQ(cases[i].expected_host, url.host());
     EXPECT_EQ(cases[i].expected_plainhost, url.HostNoBrackets());
diff --git a/url/origin.cc b/url/origin.cc
index e943d4f..b17591d 100644
--- a/url/origin.cc
+++ b/url/origin.cc
@@ -8,21 +8,23 @@
 
 #include <algorithm>
 #include <ostream>
-#include <vector>
+#include <string>
+#include <tuple>
+#include <utility>
 
 #include "base/base64.h"
+#include "polyfills/base/check.h"
 #include "polyfills/base/check_op.h"
 #include "base/containers/contains.h"
 #include "base/containers/span.h"
+#include "base/debug/crash_logging.h"
 #include "base/pickle.h"
 #include "base/strings/strcat.h"
-#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
-#include "base/strings/string_util.h"
+#include "base/unguessable_token.h"
 #include "polyfills/third_party/perfetto/include/perfetto/tracing/traced_value.h"
 #include "url/gurl.h"
-#include "url/url_canon.h"
-#include "url/url_canon_stdstring.h"
+#include "url/scheme_host_port.h"
 #include "url/url_constants.h"
 #include "url/url_util.h"
 
@@ -150,11 +152,8 @@
   return tuple_.GetURL();
 }
 
-absl::optional<gurl_base::UnguessableToken> Origin::GetNonceForSerialization()
-    const {
-  // TODO(nasko): Consider not making a copy here, but return a reference to
-  // the nonce.
-  return nonce_ ? absl::make_optional(nonce_->token()) : absl::nullopt;
+const gurl_base::UnguessableToken* Origin::GetNonceForSerialization() const {
+  return nonce_ ? &nonce_->token() : nullptr;
 }
 
 bool Origin::IsSameOriginWith(const Origin& other) const {
diff --git a/url/origin.h b/url/origin.h
index c1ad177..1b0a407 100644
--- a/url/origin.h
+++ b/url/origin.h
@@ -13,17 +13,15 @@
 #include "polyfills/base/component_export.h"
 #include "polyfills/base/debug/alias.h"
 #include "base/debug/crash_logging.h"
-#include "base/strings/string_piece.h"
+#include "base/strings/string_piece_forward.h"
 #include "base/strings/string_util.h"
 #include "base/unguessable_token.h"
 #include "build/build_config.h"
+#include "build/buildflag.h"
 #include "ipc/ipc_param_traits.h"
 #include "absl/types/optional.h"
 #include "polyfills/third_party/perfetto/include/perfetto/tracing/traced_value.h"
 #include "url/scheme_host_port.h"
-#include "url/third_party/mozilla/url_parse.h"
-#include "url/url_canon.h"
-#include "url/url_constants.h"
 
 #if BUILDFLAG(IS_ANDROID)
 #include <jni.h>
@@ -403,9 +401,10 @@
   // given |nonce|.
   Origin(const Nonce& nonce, SchemeHostPort precursor);
 
-  // Get the nonce associated with this origin, if it is opaque. This should be
-  // used only when trying to send an Origin across an IPC pipe.
-  absl::optional<gurl_base::UnguessableToken> GetNonceForSerialization() const;
+  // Get the nonce associated with this origin, if it is opaque, or nullptr
+  // otherwise. This should be used only when trying to send an Origin across an
+  // IPC pipe.
+  const gurl_base::UnguessableToken* GetNonceForSerialization() const;
 
   // Serializes this Origin, including its nonce if it is opaque. If an opaque
   // origin's |tuple_| is invalid nullopt is returned. If the nonce is not
diff --git a/url/origin_unittest.cc b/url/origin_unittest.cc
index 755d2e3..bd9ee7e 100644
--- a/url/origin_unittest.cc
+++ b/url/origin_unittest.cc
@@ -69,7 +69,7 @@
     return Origin::Nonce(nonce);
   }
 
-  absl::optional<gurl_base::UnguessableToken> GetNonce(const Origin& origin) {
+  const gurl_base::UnguessableToken* GetNonce(const Origin& origin) {
     return origin.GetNonceForSerialization();
   }
 
@@ -364,7 +364,7 @@
       << "UnsafelyCreateOpaqueOriginWithoutNormalization, so long as it is "
       << "the canonical form of the invalid tuple.";
   EXPECT_TRUE(anonymous_opaque->opaque());
-  EXPECT_EQ(GetNonce(anonymous_opaque.value()), token);
+  EXPECT_EQ(*GetNonce(anonymous_opaque.value()), token);
   EXPECT_EQ(anonymous_opaque->GetTupleOrPrecursorTupleIfOpaque(),
             url::SchemeHostPort());
 }
diff --git a/url/scheme_host_port_unittest.cc b/url/scheme_host_port_unittest.cc
index e55c9d5..f49bd59 100644
--- a/url/scheme_host_port_unittest.cc
+++ b/url/scheme_host_port_unittest.cc
@@ -2,13 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "url/scheme_host_port.h"
+
 #include <stddef.h>
 #include <stdint.h>
 
-#include "base/cxx17_backports.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
-#include "url/scheme_host_port.h"
 #include "url/url_util.h"
 
 namespace {
@@ -262,10 +262,10 @@
       {"https", "b", 81},
   };
 
-  for (size_t i = 0; i < gurl_base::size(tuples); i++) {
+  for (size_t i = 0; i < std::size(tuples); i++) {
     url::SchemeHostPort current(tuples[i].scheme, tuples[i].host,
                                 tuples[i].port);
-    for (size_t j = i; j < gurl_base::size(tuples); j++) {
+    for (size_t j = i; j < std::size(tuples); j++) {
       url::SchemeHostPort to_compare(tuples[j].scheme, tuples[j].host,
                                      tuples[j].port);
       EXPECT_EQ(i < j, current < to_compare) << i << " < " << j;
diff --git a/url/third_party/mozilla/url_parse.cc b/url/third_party/mozilla/url_parse.cc
index 8edb7f3..2500fc6 100644
--- a/url/third_party/mozilla/url_parse.cc
+++ b/url/third_party/mozilla/url_parse.cc
@@ -692,6 +692,11 @@
 
 }  // namespace
 
+COMPONENT_EXPORT(URL)
+std::ostream& operator<<(std::ostream& os, const Component& component) {
+  return os << '{' << component.begin << ", " << component.len << "}";
+}
+
 Parsed::Parsed() : potentially_dangling_markup(false), inner_parsed_(NULL) {}
 
 Parsed::Parsed(const Parsed& other)
diff --git a/url/third_party/mozilla/url_parse.h b/url/third_party/mozilla/url_parse.h
index 1ec0ef8..c3535ba 100644
--- a/url/third_party/mozilla/url_parse.h
+++ b/url/third_party/mozilla/url_parse.h
@@ -5,6 +5,8 @@
 #ifndef URL_THIRD_PARTY_MOZILLA_URL_PARSE_H_
 #define URL_THIRD_PARTY_MOZILLA_URL_PARSE_H_
 
+#include <iosfwd>
+
 #include "polyfills/base/component_export.h"
 
 namespace url {
@@ -47,6 +49,10 @@
   int len;    // Will be -1 if the component is unspecified.
 };
 
+// Permit printing Components by GURL_CHECK macros.
+COMPONENT_EXPORT(URL)
+std::ostream& operator<<(std::ostream& os, const Component& component);
+
 // Helper that returns a component created with the given begin and ending
 // points. The ending point is non-inclusive.
 inline Component MakeRange(int begin, int end) {
diff --git a/url/url_canon.h b/url/url_canon.h
index 32e7b15..e935d7f 100644
--- a/url/url_canon.h
+++ b/url/url_canon.h
@@ -8,8 +8,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include <string>
-
 #include "polyfills/base/component_export.h"
 #include "polyfills/base/export_template.h"
 #include "url/third_party/mozilla/url_parse.h"
@@ -299,7 +297,7 @@
 // Piece-by-piece canonicalizers ----------------------------------------------
 //
 // These individual canonicalizers append the canonicalized versions of the
-// corresponding URL component to the given std::string. The spec and the
+// corresponding URL component to the given CanonOutput. The spec and the
 // previously-identified range of that component are the input. The range of
 // the canonicalized component will be written to the output component.
 //
diff --git a/url/url_canon_icu_unittest.cc b/url/url_canon_icu_unittest.cc
index 702b1d3..cb74f64 100644
--- a/url/url_canon_icu_unittest.cc
+++ b/url/url_canon_icu_unittest.cc
@@ -2,15 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "url/url_canon_icu.h"
+
 #include <stddef.h>
 
-#include "base/cxx17_backports.h"
 #include "polyfills/base/logging.h"
 #include "base/memory/raw_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <unicode/ucnv.h>
 #include "url/url_canon.h"
-#include "url/url_canon_icu.h"
 #include "url/url_canon_stdstring.h"
 #include "url/url_test_utils.h"
 
@@ -60,7 +60,7 @@
       "hello\xa7\x41%26%231758%3B\xa6\x6eworld"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(icu_cases); i++) {
+  for (size_t i = 0; i < std::size(icu_cases); i++) {
     UConvScoper conv(icu_cases[i].encoding);
     ASSERT_TRUE(conv.converter() != NULL);
     ICUCharsetConverter converter(conv.converter());
@@ -118,7 +118,7 @@
       "?q=Chinese%26%2365319%3B"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(query_cases); i++) {
+  for (size_t i = 0; i < std::size(query_cases); i++) {
     Component out_comp;
 
     UConvScoper conv(query_cases[i].encoding);
diff --git a/url/url_canon_unittest.cc b/url/url_canon_unittest.cc
index 2dd5075..0170e00 100644
--- a/url/url_canon_unittest.cc
+++ b/url/url_canon_unittest.cc
@@ -2,16 +2,16 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "url/url_canon.h"
+
 #include <errno.h>
 #include <stddef.h>
 
-#include "base/cxx17_backports.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/gtest_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/third_party/mozilla/url_parse.h"
-#include "url/url_canon.h"
 #include "url/url_canon_internal.h"
 #include "url/url_canon_stdstring.h"
 #include "url/url_test_utils.h"
@@ -116,7 +116,7 @@
     {0x10FFFF, "\xF4\x8F\xBF\xBF"},
   };
   std::string out_str;
-  for (size_t i = 0; i < gurl_base::size(utf_cases); i++) {
+  for (size_t i = 0; i < std::size(utf_cases); i++) {
     out_str.clear();
     StdStringCanonOutput output(&out_str);
     AppendUTF8Value(utf_cases[i].input, &output);
@@ -168,7 +168,7 @@
   };
 
   std::string out_str;
-  for (size_t i = 0; i < gurl_base::size(utf_cases); i++) {
+  for (size_t i = 0; i < std::size(utf_cases); i++) {
     if (utf_cases[i].input8) {
       out_str.clear();
       StdStringCanonOutput output(&out_str);
@@ -239,7 +239,7 @@
 
   std::string out_str;
 
-  for (size_t i = 0; i < gurl_base::size(scheme_cases); i++) {
+  for (size_t i = 0; i < std::size(scheme_cases); i++) {
     int url_len = static_cast<int>(strlen(scheme_cases[i].input));
     Component in_comp(0, url_len);
     Component out_comp;
@@ -504,7 +504,7 @@
 
   // CanonicalizeHost() non-verbose.
   std::string out_str;
-  for (size_t i = 0; i < gurl_base::size(host_cases); i++) {
+  for (size_t i = 0; i < std::size(host_cases); i++) {
     // Narrow version.
     if (host_cases[i].input8) {
       int host_len = static_cast<int>(strlen(host_cases[i].input8));
@@ -552,7 +552,7 @@
   }
 
   // CanonicalizeHostVerbose()
-  for (size_t i = 0; i < gurl_base::size(host_cases); i++) {
+  for (size_t i = 0; i < std::size(host_cases); i++) {
     // Narrow version.
     if (host_cases[i].input8) {
       int host_len = static_cast<int>(strlen(host_cases[i].input8));
@@ -869,7 +869,7 @@
     {"[::1 hello]", L"[::1 hello]", "", Component(), CanonHostInfo::BROKEN, -1, ""},
   };
 
-  for (size_t i = 0; i < gurl_base::size(cases); i++) {
+  for (size_t i = 0; i < std::size(cases); i++) {
     // 8-bit version.
     Component component(0, static_cast<int>(strlen(cases[i].input8)));
 
@@ -995,7 +995,7 @@
     {"ftp://me\\mydomain:pass@foo.com/", "", Component(0, -1), Component(0, -1), true},
   };
 
-  for (size_t i = 0; i < gurl_base::size(user_info_cases); i++) {
+  for (size_t i = 0; i < std::size(user_info_cases); i++) {
     int url_len = static_cast<int>(strlen(user_info_cases[i].input));
     Parsed parsed;
     ParseStandardURL(user_info_cases[i].input, url_len, &parsed);
@@ -1064,7 +1064,7 @@
     {"80", PORT_UNSPECIFIED, ":80", Component(1, 2), true},
   };
 
-  for (size_t i = 0; i < gurl_base::size(port_cases); i++) {
+  for (size_t i = 0; i < std::size(port_cases); i++) {
     int url_len = static_cast<int>(strlen(port_cases[i].input));
     Component in_comp(0, url_len);
     Component out_comp;
@@ -1249,7 +1249,7 @@
 }
 
 TEST(URLCanonTest, Path) {
-  DoPathTest(kCommonPathCases, gurl_base::size(kCommonPathCases), CanonicalizePath,
+  DoPathTest(kCommonPathCases, std::size(kCommonPathCases), CanonicalizePath,
              CanonicalizePath);
 
   // Manual test: embedded NULLs should be escaped and the URL should be marked
@@ -1272,9 +1272,9 @@
       {"", L"", "", Component(0, 0), true},
   };
 
-  DoPathTest(kCommonPathCases, gurl_base::size(kCommonPathCases),
+  DoPathTest(kCommonPathCases, std::size(kCommonPathCases),
              CanonicalizePartialPath, CanonicalizePartialPath);
-  DoPathTest(partial_path_cases, gurl_base::size(partial_path_cases),
+  DoPathTest(partial_path_cases, std::size(partial_path_cases),
              CanonicalizePartialPath, CanonicalizePartialPath);
 }
 
@@ -1304,7 +1304,7 @@
     {"q=\"asdf\"", L"q=\"asdf\"", "?q=%22asdf%22"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(query_cases); i++) {
+  for (size_t i = 0; i < std::size(query_cases); i++) {
     Component out_comp;
 
     if (query_cases[i].input8) {
@@ -1376,7 +1376,7 @@
       {"#asdf", L"#asdf", "##asdf", Component(1, 5), true},
   };
 
-  for (size_t i = 0; i < gurl_base::size(ref_cases); i++) {
+  for (size_t i = 0; i < std::size(ref_cases); i++) {
     // 8-bit input
     if (ref_cases[i].input8) {
       int len = static_cast<int>(strlen(ref_cases[i].input8));
@@ -1491,7 +1491,7 @@
       {R"(HTTP:S/5%\../>%41)", "http://s/%3EA", true},
   };
 
-  for (size_t i = 0; i < gurl_base::size(cases); i++) {
+  for (size_t i = 0; i < std::size(cases); i++) {
     int url_len = static_cast<int>(strlen(cases[i].input));
     Parsed parsed;
     ParseStandardURL(cases[i].input, url_len, &parsed);
@@ -1532,7 +1532,7 @@
        "filesystem://a:b@google.com:22/foo?baz@cat"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(replace_cases); i++) {
+  for (size_t i = 0; i < std::size(replace_cases); i++) {
     const ReplaceCase& cur = replace_cases[i];
     int base_len = static_cast<int>(strlen(cur.base));
     Parsed parsed;
@@ -1632,7 +1632,7 @@
        nullptr, nullptr, nullptr, "file:///C:/gaba?query#ref"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(replace_cases); i++) {
+  for (size_t i = 0; i < std::size(replace_cases); i++) {
     const ReplaceCase& cur = replace_cases[i];
     SCOPED_TRACE(cur.base);
     int base_len = static_cast<int>(strlen(cur.base));
@@ -1701,7 +1701,7 @@
        "filesystem:http://bar.com:40/t/gaba?query#ref"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(replace_cases); i++) {
+  for (size_t i = 0; i < std::size(replace_cases); i++) {
     const ReplaceCase& cur = replace_cases[i];
     int base_len = static_cast<int>(strlen(cur.base));
     Parsed parsed;
@@ -1745,7 +1745,7 @@
        nullptr, nullptr, "data:"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(replace_cases); i++) {
+  for (size_t i = 0; i < std::size(replace_cases); i++) {
     const ReplaceCase& cur = replace_cases[i];
     int base_len = static_cast<int>(strlen(cur.base));
     Parsed parsed;
@@ -1796,7 +1796,7 @@
     {"mailto:addr1", NULL, NULL, NULL, NULL, NULL, NULL, NULL, "BLAH", "mailto:addr1"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(replace_cases); i++) {
+  for (size_t i = 0; i < std::size(replace_cases); i++) {
     const ReplaceCase& cur = replace_cases[i];
     int base_len = static_cast<int>(strlen(cur.base));
     Parsed parsed;
@@ -1909,7 +1909,7 @@
 #endif  // _WIN32
   };
 
-  for (size_t i = 0; i < gurl_base::size(cases); i++) {
+  for (size_t i = 0; i < std::size(cases); i++) {
     int url_len = static_cast<int>(strlen(cases[i].input));
     Parsed parsed;
     ParseFileURL(cases[i].input, url_len, &parsed);
@@ -1958,7 +1958,7 @@
       {"FilEsysteM:htTp:E=/.", "filesystem:http://e%3D//", false},
   };
 
-  for (size_t i = 0; i < gurl_base::size(cases); i++) {
+  for (size_t i = 0; i < std::size(cases); i++) {
     int url_len = static_cast<int>(strlen(cases[i].input));
     Parsed parsed;
     ParseFileSystemURL(cases[i].input, url_len, &parsed);
@@ -1997,7 +1997,7 @@
       {"javascript:\uFFFF", "javascript:%EF%BF%BD"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(path_cases); i++) {
+  for (size_t i = 0; i < std::size(path_cases); i++) {
     int url_len = static_cast<int>(strlen(path_cases[i].input));
     Parsed parsed;
     ParsePathURL(path_cases[i].input, url_len, true, &parsed);
@@ -2035,7 +2035,7 @@
       {"\uFFFF", L"\uFFFF", "%EF%BF%BD"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(path_cases); i++) {
+  for (size_t i = 0; i < std::size(path_cases); i++) {
     // 8-bit string input
     std::string out_str;
     StdStringCanonOutput output(&out_str);
@@ -2129,7 +2129,7 @@
   Parsed parsed;
   Parsed out_parsed;
 
-  for (size_t i = 0; i < gurl_base::size(cases); i++) {
+  for (size_t i = 0; i < std::size(cases); i++) {
     int url_len = static_cast<int>(strlen(cases[i].input));
     if (i == 0) {
       // The first test case purposely has a '\0' in it -- don't count it
@@ -2399,7 +2399,7 @@
     {"about:blank", false, false, "content://content.Provider/", true, false, true, ""},
   };
 
-  for (size_t i = 0; i < gurl_base::size(rel_cases); i++) {
+  for (size_t i = 0; i < std::size(rel_cases); i++) {
     const RelativeCase& cur_case = rel_cases[i];
 
     Parsed parsed;
diff --git a/url/url_parse_unittest.cc b/url/url_parse_unittest.cc
index 7cd3fe8..9a8bb57 100644
--- a/url/url_parse_unittest.cc
+++ b/url/url_parse_unittest.cc
@@ -2,11 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "url/third_party/mozilla/url_parse.h"
-
 #include <stddef.h>
 
-#include "base/cxx17_backports.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/third_party/mozilla/url_parse.h"
 
@@ -137,7 +134,7 @@
     "http://user@",
     "http:",
   };
-  for (size_t i = 0; i < gurl_base::size(length_cases); i++) {
+  for (size_t i = 0; i < std::size(length_cases); i++) {
     int true_length = static_cast<int>(strlen(length_cases[i]));
 
     Parsed parsed;
@@ -196,7 +193,7 @@
     {"file:///c:/foo", Parsed::HOST, true, 7},
     {"file:///c:/foo", Parsed::PATH, true, 7},
   };
-  for (size_t i = 0; i < gurl_base::size(count_cases); i++) {
+  for (size_t i = 0; i < std::size(count_cases); i++) {
     int length = static_cast<int>(strlen(count_cases[i].url));
 
     // Simple test to distinguish file and standard URLs.
@@ -314,7 +311,7 @@
   // Declared outside for loop to try to catch cases in init() where we forget
   // to reset something that is reset by the constructor.
   Parsed parsed;
-  for (size_t i = 0; i < gurl_base::size(cases); i++) {
+  for (size_t i = 0; i < std::size(cases); i++) {
     const char* url = cases[i].input;
     ParseStandardURL(url, static_cast<int>(strlen(url)), &parsed);
     int port = ParsePort(url, parsed.port);
@@ -349,7 +346,7 @@
   // Declared outside for loop to try to catch cases in init() where we forget
   // to reset something that is reset by the constructor.
   Parsed parsed;
-  for (size_t i = 0; i < gurl_base::size(path_cases); i++) {
+  for (size_t i = 0; i < std::size(path_cases); i++) {
     const char* url = path_cases[i].input;
     ParsePathURL(url, static_cast<int>(strlen(url)), false, &parsed);
 
@@ -448,7 +445,7 @@
   // Declared outside for loop to try to catch cases in init() where we forget
   // to reset something that is reset by the construtor.
   Parsed parsed;
-  for (size_t i = 0; i < gurl_base::size(file_cases); i++) {
+  for (size_t i = 0; i < std::size(file_cases); i++) {
     const char* url = file_cases[i].input;
     ParseFileURL(url, static_cast<int>(strlen(url)), &parsed);
     int port = ParsePort(url, parsed.port);
@@ -509,7 +506,7 @@
       {"http://www.google.com/foo;bar;html", "foo"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(extract_cases); i++) {
+  for (size_t i = 0; i < std::size(extract_cases); i++) {
     const char* url = extract_cases[i].input;
     int len = static_cast<int>(strlen(url));
 
@@ -617,7 +614,7 @@
   // Declared outside for loop to try to catch cases in init() where we forget
   // to reset something that is reset by the constructor.
   Parsed parsed;
-  for (size_t i = 0; i < gurl_base::size(mailto_cases); ++i) {
+  for (size_t i = 0; i < std::size(mailto_cases); ++i) {
     const char* url = mailto_cases[i].input;
     ParseMailtoURL(url, static_cast<int>(strlen(url)), &parsed);
     int port = ParsePort(url, parsed.port);
@@ -649,7 +646,7 @@
   // Declared outside for loop to try to catch cases in init() where we forget
   // to reset something that is reset by the constructor.
   Parsed parsed;
-  for (size_t i = 0; i < gurl_base::size(filesystem_cases); i++) {
+  for (size_t i = 0; i < std::size(filesystem_cases); i++) {
     const FileSystemURLParseCase* parsecase = &filesystem_cases[i];
     const char* url = parsecase->input;
     ParseFileSystemURL(url, static_cast<int>(strlen(url)), &parsed);
diff --git a/url/url_util.cc b/url/url_util.cc
index 3162fdf..26657f7 100644
--- a/url/url_util.cc
+++ b/url/url_util.cc
@@ -438,6 +438,13 @@
     // ref).
     Replacements<CHAR> replacements_no_scheme = replacements;
     replacements_no_scheme.SetScheme(NULL, Component());
+    // If the input URL has potentially dangling markup, set the flag on the
+    // output too. Note that in some cases the replacement gets rid of the
+    // potentially dangling markup, but this ok since the check will fail
+    // closed.
+    if (parsed.potentially_dangling_markup) {
+      out_parsed->potentially_dangling_markup = true;
+    }
     return DoReplaceComponents(recanonicalized.data(), recanonicalized.length(),
                                recanonicalized_parsed, replacements_no_scheme,
                                charset_converter, output, out_parsed);
diff --git a/url/url_util_unittest.cc b/url/url_util_unittest.cc
index 5255817..53aab7d 100644
--- a/url/url_util_unittest.cc
+++ b/url/url_util_unittest.cc
@@ -6,7 +6,6 @@
 
 #include <stddef.h>
 
-#include "base/cxx17_backports.h"
 #include "base/strings/string_piece.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest-message.h"
@@ -251,7 +250,7 @@
       {"%e4%bd%a0%e5%a5%bd", "\xe4\xbd\xa0\xe5\xa5\xbd"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(decode_cases); i++) {
+  for (size_t i = 0; i < std::size(decode_cases); i++) {
     const char* input = decode_cases[i].input;
     RawCanonOutputT<char16_t> output;
     DecodeURLEscapeSequences(input, strlen(input),
@@ -333,7 +332,7 @@
      "pqrstuvwxyz%7B%7C%7D~%7F"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(encode_cases); i++) {
+  for (size_t i = 0; i < std::size(encode_cases); i++) {
     const char* input = encode_cases[i].input;
     RawCanonOutputT<char> buffer;
     EncodeURIComponent(input, strlen(input), &buffer);
@@ -410,7 +409,7 @@
       // adding the requested dot doesn't seem wrong either.
       {"aaa://a\\", "aaa:.", true, "aaa://a\\."}};
 
-  for (size_t i = 0; i < gurl_base::size(resolve_non_standard_cases); i++) {
+  for (size_t i = 0; i < std::size(resolve_non_standard_cases); i++) {
     const ResolveRelativeCase& test_data = resolve_non_standard_cases[i];
     Parsed base_parsed;
     ParsePathURL(test_data.base, strlen(test_data.base), false, &base_parsed);
@@ -518,6 +517,26 @@
   EXPECT_TRUE(replaced_parsed.potentially_dangling_markup);
 }
 
+TEST_F(URLUtilTest, PotentiallyDanglingMarkupAfterSchemeOnlyReplacement) {
+  // Parse a URL with potentially dangling markup.
+  Parsed original_parsed;
+  RawCanonOutput<32> original;
+  const char* url = "http://example.com/\n/<path";
+  Canonicalize(url, strlen(url), false, nullptr, &original, &original_parsed);
+  ASSERT_TRUE(original_parsed.potentially_dangling_markup);
+
+  // Perform a replacement, and validate that the potentially_dangling_markup
+  // flag carried over to the new Parsed object.
+  Replacements<char> replacements;
+  const char* new_scheme = "https";
+  replacements.SetScheme(new_scheme, Component(0, strlen(new_scheme)));
+  Parsed replaced_parsed;
+  RawCanonOutput<32> replaced;
+  ReplaceComponents(original.data(), original.length(), original_parsed,
+                    replacements, nullptr, &replaced, &replaced_parsed);
+  EXPECT_TRUE(replaced_parsed.potentially_dangling_markup);
+}
+
 TEST_F(URLUtilTest, TestDomainIs) {
   const struct {
     const char* canonicalized_host;