diff --git a/AUTHORS b/AUTHORS
index 4bb6b20..1aa2922 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -43,6 +43,7 @@
 Aku Kotkavuo <a.kotkavuo@partner.samsung.com>
 Aldo Culquicondor <alculquicondor@gmail.com>
 Aleksandar Stojiljkovic <aleksandar.stojiljkovic@intel.com>
+Aleksei Gurianov <gurianov@gmail.com>
 Alex Chronopoulos <achronop@gmail.com>
 Alex Gabriel <minilogo@gmail.com>
 Alex Gartrell <agartrell@cmu.edu>
@@ -126,6 +127,7 @@
 Asami Doi <d0iasm.pub@gmail.com>
 Ashish Kumar Gupta <guptaag@amazon.com>
 Ashlin Joseph <ashlin.j@samsung.com>
+Ashutosh  <coder.commando@gmail.com>
 Asish Singh <asish.singh@samsung.com>
 Attila Dusnoki <dati91@gmail.com>
 Avinaash Doreswamy <avi.nitk@samsung.com>
@@ -210,6 +212,7 @@
 Chris Tserng <tserng@amazon.com>
 Chris Vasselli <clindsay@gmail.com>
 Chris Ye <hawkoyates@gmail.com>
+Christoph Durschang <christoph142@gmx.com>
 Christophe Dumez <ch.dumez@samsung.com>
 Christopher Dale <chrelad@gmail.com>
 Chunbo Hua <chunbo.hua@intel.com>
@@ -286,6 +289,7 @@
 Donghee Na <corona10@gmail.com>
 Dong-hee Na <donghee.na92@gmail.com>
 Dongie Agnir <dongie.agnir@gmail.com>
+Dongjun Kim <deejay.kim@navercorp.com>
 Dongjun Kim <djmix.kim@samsung.com>
 Dongseong Hwang <dongseong.hwang@intel.com>
 Dongwoo Joshua Im <dw.im@samsung.com>
@@ -308,11 +312,14 @@
 Elan Ruusamäe <elan.ruusamae@gmail.com>
 Ergun Erdogmus <erdogmusergun@gmail.com>
 Eric Ahn <byungwook.ahn@gmail.com>
+Eric Huang <ele828@gmail.com>
 Eric Rescorla <ekr@rtfm.com>
 Erik Hill <erikghill@gmail.com>
+Erik Kurzinger <ekurzinger@gmail.com>
 Erik Sjölund <erik.sjolund@gmail.com>
 Eriq Augustine <eriq.augustine@gmail.com>
 Ernesto Mudu <ernesto.mudu@gmail.com>
+Ethan Wong <bunnnywong@gmail.com>
 Etienne Laurin <etienne@atnnn.com>
 Eugene Kim <eugene70kim@gmail.com>
 Eugene Sudin <eugene@sudin.pro>
@@ -415,6 +422,7 @@
 HyunJi Kim <hjkim3323@gmail.com>
 Hyunjun Shin <hyunjun.shin2@navercorp.com>
 Hyunjun Shin <shjj1504@gmail.com>
+Hyunjune Kim <hyunjune.kim@navercorp.com>
 Hyunjune Kim <hyunjune.kim@samsung.com>
 Hyunki Baik <hyunki.baik@samsung.com>
 Ian Cullinan <cullinan@amazon.com>
@@ -479,6 +487,7 @@
 Jerry Lin <wahahab11@gmail.com>
 Jerry Zhang <zhj8407@gmail.com>
 Jesper Storm Bache <jsbache@gmail.com>
+Jesper van den Ende <jespertheend@gmail.com>
 Jesse Miller <jesse@jmiller.biz>
 Jesus Sanchez-Palencia <jesus.sanchez-palencia.fernandez.fil@intel.com>
 Jiadong Chen <chenjiadong@huawei.com>
@@ -547,6 +556,7 @@
 Josué Ratelle <jorat1346@gmail.com>
 Josyula Venkat Narasimham <venkat.nj@samsung.com>
 Joyer Huang <collger@gmail.com>
+Juan Cruz Viotti <jv@jviotti.com>
 Juan Jose Lopez Jaimez <jj.lopezjaimez@gmail.com>
 Juhui Lee <juhui24.lee@samsung.com>
 Julian Geppert <spctstr@gmail.com>
@@ -562,6 +572,7 @@
 Jungkee Song <jungkee.song@samsung.com>
 Junmin Zhu <junmin.zhu@intel.com>
 Junsong Li <ljs.darkfish@gmail.com>
+Jun Zeng <hjunzeng6@gmail.com>
 Justin Okamoto <justmoto@amazon.com>
 Justin Ribeiro <justin@justinribeiro.com>
 Jüri Valdmann <juri.valdmann@qt.io>
@@ -657,6 +668,7 @@
 Lucie Brozkova <lucinka.brozkova@gmail.com>
 Luiz Von Dentz <luiz.von.dentz@intel.com>
 Luka Dojcilovic <l.dojcilovic@gmail.com>
+Lukas Lihotzki <lukas@lihotzki.de>
 Lukasz Krakowiak <lukasz.krakowiak@mobica.com>
 Luke Inman-Semerau <luke.semerau@gmail.com>
 Luke Seunghoe Gu <gulukesh@gmail.com>
@@ -714,7 +726,9 @@
 Matthias Reitinger <reimarvin@gmail.com>
 Matthieu Rigolot <matthieu.rigolot@gmail.com>
 Matthieu Vlad Hauglustaine <matt.hauglustaine@gmail.com>
+Max Karolinskiy <max@brave.com>
 Max Perepelitsyn <pph34r@gmail.com>
+Max Schmitt <max@schmitt.mx>
 Max Vujovic <mvujovic@adobe.com>
 Mayank Gupta <mayank.g1@samsung.com>
 Mayur Kankanwadi <mayurk.vk@samsung.com>
@@ -732,6 +746,7 @@
 Michael Müller <michael@fds-team.de>
 Michael Schechter <mike.schechter@gmail.com>
 Michael Smith <sideshowbarker@gmail.com>
+Michael Weiss <dev.primeos@gmail.com>
 Michaël Zasso <mic.besace@gmail.com>
 Michael Zugelder <michael@zugelder.org>
 Michel Promonet <michel.promonet.1@gmail.com>
@@ -764,6 +779,7 @@
 Momoko Hattori <momohatt10@gmail.com>
 Mostafa Sedaghat joo <mostafa.sedaghat@gmail.com>
 Mrunal Kapade <mrunal.kapade@intel.com>
+Munira Tursunova <moonira@google.com>
 Myeongjin Cho <myeongjin.cho@navercorp.com>
 Myles C. Maxfield <mymax@amazon.com>
 Myung-jong Kim <mjkim610@gmail.com>
@@ -889,6 +905,7 @@
 Reda Tawfik <redatawfik@noogler.google.com>
 Réda Housni Alaoui <alaoui.rda@gmail.com>
 Refael Ackermann <refack@gmail.com>
+Rémi Arnaud <jsremi@gmail.com>
 Renata Hodovan <rhodovan.u-szeged@partner.samsung.com>
 Rene Bolldorf <rb@radix.io>
 Rene Ladan <r.c.ladan@gmail.com>
@@ -922,6 +939,7 @@
 Rulong Chen <rulong.crl@alibaba-inc.com>
 Russell Davis <russell.davis@gmail.com>
 Ryan Ackley <ryanackley@gmail.com>
+Ryan Gonzalez <rymg19@gmail.com>
 Ryan Norton <rnorton10@gmail.com>
 Ryan Sleevi <ryan-chromium-dev@sleevi.com>
 Ryan Yoakum <ryoakum@skobalt.com>
@@ -1038,6 +1056,7 @@
 Sumaid Syed <sumaidsyed@gmail.com>
 Sunchang Li <johnstonli@tencent.com>
 Sundoo Kim <nerdooit@gmail.com>
+Sundoo Kim <0xd00d00b@gmail.com>
 Suneel Kota <suneel.kota@samsung.com>
 Sungguk Lim <limasdf@gmail.com>
 Sungmann Cho <sungmann.cho@gmail.com>
@@ -1086,6 +1105,8 @@
 Timo Reimann <ttr314@googlemail.com>
 Timo Witte <timo.witte@gmail.com>
 Ting Shao <ting.shao@intel.com>
+Tobias Soppa <tobias@soppa.me>
+Tobias Soppa <tobias.soppa@code.berlin>
 Tom Callaway <tcallawa@redhat.com>
 Tom Harwood <tfh@skip.org>
 Tomas Popela <tomas.popela@gmail.com>
@@ -1114,6 +1135,7 @@
 Vernon Tang <vt@foilhead.net>
 Viatcheslav Ostapenko <sl.ostapenko@samsung.com>
 Victor Costan <costan@gmail.com>
+Victor Solonsky <victor.solonsky@gmail.com>
 Viet-Trung Luu <viettrungluu@gmail.com>
 Vinay Anantharaman <vinaya@adobe.com>
 Vinoth Chandar <vinoth@uber.com>
@@ -1141,6 +1163,7 @@
 Xiang Long <xiang.long@intel.com>
 XiangYang <yangxiang12@huawei.com>
 Xiangze Zhang <xiangze.zhang@intel.com>
+Xiaobing Yang <yangxiaobing@qianxin.com>
 Xiaofeng Zhang <xiaofeng.zhang@intel.com>
 Xiaolei Yu <dreifachstein@gmail.com>
 Xiaoshu Zhang <xiaoshu@amazon.com>
@@ -1222,6 +1245,7 @@
 # END individuals section.
 
 # BEGIN organizations section.
+Accenture <*@accenture.com>
 ACCESS CO., LTD. <*@access-company.com>
 Akamai Inc. <*@akamai.com>
 ARM Holdings <*@arm.com>
diff --git a/base/BUILD b/base/BUILD
index c933421..e2da292 100644
--- a/base/BUILD
+++ b/base/BUILD
@@ -14,6 +14,7 @@
         "containers/span.h",
         "containers/util.h",
         "cxx17_backports.h",
+        "cxx20_to_address.h",
         "debug/leak_annotations.h",
         "functional/identity.h",
         "functional/invoke.h",
diff --git a/base/compiler_specific.h b/base/compiler_specific.h
index 3faca72..6651220 100644
--- a/base/compiler_specific.h
+++ b/base/compiler_specific.h
@@ -308,6 +308,31 @@
 #define STACK_UNINITIALIZED
 #endif
 
+// Attribute "no_stack_protector" disables -fstack-protector for the specified
+// function.
+//
+// "stack_protector" is enabled on most POSIX builds. The flag adds a canary
+// to each stack frame, which on function return is checked against a reference
+// canary. If the canaries do not match, it's likely that a stack buffer
+// overflow has occurred, so immediately crashing will prevent exploitation in
+// many cases.
+//
+// In some cases it's desirable to remove this, e.g. on hot functions, or if
+// we have purposely changed the reference canary.
+#if defined(COMPILER_GCC) || defined(__clang__)
+#if defined(__has_attribute)
+#if __has_attribute(__no_stack_protector__)
+#define NO_STACK_PROTECTOR __attribute__((__no_stack_protector__))
+#else  // __has_attribute(__no_stack_protector__)
+#define NO_STACK_PROTECTOR __attribute__((__optimize__("-fno-stack-protector")))
+#endif
+#else  // defined(__has_attribute)
+#define NO_STACK_PROTECTOR __attribute__((__optimize__("-fno-stack-protector")))
+#endif
+#else
+#define NO_STACK_PROTECTOR
+#endif
+
 // The ANALYZER_ASSUME_TRUE(bool arg) macro adds compiler-specific hints
 // to Clang which control what code paths are statically analyzed,
 // and is meant to be used in conjunction with assert & assert-like functions.
diff --git a/base/containers/span.h b/base/containers/span.h
index 1a54de1..d43814e 100644
--- a/base/containers/span.h
+++ b/base/containers/span.h
@@ -17,8 +17,9 @@
 #include "polyfills/base/check_op.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/macros.h"
-#include "base/stl_util.h"
 #include "base/template_util.h"
 
 namespace gurl_base {
diff --git a/base/cxx17_backports.h b/base/cxx17_backports.h
index 6378a78..77d689a 100644
--- a/base/cxx17_backports.h
+++ b/base/cxx17_backports.h
@@ -6,10 +6,13 @@
 #define BASE_CXX17_BACKPORTS_H_
 
 #include <array>
+#include <functional>
 #include <initializer_list>
 #include <memory>
 #include <string>
 
+#include "polyfills/base/check.h"
+
 namespace gurl_base {
 
 // C++14 implementation of C++17's std::size():
@@ -89,6 +92,22 @@
   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
+// with a value of `lo` that compares greater than the value of `hi`. This
+// implementation uses a GURL_CHECK to enforce this as a hard restriction.
+template <typename T, typename Compare>
+constexpr const T& clamp(const T& v, const T& lo, const T& hi, Compare comp) {
+  GURL_CHECK(!comp(hi, lo));
+  return comp(v, lo) ? lo : comp(hi, v) ? hi : v;
+}
+
+template <typename T>
+constexpr const T& clamp(const T& v, const T& lo, const T& hi) {
+  return clamp(v, lo, hi, std::less<T>{});
+}
+
 }  // namespace base
 
 #endif  // BASE_CXX17_BACKPORTS_H_
diff --git a/base/no_destructor.h b/base/no_destructor.h
index 3d7a85c..2f3c549 100644
--- a/base/no_destructor.h
+++ b/base/no_destructor.h
@@ -6,9 +6,15 @@
 #define BASE_NO_DESTRUCTOR_H_
 
 #include <new>
+#include <type_traits>
 #include <utility>
 
 namespace gurl_base {
+// A tag type used for NoDestructor to allow it to be created for a type that
+// has a trivial destructor. Use for cases where the same class might have
+// different implementations that vary on destructor triviality or when the
+// LSan hiding properties of NoDestructor are needed.
+struct AllowForTriviallyDestructibleType;
 
 // A wrapper that makes it easy to create an object of type T with static
 // storage duration that:
@@ -44,9 +50,20 @@
 // Note that since the destructor is never run, this *will* leak memory if used
 // as a stack or member variable. Furthermore, a NoDestructor<T> should never
 // have global scope as that may require a static initializer.
-template <typename T>
+template <typename T, typename O = std::nullptr_t>
 class NoDestructor {
  public:
+  static_assert(
+      !std::is_trivially_destructible<T>::value ||
+          std::is_same<O, AllowForTriviallyDestructibleType>::value,
+      "gurl_base::NoDestructor is not needed because the templated class has a "
+      "trivial destructor");
+
+  static_assert(std::is_same<O, AllowForTriviallyDestructibleType>::value ||
+                    std::is_same<O, std::nullptr_t>::value,
+                "AllowForTriviallyDestructibleType is the only valid option "
+                "for the second template parameter of NoDestructor");
+
   // Not constexpr; just write static constexpr T x = ...; if the value should
   // be a constexpr.
   template <typename... Args>
diff --git a/base/stl_util.h b/base/stl_util.h
index 609b71a..46e91b9 100644
--- a/base/stl_util.h
+++ b/base/stl_util.h
@@ -8,22 +8,13 @@
 #define BASE_STL_UTIL_H_
 
 #include <algorithm>
-#include <deque>
 #include <forward_list>
 #include <iterator>
-#include <list>
-#include <map>
-#include <set>
-#include <string>
 #include <tuple>
 #include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
 #include <utility>
-#include <vector>
 
 #include "polyfills/base/check.h"
-#include "base/cxx17_backports.h"
 #include "base/ranges/algorithm.h"
 #include "absl/types/optional.h"
 
@@ -31,20 +22,6 @@
 
 namespace internal {
 
-// Calls erase on iterators of matching elements and returns the number of
-// removed elements.
-template <typename Container, typename Predicate>
-size_t IterateAndEraseIf(Container& container, Predicate pred) {
-  size_t old_size = container.size();
-  for (auto it = container.begin(), last = container.end(); it != last;) {
-    if (pred(*it))
-      it = container.erase(it);
-    else
-      ++it;
-  }
-  return old_size - container.size();
-}
-
 template <typename Iter>
 constexpr bool IsRandomAccessIter =
     std::is_same<typename std::iterator_traits<Iter>::iterator_category,
@@ -52,23 +29,6 @@
 
 }  // namespace internal
 
-// Simplified C++14 implementation of  C++20's std::to_address.
-// Note: This does not consider specializations of pointer_traits<>::to_address,
-// since that member function may only be present in C++20 and later.
-//
-// Reference: https://wg21.link/pointer.conversion#lib:to_address
-template <typename T>
-constexpr T* to_address(T* p) noexcept {
-  static_assert(!std::is_function<T>::value,
-                "Error: T must not be a function type.");
-  return p;
-}
-
-template <typename Ptr>
-constexpr auto to_address(const Ptr& p) noexcept {
-  return to_address(p.operator->());
-}
-
 // Implementation of C++23's std::to_underlying.
 //
 // Note: This has an additional `std::is_enum<EnumT>` requirement to be SFINAE
@@ -348,167 +308,6 @@
   return result;
 }
 
-// Erase/EraseIf are based on C++20's uniform container erasure API:
-// - https://eel.is/c++draft/libraryindex#:erase
-// - https://eel.is/c++draft/libraryindex#:erase_if
-// They provide a generic way to erase elements from a container.
-// The functions here implement these for the standard containers until those
-// functions are available in the C++ standard.
-// For Chromium containers overloads should be defined in their own headers
-// (like standard containers).
-// Note: there is no std::erase for standard associative containers so we don't
-// have it either.
-
-template <typename CharT, typename Traits, typename Allocator, typename Value>
-size_t Erase(std::basic_string<CharT, Traits, Allocator>& container,
-             const Value& value) {
-  auto it = std::remove(container.begin(), container.end(), value);
-  size_t removed = std::distance(it, container.end());
-  container.erase(it, container.end());
-  return removed;
-}
-
-template <typename CharT, typename Traits, typename Allocator, class Predicate>
-size_t EraseIf(std::basic_string<CharT, Traits, Allocator>& container,
-               Predicate pred) {
-  auto it = std::remove_if(container.begin(), container.end(), pred);
-  size_t removed = std::distance(it, container.end());
-  container.erase(it, container.end());
-  return removed;
-}
-
-template <class T, class Allocator, class Value>
-size_t Erase(std::deque<T, Allocator>& container, const Value& value) {
-  auto it = std::remove(container.begin(), container.end(), value);
-  size_t removed = std::distance(it, container.end());
-  container.erase(it, container.end());
-  return removed;
-}
-
-template <class T, class Allocator, class Predicate>
-size_t EraseIf(std::deque<T, Allocator>& container, Predicate pred) {
-  auto it = std::remove_if(container.begin(), container.end(), pred);
-  size_t removed = std::distance(it, container.end());
-  container.erase(it, container.end());
-  return removed;
-}
-
-template <class T, class Allocator, class Value>
-size_t Erase(std::vector<T, Allocator>& container, const Value& value) {
-  auto it = std::remove(container.begin(), container.end(), value);
-  size_t removed = std::distance(it, container.end());
-  container.erase(it, container.end());
-  return removed;
-}
-
-template <class T, class Allocator, class Predicate>
-size_t EraseIf(std::vector<T, Allocator>& container, Predicate pred) {
-  auto it = std::remove_if(container.begin(), container.end(), pred);
-  size_t removed = std::distance(it, container.end());
-  container.erase(it, container.end());
-  return removed;
-}
-
-template <class T, class Allocator, class Predicate>
-size_t EraseIf(std::forward_list<T, Allocator>& container, Predicate pred) {
-  // Note: std::forward_list does not have a size() API, thus we need to use the
-  // O(n) std::distance work-around. However, given that EraseIf is O(n)
-  // already, this should not make a big difference.
-  size_t old_size = std::distance(container.begin(), container.end());
-  container.remove_if(pred);
-  return old_size - std::distance(container.begin(), container.end());
-}
-
-template <class T, class Allocator, class Predicate>
-size_t EraseIf(std::list<T, Allocator>& container, Predicate pred) {
-  size_t old_size = container.size();
-  container.remove_if(pred);
-  return old_size - container.size();
-}
-
-template <class Key, class T, class Compare, class Allocator, class Predicate>
-size_t EraseIf(std::map<Key, T, Compare, Allocator>& container,
-               Predicate pred) {
-  return internal::IterateAndEraseIf(container, pred);
-}
-
-template <class Key, class T, class Compare, class Allocator, class Predicate>
-size_t EraseIf(std::multimap<Key, T, Compare, Allocator>& container,
-               Predicate pred) {
-  return internal::IterateAndEraseIf(container, pred);
-}
-
-template <class Key, class Compare, class Allocator, class Predicate>
-size_t EraseIf(std::set<Key, Compare, Allocator>& container, Predicate pred) {
-  return internal::IterateAndEraseIf(container, pred);
-}
-
-template <class Key, class Compare, class Allocator, class Predicate>
-size_t EraseIf(std::multiset<Key, Compare, Allocator>& container,
-               Predicate pred) {
-  return internal::IterateAndEraseIf(container, pred);
-}
-
-template <class Key,
-          class T,
-          class Hash,
-          class KeyEqual,
-          class Allocator,
-          class Predicate>
-size_t EraseIf(std::unordered_map<Key, T, Hash, KeyEqual, Allocator>& container,
-               Predicate pred) {
-  return internal::IterateAndEraseIf(container, pred);
-}
-
-template <class Key,
-          class T,
-          class Hash,
-          class KeyEqual,
-          class Allocator,
-          class Predicate>
-size_t EraseIf(
-    std::unordered_multimap<Key, T, Hash, KeyEqual, Allocator>& container,
-    Predicate pred) {
-  return internal::IterateAndEraseIf(container, pred);
-}
-
-template <class Key,
-          class Hash,
-          class KeyEqual,
-          class Allocator,
-          class Predicate>
-size_t EraseIf(std::unordered_set<Key, Hash, KeyEqual, Allocator>& container,
-               Predicate pred) {
-  return internal::IterateAndEraseIf(container, pred);
-}
-
-template <class Key,
-          class Hash,
-          class KeyEqual,
-          class Allocator,
-          class Predicate>
-size_t EraseIf(
-    std::unordered_multiset<Key, Hash, KeyEqual, Allocator>& container,
-    Predicate pred) {
-  return internal::IterateAndEraseIf(container, pred);
-}
-
-template <class T, class Allocator, class Value>
-size_t Erase(std::forward_list<T, Allocator>& container, const Value& value) {
-  // Unlike std::forward_list::remove, this function template accepts
-  // heterogeneous types and does not force a conversion to the container's
-  // value type before invoking the == operator.
-  return EraseIf(container, [&](const T& cur) { return cur == value; });
-}
-
-template <class T, class Allocator, class Value>
-size_t Erase(std::list<T, Allocator>& container, const Value& value) {
-  // Unlike std::list::remove, this function template accepts heterogeneous
-  // types and does not force a conversion to the container's value type before
-  // invoking the == operator.
-  return EraseIf(container, [&](const T& cur) { return cur == value; });
-}
-
 // A helper class to be used as the predicate with |EraseIf| to implement
 // in-place set intersection. Helps implement the algorithm of going through
 // each container an element at a time, erasing elements from the first
diff --git a/base/strings/escape_unittest.cc b/base/strings/escape_unittest.cc
index b8a5fd6..923eb5a 100644
--- a/base/strings/escape_unittest.cc
+++ b/base/strings/escape_unittest.cc
@@ -421,8 +421,10 @@
   EXPECT_TRUE(ContainsEncodedBytes("abc%2fdef", {'/', '\\'}));
 
   // Should be looking for byte values, not UTF-8 character values.
-  EXPECT_TRUE(ContainsEncodedBytes("caf%C3%A9", {'\xc3'}));
-  EXPECT_FALSE(ContainsEncodedBytes("caf%C3%A9", {'\xe9'}));
+  EXPECT_TRUE(
+      ContainsEncodedBytes("caf%C3%A9", {static_cast<uint8_t>('\xc3')}));
+  EXPECT_FALSE(
+      ContainsEncodedBytes("caf%C3%A9", {static_cast<uint8_t>('\xe9')}));
 }
 
 }  // namespace base
diff --git a/base/strings/safe_sprintf.cc b/base/strings/safe_sprintf.cc
index e8bb070..0569da1 100644
--- a/base/strings/safe_sprintf.cc
+++ b/base/strings/safe_sprintf.cc
@@ -490,7 +490,6 @@
             goto format_character_found;
           }
         }
-        break;
       case 'c': {  // Output an ASCII character.
         // Check that there are arguments left to be inserted.
         if (cur_arg >= max_args) {
diff --git a/base/strings/safe_sprintf.h b/base/strings/safe_sprintf.h
index 92f8c59..40cddc5 100644
--- a/base/strings/safe_sprintf.h
+++ b/base/strings/safe_sprintf.h
@@ -5,12 +5,12 @@
 #ifndef BASE_STRINGS_SAFE_SPRINTF_H_
 #define BASE_STRINGS_SAFE_SPRINTF_H_
 
-#include "build/build_config.h"
-
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
 
+#include "build/build_config.h"
+
 #if defined(OS_POSIX) || defined(OS_FUCHSIA)
 // For ssize_t
 #include <unistd.h>
diff --git a/base/strings/string_number_conversions_internal.h b/base/strings/string_number_conversions_internal.h
index 8223b59..8c45d1b 100644
--- a/base/strings/string_number_conversions_internal.h
+++ b/base/strings/string_number_conversions_internal.h
@@ -14,7 +14,6 @@
 
 #include "polyfills/base/check_op.h"
 #include "polyfills/base/logging.h"
-#include "base/no_destructor.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/string_util.h"
 #include "base/third_party/double_conversion/double-conversion/double-conversion.h"
@@ -229,10 +228,10 @@
 
 static const double_conversion::DoubleToStringConverter*
 GetDoubleToStringConverter() {
-  static NoDestructor<double_conversion::DoubleToStringConverter> converter(
+  static double_conversion::DoubleToStringConverter converter(
       double_conversion::DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN,
       nullptr, nullptr, 'e', -6, 12, 0, 0);
-  return converter.get();
+  return &converter;
 }
 
 // Converts a given (data, size) pair to a desired string type. For
@@ -258,14 +257,14 @@
 
 template <typename STRING, typename CHAR>
 bool StringToDoubleImpl(STRING input, const CHAR* data, double& output) {
-  static NoDestructor<double_conversion::StringToDoubleConverter> converter(
+  static double_conversion::StringToDoubleConverter converter(
       double_conversion::StringToDoubleConverter::ALLOW_LEADING_SPACES |
           double_conversion::StringToDoubleConverter::ALLOW_TRAILING_JUNK,
       0.0, 0, nullptr, nullptr);
 
   int processed_characters_count;
-  output = converter->StringToDouble(data, input.size(),
-                                     &processed_characters_count);
+  output =
+      converter.StringToDouble(data, input.size(), &processed_characters_count);
 
   // Cases to return false:
   //  - If the input string is empty, there was nothing to parse.
diff --git a/base/strings/string_number_conversions_unittest.cc b/base/strings/string_number_conversions_unittest.cc
index f836316..b5a23a1 100644
--- a/base/strings/string_number_conversions_unittest.cc
+++ b/base/strings/string_number_conversions_unittest.cc
@@ -14,8 +14,8 @@
 #include <limits>
 
 #include "base/bit_cast.h"
+#include "base/cxx17_backports.h"
 #include "base/format_macros.h"
-#include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
diff --git a/base/strings/string_piece.h b/base/strings/string_piece.h
index 03f5103..8a22e8d 100644
--- a/base/strings/string_piece.h
+++ b/base/strings/string_piece.h
@@ -25,7 +25,6 @@
 
 #include <iosfwd>
 #include <limits>
-#include <ostream>
 #include <string>
 #include <type_traits>
 
diff --git a/base/strings/string_util.cc b/base/strings/string_util.cc
index f76d2f7..2adfa94 100644
--- a/base/strings/string_util.cc
+++ b/base/strings/string_util.cc
@@ -22,8 +22,8 @@
 #include <vector>
 
 #include "polyfills/base/check_op.h"
+#include "base/cxx17_backports.h"
 #include "base/no_destructor.h"
-#include "base/stl_util.h"
 #include "base/strings/string_util_internal.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/strings/utf_string_conversions.h"
diff --git a/base/strings/string_util.h b/base/strings/string_util.h
index ccbf745..5995c2d 100644
--- a/base/strings/string_util.h
+++ b/base/strings/string_util.h
@@ -20,6 +20,7 @@
 #include "polyfills/base/base_export.h"
 #include "base/compiler_specific.h"
 #include "base/containers/span.h"
+#include "base/cxx20_to_address.h"
 #include "base/strings/string_piece.h"  // For implicit conversions.
 #include "build/build_config.h"
 
diff --git a/base/strings/string_util_unittest.cc b/base/strings/string_util_unittest.cc
index f8326cc..231c3c8 100644
--- a/base/strings/string_util_unittest.cc
+++ b/base/strings/string_util_unittest.cc
@@ -14,7 +14,7 @@
 #include <type_traits>
 
 #include "base/bits.h"
-#include "base/stl_util.h"
+#include "base/cxx17_backports.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
diff --git a/base/strings/stringprintf.cc b/base/strings/stringprintf.cc
index e1a18c9..3f74e07 100644
--- a/base/strings/stringprintf.cc
+++ b/base/strings/stringprintf.cc
@@ -9,9 +9,9 @@
 
 #include <vector>
 
+#include "base/cxx17_backports.h"
 #include "polyfills/base/logging.h"
 #include "base/scoped_clear_last_error.h"
-#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
diff --git a/base/strings/utf_offset_string_conversions_unittest.cc b/base/strings/utf_offset_string_conversions_unittest.cc
index 0775dc4..f50fa3f 100644
--- a/base/strings/utf_offset_string_conversions_unittest.cc
+++ b/base/strings/utf_offset_string_conversions_unittest.cc
@@ -6,7 +6,7 @@
 
 #include <algorithm>
 
-#include "base/stl_util.h"
+#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"
diff --git a/base/strings/utf_string_conversions.cc b/base/strings/utf_string_conversions.cc
index 9595e7b..8cf90f1 100644
--- a/base/strings/utf_string_conversions.cc
+++ b/base/strings/utf_string_conversions.cc
@@ -7,6 +7,7 @@
 #include <limits.h>
 #include <stdint.h>
 
+#include <ostream>
 #include <type_traits>
 
 #include "base/strings/string_piece.h"
diff --git a/base/strings/utf_string_conversions_unittest.cc b/base/strings/utf_string_conversions_unittest.cc
index 752bf95..3b26fa8 100644
--- a/base/strings/utf_string_conversions_unittest.cc
+++ b/base/strings/utf_string_conversions_unittest.cc
@@ -4,7 +4,7 @@
 
 #include <stddef.h>
 
-#include "base/stl_util.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"
diff --git a/base/template_util.h b/base/template_util.h
index 78b52ee..d0803f8 100644
--- a/base/template_util.h
+++ b/base/template_util.h
@@ -10,11 +10,14 @@
 #include <iterator>
 #include <type_traits>
 #include <utility>
-#include <vector>
 
 #include "base/compiler_specific.h"
 #include "build/build_config.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
diff --git a/copy.bara.sky b/copy.bara.sky
index 1384bee..33c0f00 100644
--- a/copy.bara.sky
+++ b/copy.bara.sky
@@ -19,6 +19,7 @@
         "base/containers/span.h",
         "base/containers/util.h",
         "base/cxx17_backports.h",
+        "base/cxx20_to_address.h",
         "base/debug/leak_annotations.h",
         "base/functional/*.h",
         "base/i18n/uchar.h",
@@ -63,7 +64,6 @@
     "base/debug/alias.h",
     "base/export_template.h",
     "base/logging.h",
-    "base/metrics/histogram_macros.h",
     "base/notreached.h",
     "base/trace_event/memory_usage_estimator.h",
     "third_party/perfetto/include/perfetto/tracing/traced_value.h",
diff --git a/url/BUILD b/url/BUILD
index 6ed3fc5..f2ec8da 100644
--- a/url/BUILD
+++ b/url/BUILD
@@ -43,9 +43,7 @@
         "url_file.h",
         "url_util.h",
     ],
-    copts = build_config.default_copts + [
-        "-Wno-c++11-narrowing",
-    ],
+    copts = build_config.default_copts,
     linkopts = build_config.url_linkopts,
     visibility = ["//visibility:public"],
     deps = [
diff --git a/url/gurl.cc b/url/gurl.cc
index 2d68889..18a46f1 100644
--- a/url/gurl.cc
+++ b/url/gurl.cc
@@ -237,11 +237,8 @@
       NULL, &output, &result.parsed_);
 
   output.Complete();
-  if (result.is_valid_ && result.SchemeIsFileSystem()) {
-    result.inner_url_ =
-        std::make_unique<GURL>(result.spec_.data(), result.parsed_.Length(),
-                               *result.parsed_.inner_parsed(), true);
-  }
+
+  ProcessFileOrFileSystemURLAfterReplaceComponents(result);
   return result;
 }
 
@@ -260,14 +257,34 @@
       NULL, &output, &result.parsed_);
 
   output.Complete();
-  if (result.is_valid_ && result.SchemeIsFileSystem()) {
-    result.inner_url_ =
-        std::make_unique<GURL>(result.spec_.data(), result.parsed_.Length(),
-                               *result.parsed_.inner_parsed(), true);
-  }
+
+  ProcessFileOrFileSystemURLAfterReplaceComponents(result);
+
   return result;
 }
 
+void GURL::ProcessFileOrFileSystemURLAfterReplaceComponents(GURL& url) const {
+  if (!url.is_valid_)
+    return;
+  if (url.SchemeIsFileSystem()) {
+    url.inner_url_ =
+        std::make_unique<GURL>(url.spec_.data(), url.parsed_.Length(),
+                               *url.parsed_.inner_parsed(), true);
+  }
+#ifdef WIN32
+  if (url.SchemeIsFile()) {
+    // On Win32, some file URLs created through ReplaceComponents used to lose
+    // its hostname after getting reparsed (e.g. when it's sent through IPC) due
+    // to special handling of file URLs with Windows-drive paths in the URL
+    // parser. To make the behavior for URLs modified through ReplaceComponents
+    // (instead of getting fully reparsed) the same, immediately reparse the
+    // URL here to trigger the special handling.
+    // See https://crbug.com/1214098.
+    url = GURL(url.spec());
+  }
+#endif
+}
+
 GURL GURL::GetOrigin() const {
   // This doesn't make sense for invalid or nonstandard URLs, so return
   // the empty URL.
diff --git a/url/gurl.h b/url/gurl.h
index 21e6611..c70c5a4 100644
--- a/url/gurl.h
+++ b/url/gurl.h
@@ -468,6 +468,8 @@
     return gurl_base::StringPiece(&spec_[comp.begin], comp.len);
   }
 
+  void ProcessFileOrFileSystemURLAfterReplaceComponents(GURL& url) const;
+
   // The actual text of the URL, in canonical ASCII form.
   std::string spec_;
 
diff --git a/url/gurl_unittest.cc b/url/gurl_unittest.cc
index 0b81da4..f3b9f3c 100644
--- a/url/gurl_unittest.cc
+++ b/url/gurl_unittest.cc
@@ -4,7 +4,7 @@
 
 #include <stddef.h>
 
-#include "base/stl_util.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"
@@ -561,12 +561,12 @@
   GURL url(" data: one ? two # three ");
 
   // By default the trailing whitespace will have been stripped.
-  EXPECT_EQ("data: one ? two #%20three", url.spec());
+  EXPECT_EQ("data: one ?%20two%20#%20three", url.spec());
   GURL::Replacements repl;
   repl.ClearRef();
   GURL url_no_ref = url.ReplaceComponents(repl);
 
-  EXPECT_EQ("data: one ? two ", url_no_ref.spec());
+  EXPECT_EQ("data: one ?%20two%20", url_no_ref.spec());
 
   // Importing a parsed URL via this constructor overload will retain trailing
   // whitespace.
@@ -574,7 +574,7 @@
                   url_no_ref.parsed_for_possibly_invalid_spec(),
                   url_no_ref.is_valid());
   EXPECT_EQ(url_no_ref, import_url);
-  EXPECT_EQ(import_url.query(), " two ");
+  EXPECT_EQ(import_url.query(), "%20two%20");
 }
 
 TEST(GURLTest, PathForRequest) {
@@ -862,7 +862,7 @@
       {"http://www.example.com/GUID#ref", "www.example.com/GUID"},
       {"http://me:secret@example.com/GUID/#ref", "me:secret@example.com/GUID/"},
       {"data:text/html,Question?<div style=\"color: #bad\">idea</div>",
-       "text/html,Question?<div style=\"color: "},
+       "text/html,Question?%3Cdiv%20style=%22color:%20"},
 
       // TODO(mkwst): This seems like a bug. https://crbug.com/513600
       {"filesystem:http://example.com/path", "/"},
diff --git a/url/origin.cc b/url/origin.cc
index 33e26f9..6c7915f 100644
--- a/url/origin.cc
+++ b/url/origin.cc
@@ -7,6 +7,7 @@
 #include <stdint.h>
 
 #include <algorithm>
+#include <ostream>
 #include <vector>
 
 #include "base/base64.h"
@@ -423,11 +424,11 @@
 }
 
 // Moving a nonce does NOT trigger lazy-generation of the token.
-Origin::Nonce::Nonce(Origin::Nonce&& other) : token_(other.token_) {
+Origin::Nonce::Nonce(Origin::Nonce&& other) noexcept : token_(other.token_) {
   other.token_ = gurl_base::UnguessableToken();  // Reset |other|.
 }
 
-Origin::Nonce& Origin::Nonce::operator=(Origin::Nonce&& other) {
+Origin::Nonce& Origin::Nonce::operator=(Origin::Nonce&& other) noexcept {
   token_ = other.token_;
   other.token_ = gurl_base::UnguessableToken();  // Reset |other|.
   return *this;
diff --git a/url/origin_abstract_tests.h b/url/origin_abstract_tests.h
index 0c53f82..82d1f55 100644
--- a/url/origin_abstract_tests.h
+++ b/url/origin_abstract_tests.h
@@ -11,7 +11,6 @@
 #include "base/containers/contains.h"
 #include "base/strings/string_piece.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "absl/types/optional.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 #include "url/scheme_host_port.h"
diff --git a/url/origin_unittest.cc b/url/origin_unittest.cc
index a9d3a4f..cb78bb6 100644
--- a/url/origin_unittest.cc
+++ b/url/origin_unittest.cc
@@ -704,17 +704,19 @@
     EXPECT_EQ(origin.GetDebugString(), deserialized.value().GetDebugString());
   }
 
-  // Same basic test as above, but without a GURL to create tuple_.
-  Origin opaque;
-  absl::optional<std::string> serialized = SerializeWithNonce(opaque);
-  ASSERT_TRUE(serialized);
+  {
+    // Same basic test as above, but without a GURL to create tuple_.
+    Origin opaque;
+    absl::optional<std::string> serialized = SerializeWithNonce(opaque);
+    ASSERT_TRUE(serialized);
 
-  absl::optional<Origin> deserialized = Deserialize(std::move(*serialized));
-  ASSERT_TRUE(deserialized.has_value());
+    absl::optional<Origin> deserialized = Deserialize(std::move(*serialized));
+    ASSERT_TRUE(deserialized.has_value());
 
-  // Can't use DoEqualityComparisons here since empty nonces are never == unless
-  // they are the same object.
-  EXPECT_EQ(opaque.GetDebugString(), deserialized.value().GetDebugString());
+    // Can't use DoEqualityComparisons here since empty nonces are never ==
+    // unless they are the same object.
+    EXPECT_EQ(opaque.GetDebugString(), deserialized.value().GetDebugString());
+  }
 
   // Now force initialization of the nonce prior to serialization.
   for (const GURL& url : invalid_urls) {
diff --git a/url/scheme_host_port_unittest.cc b/url/scheme_host_port_unittest.cc
index a1f415d..a8bde47 100644
--- a/url/scheme_host_port_unittest.cc
+++ b/url/scheme_host_port_unittest.cc
@@ -5,7 +5,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include "base/stl_util.h"
+#include "base/cxx17_backports.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/scheme_host_port.h"
diff --git a/url/third_party/mozilla/url_parse.cc b/url/third_party/mozilla/url_parse.cc
index e8a1edb..8edb7f3 100644
--- a/url/third_party/mozilla/url_parse.cc
+++ b/url/third_party/mozilla/url_parse.cc
@@ -38,6 +38,8 @@
 
 #include <stdlib.h>
 
+#include <ostream>
+
 #include "polyfills/base/check_op.h"
 #include "url/url_parse_internal.h"
 #include "url/url_util.h"
diff --git a/url/url_canon_host.cc b/url/url_canon_host.cc
index b278b15..abcf615 100644
--- a/url/url_canon_host.cc
+++ b/url/url_canon_host.cc
@@ -3,10 +3,8 @@
 // found in the LICENSE file.
 
 #include "polyfills/base/check.h"
-#include "polyfills/base/metrics/histogram_macros.h"
 #include "url/url_canon.h"
 #include "url/url_canon_internal.h"
-#include "url/url_canon_ip.h"
 
 namespace url {
 
@@ -379,16 +377,6 @@
     if (host_info->IsIPAddress()) {
       output->set_length(output_begin);
       output->Append(canon_ip.data(), canon_ip.length());
-    } else if (host_info->family == CanonHostInfo::NEUTRAL) {
-      // Only need to call CheckHostnameSafety() for valid hosts that aren't IP
-      // addresses and aren't broken.
-      HostSafetyStatus host_safety_status = CheckHostnameSafety(spec, host);
-      // Don't record kOK.  Ratio of OK to not-OK statuses is not meaningful at
-      // this layer, and hostnames are canonicalized a lot.
-      if (host_safety_status != HostSafetyStatus::kOk) {
-        UMA_HISTOGRAM_ENUMERATION("Net.Url.HostSafetyStatus",
-                                  host_safety_status);
-      }
     }
   } else {
     // Canonicalization failed. Set BROKEN to notify the caller.
diff --git a/url/url_canon_icu_unittest.cc b/url/url_canon_icu_unittest.cc
index 7cd5cae..ca13427 100644
--- a/url/url_canon_icu_unittest.cc
+++ b/url/url_canon_icu_unittest.cc
@@ -4,8 +4,8 @@
 
 #include <stddef.h>
 
+#include "base/cxx17_backports.h"
 #include "polyfills/base/logging.h"
-#include "base/stl_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <unicode/ucnv.h>
 #include "url/url_canon.h"
diff --git a/url/url_canon_internal.cc b/url/url_canon_internal.cc
index ab56e7b..99541bd 100644
--- a/url/url_canon_internal.cc
+++ b/url/url_canon_internal.cc
@@ -427,7 +427,7 @@
   }
 
   for (int i = 0; i < written; ++i) {
-    buffer[i] = char16_t{temp[i]};
+    buffer[i] = static_cast<char16_t>(temp[i]);
   }
   buffer[written] = '\0';
   return 0;
diff --git a/url/url_canon_ip.cc b/url/url_canon_ip.cc
index 8234b4e..f0552b5 100644
--- a/url/url_canon_ip.cc
+++ b/url/url_canon_ip.cc
@@ -6,11 +6,10 @@
 
 #include <stdint.h>
 #include <stdlib.h>
+
 #include <limits>
 
 #include "polyfills/base/check.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/string_util.h"
 #include "url/url_canon_internal.h"
 
 namespace url {
@@ -32,56 +31,6 @@
   }
 }
 
-template<typename CHAR, typename UCHAR>
-bool DoFindIPv4Components(const CHAR* spec,
-                          const Component& host,
-                          Component components[4]) {
-  if (!host.is_nonempty())
-    return false;
-
-  int cur_component = 0;  // Index of the component we're working on.
-  int cur_component_begin = host.begin;  // Start of the current component.
-  int end = host.end();
-  for (int i = host.begin; /* nothing */; i++) {
-    if (i >= end || spec[i] == '.') {
-      // Found the end of the current component.
-      int component_len = i - cur_component_begin;
-      components[cur_component] = Component(cur_component_begin, component_len);
-
-      // The next component starts after the dot.
-      cur_component_begin = i + 1;
-      cur_component++;
-
-      // Don't allow empty components (two dots in a row), except we may
-      // allow an empty component at the end (this would indicate that the
-      // input ends in a dot). We also want to error if the component is
-      // empty and it's the only component (cur_component == 1).
-      if (component_len == 0 && (i < end || cur_component == 1))
-        return false;
-
-      if (i >= end)
-        break;  // End of the input.
-
-      if (cur_component == 4) {
-        // Anything else after the 4th component is an error unless it is a
-        // dot that would otherwise be treated as the end of input.
-        if (spec[i] == '.' && i + 1 == end)
-          break;
-        return false;
-      }
-    } else if (static_cast<UCHAR>(spec[i]) >= 0x80 ||
-               !IsIPv4Char(static_cast<unsigned char>(spec[i]))) {
-      // Invalid character for an IPv4 address.
-      return false;
-    }
-  }
-
-  // Fill in any unused components.
-  while (cur_component < 4)
-    components[cur_component++] = Component();
-  return true;
-}
-
 // Converts an IPv4 component to a 32-bit number, while checking for overflow.
 //
 // Possible return values:
@@ -89,13 +38,15 @@
 // - BROKEN  - The input was numeric, but too large for a 32-bit field.
 // - NEUTRAL - Input was not numeric.
 //
-// The input is assumed to be ASCII. FindIPv4Components should have stripped
-// out any input that is greater than 7 bits. The components are assumed
-// to be non-empty.
+// The input is assumed to be ASCII. The components are assumed to be non-empty.
 template<typename CHAR>
 CanonHostInfo::Family IPv4ComponentToNumber(const CHAR* spec,
                                             const Component& component,
                                             uint32_t* number) {
+  // Empty components are considered non-numeric.
+  if (!component.is_nonempty())
+    return CanonHostInfo::NEUTRAL;
+
   // Figure out the base
   SharedCharTypes base;
   int base_prefix_len = 0;  // Size of the prefix for this base.
@@ -127,14 +78,25 @@
   const int kMaxComponentLen = 16;
   char buf[kMaxComponentLen + 1];  // digits + '\0'
   int dest_i = 0;
+  bool may_be_broken_octal = false;
   for (int i = component.begin + base_prefix_len; i < component.end(); i++) {
+    if (spec[i] >= 0x80)
+      return CanonHostInfo::NEUTRAL;
+
     // We know the input is 7-bit, so convert to narrow (if this is the wide
     // version of the template) by casting.
     char input = static_cast<char>(spec[i]);
 
     // Validate that this character is OK for the given base.
-    if (!IsCharOfType(input, base))
-      return CanonHostInfo::NEUTRAL;
+    if (!IsCharOfType(input, base)) {
+      if (IsCharOfType(input, CHAR_DEC)) {
+        // Entirely numeric components with leading 0s that aren't octal are
+        // considered broken.
+        may_be_broken_octal = true;
+      } else {
+        return CanonHostInfo::NEUTRAL;
+      }
+    }
 
     // Fill the buffer, if there's space remaining. This check allows us to
     // verify that all characters are numeric, even those that don't fit.
@@ -142,6 +104,9 @@
       buf[dest_i++] = input;
   }
 
+  if (may_be_broken_octal)
+    return CanonHostInfo::BROKEN;
+
   buf[dest_i] = '\0';
 
   // Use the 64-bit strtoi so we get a big number (no hex, decimal, or octal
@@ -158,64 +123,76 @@
 }
 
 // See declaration of IPv4AddressToNumber for documentation.
-template<typename CHAR>
+template <typename CHAR, typename UCHAR>
 CanonHostInfo::Family DoIPv4AddressToNumber(const CHAR* spec,
-                                            const Component& host,
+                                            Component host,
                                             unsigned char address[4],
                                             int* num_ipv4_components) {
-  // The identified components. Not all may exist.
-  Component components[4];
-  if (!FindIPv4Components(spec, host, components))
+  // Ignore terminal dot, if present.
+  if (host.is_nonempty() && spec[host.end() - 1] == '.')
+    --host.len;
+
+  // Do nothing if empty.
+  if (!host.is_nonempty())
     return CanonHostInfo::NEUTRAL;
 
-  // Convert existing components to digits. Values up to
-  // |existing_components| will be valid.
+  // Read component values.  The first `existing_components` of them are
+  // populated front to back, with the first one corresponding to the last
+  // component, which allows for early exit if the last component isn't a
+  // number.
   uint32_t component_values[4];
   int existing_components = 0;
 
-  // Set to true if one or more components are BROKEN. BROKEN is only
-  // returned if all components are IPV4 or BROKEN, so, for example,
-  // 12345678912345.de returns NEUTRAL rather than broken.
-  bool broken = false;
-  for (int i = 0; i < 4; i++) {
-    if (components[i].len <= 0)
+  int current_component_end = host.end();
+  int current_position = current_component_end;
+  while (true) {
+    // If this is not the first character of a component, go to the next
+    // component.
+    if (current_position != host.begin && spec[current_position - 1] != '.') {
+      --current_position;
       continue;
-    CanonHostInfo::Family family = IPv4ComponentToNumber(
-        spec, components[i], &component_values[existing_components]);
-
-    if (family == CanonHostInfo::BROKEN) {
-      broken = true;
-    } else if (family != CanonHostInfo::IPV4) {
-      // Stop if we hit a non-BROKEN invalid non-empty component.
-      return family;
     }
 
-    existing_components++;
+    CanonHostInfo::Family family = IPv4ComponentToNumber(
+        spec,
+        Component(current_position, current_component_end - current_position),
+        &component_values[existing_components]);
+
+    // If `family` is NEUTRAL and this is the last component, return NEUTRAL. If
+    // `family` is NEUTRAL but not the last component, this is considered a
+    // BROKEN IPv4 address, as opposed to a non-IPv4 hostname.
+    if (family == CanonHostInfo::NEUTRAL && existing_components == 0)
+      return CanonHostInfo::NEUTRAL;
+
+    if (family != CanonHostInfo::IPV4)
+      return CanonHostInfo::BROKEN;
+
+    ++existing_components;
+
+    // If this is the final component, nothing else to do.
+    if (current_position == host.begin)
+      break;
+
+    // If there are more than 4 components, fail.
+    if (existing_components == 4)
+      return CanonHostInfo::BROKEN;
+
+    current_component_end = current_position - 1;
+    --current_position;
   }
 
-  if (broken)
-    return CanonHostInfo::BROKEN;
-
-  // Use that sequence of numbers to fill out the 4-component IP address.
+  // Use `component_values` to fill out the 4-component IP address.
 
   // First, process all components but the last, while making sure each fits
   // within an 8-bit field.
-  for (int i = 0; i < existing_components - 1; i++) {
+  for (int i = existing_components - 1; i > 0; i--) {
     if (component_values[i] > std::numeric_limits<uint8_t>::max())
       return CanonHostInfo::BROKEN;
-    address[i] = static_cast<unsigned char>(component_values[i]);
+    address[existing_components - i - 1] =
+        static_cast<unsigned char>(component_values[i]);
   }
 
-  // Next, consume the last component to fill in the remaining bytes.
-  // Work around a gcc 4.9 bug. crbug.com/392872
-#if ((__GNUC__ == 4 && __GNUC_MINOR__ >= 9) || __GNUC__ > 4)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Warray-bounds"
-#endif
-  uint32_t last_value = component_values[existing_components - 1];
-#if ((__GNUC__ == 4 && __GNUC_MINOR__ >= 9) || __GNUC__ > 4)
-#pragma GCC diagnostic pop
-#endif
+  uint32_t last_value = component_values[0];
   for (int i = 3; i >= existing_components - 1; i--) {
     address[i] = static_cast<unsigned char>(last_value);
     last_value >>= 8;
@@ -595,105 +572,6 @@
   return true;
 }
 
-// Method to check if something looks like a number. Used instead of
-// IPv4ComponentToNumber() so that it counts things that look like bad base-8
-// (e.g. 09).
-//
-// TODO(https://crbug.com/1149194): Remove this once the bug is fixed.
-template <typename CHAR>
-bool LooksLikeANumber(const CHAR* spec, const Component& component) {
-  // Empty components don't look like numbers.
-  if (!component.is_nonempty())
-    return false;
-
-  SharedCharTypes base = CHAR_DEC;
-  size_t start = component.begin;
-  if (component.len >= 2 && spec[start] == '0' &&
-      (spec[start + 1] == 'x' || spec[start + 1] == 'X')) {
-    base = CHAR_HEX;
-    start += 2;
-  }
-  for (int i = start; i < component.end(); i++) {
-    if (!IsCharOfType(spec[i], base))
-      return false;
-  }
-  return true;
-}
-
-// Calculates the "HostSafetyStatus" of the provided hostname.
-//
-// TODO(https://crbug.com/1149194): Remove this once the bug is fixed.
-template <typename CHAR>
-HostSafetyStatus DoCheckHostnameSafety(const CHAR* spec,
-                                       const Component& host) {
-  if (!host.is_nonempty())
-    return HostSafetyStatus::kOk;
-
-  // Find the last two components.
-
-  // Number of identified components. Stops after second component. Does not
-  // include the empty terminal component, if the host ends with a dot.
-  int existing_components = 0;
-  // Parsed component values. Populated last component first.
-  Component components[2];
-
-  // Index of the character after the end of the current component.
-  int cur_component_end = host.end();
-
-  // Ignore terminal dot, if there is one.
-  if (spec[cur_component_end - 1] == '.') {
-    cur_component_end--;
-    // Nothing else to do if the host is just a dot.
-    if (host.begin == cur_component_end)
-      return HostSafetyStatus::kOk;
-  }
-
-  for (int i = cur_component_end; /* nothing */; i--) {
-    GURL_DCHECK_GE(i, host.begin);
-
-    // If `i` is not the first character of the component, continue.
-    if (i != host.begin && spec[i - 1] != '.')
-      continue;
-
-    // Otherwise, i is the index of the the start of a component.
-    components[existing_components] = Component(i, cur_component_end - i);
-    existing_components++;
-
-    // Finished parsing last component.
-    if (i == host.begin)
-      break;
-
-    // If there's anything left to parse after the 2th component, nothing more
-    // to do.
-    if (existing_components == 2)
-      break;
-
-    // The next component ends before the dot at spec[i]. `i` will be
-    // decremented when restarting the loop, so no need to modify it.
-    cur_component_end = i - 1;
-  }
-
-  // If the last value doesn't look like a number, no need to do more work, as
-  // IPv6 and hostnames with non-numeric final components are all considered OK.
-  if (!LooksLikeANumber(spec, components[0]))
-    return HostSafetyStatus::kOk;
-
-  url::RawCanonOutputT<char> ignored_output;
-  CanonHostInfo host_info;
-  CanonicalizeIPAddress(spec, host, &ignored_output, &host_info);
-  // Ignore valid IPv4 addresses, and hostnames considered invalid by the IPv4
-  // and IPv6 parsers. The IPv6 check doesn't provide a whole lot, but does mean
-  // things like "].6" will correctly be considered already invalid, so will
-  // return kOk.
-  if (host_info.family != CanonHostInfo::NEUTRAL)
-    return HostSafetyStatus::kOk;
-
-  if (LooksLikeANumber(spec, components[1]))
-    return HostSafetyStatus::kTwoHighestLevelDomainsAreNumeric;
-
-  return HostSafetyStatus::kTopLevelDomainIsNumeric;
-}
-
 }  // namespace
 
 void AppendIPv4Address(const unsigned char address[4], CanonOutput* output) {
@@ -745,18 +623,6 @@
   }
 }
 
-bool FindIPv4Components(const char* spec,
-                        const Component& host,
-                        Component components[4]) {
-  return DoFindIPv4Components<char, unsigned char>(spec, host, components);
-}
-
-bool FindIPv4Components(const char16_t* spec,
-                        const Component& host,
-                        Component components[4]) {
-  return DoFindIPv4Components<char16_t, char16_t>(spec, host, components);
-}
-
 void CanonicalizeIPAddress(const char* spec,
                            const Component& host,
                            CanonOutput* output,
@@ -785,15 +651,16 @@
                                           const Component& host,
                                           unsigned char address[4],
                                           int* num_ipv4_components) {
-  return DoIPv4AddressToNumber<char>(spec, host, address, num_ipv4_components);
+  return DoIPv4AddressToNumber<char, unsigned char>(spec, host, address,
+                                                    num_ipv4_components);
 }
 
 CanonHostInfo::Family IPv4AddressToNumber(const char16_t* spec,
                                           const Component& host,
                                           unsigned char address[4],
                                           int* num_ipv4_components) {
-  return DoIPv4AddressToNumber<char16_t>(spec, host, address,
-                                         num_ipv4_components);
+  return DoIPv4AddressToNumber<char16_t, char16_t>(spec, host, address,
+                                                   num_ipv4_components);
 }
 
 bool IPv6AddressToNumber(const char* spec,
@@ -808,13 +675,4 @@
   return DoIPv6AddressToNumber<char16_t, char16_t>(spec, host, address);
 }
 
-HostSafetyStatus CheckHostnameSafety(const char* spec, const Component& host) {
-  return DoCheckHostnameSafety(spec, host);
-}
-
-HostSafetyStatus CheckHostnameSafety(const char16_t* spec,
-                                     const Component& host) {
-  return DoCheckHostnameSafety(spec, host);
-}
-
 }  // namespace url
diff --git a/url/url_canon_ip.h b/url/url_canon_ip.h
index 8980dbb..4e85466 100644
--- a/url/url_canon_ip.h
+++ b/url/url_canon_ip.h
@@ -6,7 +6,6 @@
 #define URL_URL_CANON_IP_H_
 
 #include "polyfills/base/component_export.h"
-#include "base/strings/string_piece_forward.h"
 #include "url/third_party/mozilla/url_parse.h"
 #include "url/url_canon.h"
 
@@ -20,33 +19,6 @@
 COMPONENT_EXPORT(URL)
 void AppendIPv6Address(const unsigned char address[16], CanonOutput* output);
 
-// Searches the host name for the portions of the IPv4 address. On success,
-// each component will be placed into |components| and it will return true.
-// It will return false if the host can not be separated as an IPv4 address
-// or if there are any non-7-bit characters or other characters that can not
-// be in an IP address. (This is important so we fail as early as possible for
-// common non-IP hostnames.)
-//
-// Not all components may exist. If there are only 3 components, for example,
-// the last one will have a length of -1 or 0 to indicate it does not exist.
-//
-// Note that many platforms' inet_addr will ignore everything after a space
-// in certain circumstances if the stuff before the space looks like an IP
-// address. IE6 is included in this. We do NOT handle this case. In many cases,
-// the browser's canonicalization will get run before this which converts
-// spaces to %20 (in the case of IE7) or rejects them (in the case of Mozilla),
-// so this code path never gets hit. Our host canonicalization will notice
-// these spaces and escape them, which will make IP address finding fail. This
-// seems like better behavior than stripping after a space.
-COMPONENT_EXPORT(URL)
-bool FindIPv4Components(const char* spec,
-                        const Component& host,
-                        Component components[4]);
-COMPONENT_EXPORT(URL)
-bool FindIPv4Components(const char16_t* spec,
-                        const Component& host,
-                        Component components[4]);
-
 // Converts an IPv4 address to a 32-bit number (network byte order).
 //
 // Possible return values:
@@ -83,48 +55,6 @@
                          const Component& host,
                          unsigned char address[16]);
 
-// Temporary enum for collecting histograms at the DNS and URL level about
-// hostname validity, for potentially updating the URL spec.
-//
-// This is used in histograms, so old values should not be reused, and new
-// values should be added at the bottom.
-//
-// TODO(https://crbug.com/1149194): Remove this once the bug is fixed.
-enum class HostSafetyStatus {
-  // Any canonical hostname that doesn't fit into any other class. IPv4
-  // hostnames, hostnames that don't have numeric eTLDs, etc. Hostnames that are
-  // broken are also considered OK.
-  kOk = 0,
-
-  // The top level domain looks numeric. This is basically means it either
-  // parses as a number per the URL spec, or is entirely numeric ("09" doesn't
-  // currently parse as a number, since the leading "0" indicates an octal
-  // value).
-  kTopLevelDomainIsNumeric = 1,
-
-  // Both the top level domain and the next level domain look like a number,
-  // using the above definition. This is the case that is actually concerning -
-  // for these domains, the eTLD+1 is purely numeric, which means putting it as
-  // the hostname of a URL will potentially result in an IPv4 hostname. This is
-  // logically a subset of kTopLevelDomainIsNumeric, but when both apply, this
-  // label will be returned instead.
-  kTwoHighestLevelDomainsAreNumeric = 2,
-
-  kMaxValue = kTwoHighestLevelDomainsAreNumeric,
-};
-
-// Calculates the HostSafetyStatus of a hostname. Hostname should have been
-// canonicalized. This function is only intended to be temporary, to inform
-// decisions around tightening up what the URL parser considers valid hostnames.
-//
-// TODO(https://crbug.com/1149194): Remove this once the bug is fixed.
-COMPONENT_EXPORT(URL)
-HostSafetyStatus CheckHostnameSafety(const char* hostname,
-                                     const Component& host);
-COMPONENT_EXPORT(URL)
-HostSafetyStatus CheckHostnameSafety(const char16_t* hostname,
-                                     const Component& host);
-
 }  // namespace url
 
 #endif  // URL_URL_CANON_IP_H_
diff --git a/url/url_canon_pathurl.cc b/url/url_canon_pathurl.cc
index 134e132..e726cfb 100644
--- a/url/url_canon_pathurl.cc
+++ b/url/url_canon_pathurl.cc
@@ -63,14 +63,17 @@
   new_parsed->host.reset();
   new_parsed->port.reset();
 
-  // Canonicalize path and query via the weaker path URL rules.
+  // Canonicalize path via the weaker path URL rules.
   //
   // Note: parsing the path part should never cause a failure, see
   // https://url.spec.whatwg.org/#cannot-be-a-base-url-path-state
   DoCanonicalizePathComponent<CHAR, UCHAR>(source.path, parsed.path, '\0',
                                            output, &new_parsed->path);
-  DoCanonicalizePathComponent<CHAR, UCHAR>(source.query, parsed.query, '?',
-                                           output, &new_parsed->query);
+
+  // Similar to mailto:, always use the default UTF-8 charset converter for
+  // query.
+  CanonicalizeQuery(source.query, parsed.query, nullptr, output,
+                    &new_parsed->query);
 
   CanonicalizeRef(source.ref, parsed.ref, output, &new_parsed->ref);
 
diff --git a/url/url_canon_unittest.cc b/url/url_canon_unittest.cc
index a59c745..aa2a8ce 100644
--- a/url/url_canon_unittest.cc
+++ b/url/url_canon_unittest.cc
@@ -5,14 +5,13 @@
 #include <errno.h>
 #include <stddef.h>
 
-#include "base/stl_util.h"
+#include "base/cxx17_backports.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_ip.h"
 #include "url/url_canon_stdstring.h"
 #include "url/url_test_utils.h"
 
@@ -609,21 +608,36 @@
 }
 
 TEST(URLCanonTest, IPv4) {
+  // clang-format off
   IPAddressCase cases[] = {
-      // Empty is not an IP address.
+    // Empty is not an IP address.
     {"", L"", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
     {".", L".", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
-      // Regular IP addresses in different bases.
+    // Regular IP addresses in different bases.
     {"192.168.0.1", L"192.168.0.1", "192.168.0.1", Component(0, 11), CanonHostInfo::IPV4, 4, "C0A80001"},
     {"0300.0250.00.01", L"0300.0250.00.01", "192.168.0.1", Component(0, 11), CanonHostInfo::IPV4, 4, "C0A80001"},
     {"0xC0.0Xa8.0x0.0x1", L"0xC0.0Xa8.0x0.0x1", "192.168.0.1", Component(0, 11), CanonHostInfo::IPV4, 4, "C0A80001"},
-      // Non-IP addresses due to invalid characters.
+    // Non-IP addresses due to invalid characters.
     {"192.168.9.com", L"192.168.9.com", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
-      // Invalid characters for the base should be rejected.
-    {"19a.168.0.1", L"19a.168.0.1", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
-    {"0308.0250.00.01", L"0308.0250.00.01", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
-    {"0xCG.0xA8.0x0.0x1", L"0xCG.0xA8.0x0.0x1", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
-      // If there are not enough components, the last one should fill them out.
+    // Hostnames with a numeric final component but other components that don't
+    // parse as numbers should be considered broken.
+    {"19a.168.0.1", L"19a.168.0.1", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    {"19a.168.0.1.", L"19a.168.0.1.", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    {"0308.0250.00.01", L"0308.0250.00.01", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    {"0308.0250.00.01.", L"0308.0250.00.01.", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    {"0xCG.0xA8.0x0.0x1", L"0xCG.0xA8.0x0.0x1", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    {"0xCG.0xA8.0x0.0x1.", L"0xCG.0xA8.0x0.0x1.", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    // Non-numeric terminal compeonent should be considered not IPv4 hostnames, but valid.
+    {"19.168.0.1a", L"19.168.0.1a", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
+    {"0xC.0xA8.0x0.0x1G", L"0xC.0xA8.0x0.0x1G", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
+    // Hostnames that would be considered broken IPv4 hostnames should be considered valid non-IPv4 hostnames if they end with two dots instead of 0 or 1.
+    {"19a.168.0.1..", L"19a.168.0.1..", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
+    {"0308.0250.00.01..", L"0308.0250.00.01..", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
+    {"0xCG.0xA8.0x0.0x1..", L"0xCG.0xA8.0x0.0x1..", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
+    // Hosts with components that aren't considered valid IPv4 numbers but are entirely numeric should be considered invalid.
+    {"1.2.3.08", L"1.2.3.08", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    {"1.2.3.08.", L"1.2.3.08.", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    // If there are not enough components, the last one should fill them out.
     {"192", L"192", "0.0.0.192", Component(0, 9), CanonHostInfo::IPV4, 1, "000000C0"},
     {"0xC0a80001", L"0xC0a80001", "192.168.0.1", Component(0, 11), CanonHostInfo::IPV4, 1, "C0A80001"},
     {"030052000001", L"030052000001", "192.168.0.1", Component(0, 11), CanonHostInfo::IPV4, 1, "C0A80001"},
@@ -632,15 +646,16 @@
     {"192.0x00A80001", L"192.0x000A80001", "192.168.0.1", Component(0, 11), CanonHostInfo::IPV4, 2, "C0A80001"},
     {"0xc0.052000001", L"0xc0.052000001", "192.168.0.1", Component(0, 11), CanonHostInfo::IPV4, 2, "C0A80001"},
     {"192.168.1", L"192.168.1", "192.168.0.1", Component(0, 11), CanonHostInfo::IPV4, 3, "C0A80001"},
-      // Too many components means not an IP address.
-    {"192.168.0.0.1", L"192.168.0.0.1", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
-      // We allow a single trailing dot.
+    // Hostnames with too many components, but a numeric final numeric component are invalid.
+    {"192.168.0.0.1", L"192.168.0.0.1", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    // We allow a single trailing dot.
     {"192.168.0.1.", L"192.168.0.1.", "192.168.0.1", Component(0, 11), CanonHostInfo::IPV4, 4, "C0A80001"},
     {"192.168.0.1. hello", L"192.168.0.1. hello", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
     {"192.168.0.1..", L"192.168.0.1..", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
-      // Two dots in a row means not an IP address.
-    {"192.168..1", L"192.168..1", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
-      // Any numerical overflow should be marked as BROKEN.
+    // Hosts with two dots in a row with a final numeric component are considered invalid.
+    {"192.168..1", L"192.168..1", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    {"192.168..1.", L"192.168..1.", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    // Any numerical overflow should be marked as BROKEN.
     {"0x100.0", L"0x100.0", "", Component(), CanonHostInfo::BROKEN, -1, ""},
     {"0x100.0.0", L"0x100.0.0", "", Component(), CanonHostInfo::BROKEN, -1, ""},
     {"0x100.0.0.0", L"0x100.0.0.0", "", Component(), CanonHostInfo::BROKEN, -1, ""},
@@ -650,7 +665,7 @@
     {"0.0.0x10000", L"0.0.0x10000", "", Component(), CanonHostInfo::BROKEN, -1, ""},
     {"0.0x1000000", L"0.0x1000000", "", Component(), CanonHostInfo::BROKEN, -1, ""},
     {"0x100000000", L"0x100000000", "", Component(), CanonHostInfo::BROKEN, -1, ""},
-      // Repeat the previous tests, minus 1, to verify boundaries.
+    // Repeat the previous tests, minus 1, to verify boundaries.
     {"0xFF.0", L"0xFF.0", "255.0.0.0", Component(0, 9), CanonHostInfo::IPV4, 2, "FF000000"},
     {"0xFF.0.0", L"0xFF.0.0", "255.0.0.0", Component(0, 9), CanonHostInfo::IPV4, 3, "FF000000"},
     {"0xFF.0.0.0", L"0xFF.0.0.0", "255.0.0.0", Component(0, 9), CanonHostInfo::IPV4, 4, "FF000000"},
@@ -660,52 +675,69 @@
     {"0.0.0xFFFF", L"0.0.0xFFFF", "0.0.255.255", Component(0, 11), CanonHostInfo::IPV4, 3, "0000FFFF"},
     {"0.0xFFFFFF", L"0.0xFFFFFF", "0.255.255.255", Component(0, 13), CanonHostInfo::IPV4, 2, "00FFFFFF"},
     {"0xFFFFFFFF", L"0xFFFFFFFF", "255.255.255.255", Component(0, 15), CanonHostInfo::IPV4, 1, "FFFFFFFF"},
-      // Old trunctations tests. They're all "BROKEN" now.
+    // Old trunctations tests. They're all "BROKEN" now.
     {"276.256.0xf1a2.077777", L"276.256.0xf1a2.077777", "", Component(), CanonHostInfo::BROKEN, -1, ""},
     {"192.168.0.257", L"192.168.0.257", "", Component(), CanonHostInfo::BROKEN, -1, ""},
     {"192.168.0xa20001", L"192.168.0xa20001", "", Component(), CanonHostInfo::BROKEN, -1, ""},
     {"192.015052000001", L"192.015052000001", "", Component(), CanonHostInfo::BROKEN, -1, ""},
     {"0X12C0a80001", L"0X12C0a80001", "", Component(), CanonHostInfo::BROKEN, -1, ""},
     {"276.1.2", L"276.1.2", "", Component(), CanonHostInfo::BROKEN, -1, ""},
-      // Spaces should be rejected.
+    // Too many components should be rejected, in valid ranges or not.
+    {"255.255.255.255.255", L"255.255.255.255.255", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    {"256.256.256.256.256", L"256.256.256.256.256", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    // Spaces should be rejected.
     {"192.168.0.1 hello", L"192.168.0.1 hello", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
-      // Very large numbers.
+    // Very large numbers.
     {"0000000000000300.0x00000000000000fF.00000000000000001", L"0000000000000300.0x00000000000000fF.00000000000000001", "192.255.0.1", Component(0, 11), CanonHostInfo::IPV4, 3, "C0FF0001"},
     {"0000000000000300.0xffffffffFFFFFFFF.3022415481470977", L"0000000000000300.0xffffffffFFFFFFFF.3022415481470977", "", Component(0, 11), CanonHostInfo::BROKEN, -1, ""},
-      // A number has no length limit, but long numbers can still overflow.
+    // A number has no length limit, but long numbers can still overflow.
     {"00000000000000000001", L"00000000000000000001", "0.0.0.1", Component(0, 7), CanonHostInfo::IPV4, 1, "00000001"},
     {"0000000000000000100000000000000001", L"0000000000000000100000000000000001", "", Component(), CanonHostInfo::BROKEN, -1, ""},
-      // If a long component is non-numeric, it's a hostname, *not* a broken IP.
+    // If a long component is non-numeric, it's a hostname, *not* a broken IP.
     {"0.0.0.000000000000000000z", L"0.0.0.000000000000000000z", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
     {"0.0.0.100000000000000000z", L"0.0.0.100000000000000000z", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
-      // Truncation of all zeros should still result in 0.
+    // Truncation of all zeros should still result in 0.
     {"0.00.0x.0x0", L"0.00.0x.0x0", "0.0.0.0", Component(0, 7), CanonHostInfo::IPV4, 4, "00000000"},
+    // Non-ASCII characters in final component should return NEUTRAL.
+    {"1.2.3.\xF0\x9F\x92\xA9", L"1.2.3.\xD83D\xDCA9", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
+    {"1.2.3.4\xF0\x9F\x92\xA9", L"1.2.3.4\xD83D\xDCA9", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
+    {"1.2.3.0x\xF0\x9F\x92\xA9", L"1.2.3.0x\xD83D\xDCA9", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
+    {"1.2.3.0\xF0\x9F\x92\xA9", L"1.2.3.0\xD83D\xDCA9", "", Component(), CanonHostInfo::NEUTRAL, -1, ""},
+    // Non-ASCII characters in other components should result in broken IPs when final component is numeric.
+    {"1.2.\xF0\x9F\x92\xA9.4", L"1.2.\xD83D\xDCA9.4", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    {"1.2.3\xF0\x9F\x92\xA9.4", L"1.2.3\xD83D\xDCA9.4", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    {"1.2.0x\xF0\x9F\x92\xA9.4", L"1.2.0x\xD83D\xDCA9.4", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    {"1.2.0\xF0\x9F\x92\xA9.4", L"1.2.0\xD83D\xDCA9.4", "", Component(), CanonHostInfo::BROKEN, -1, ""},
+    {"\xF0\x9F\x92\xA9.2.3.4", L"\xD83D\xDCA9.2.3.4", "", Component(), CanonHostInfo::BROKEN, -1, ""},
   };
+  // clang-format on
 
-  for (size_t i = 0; i < gurl_base::size(cases); i++) {
+  for (const auto& test_case : cases) {
+    SCOPED_TRACE(test_case.input8);
+
     // 8-bit version.
-    Component component(0, static_cast<int>(strlen(cases[i].input8)));
+    Component component(0, static_cast<int>(strlen(test_case.input8)));
 
     std::string out_str1;
     StdStringCanonOutput output1(&out_str1);
     CanonHostInfo host_info;
-    CanonicalizeIPAddress(cases[i].input8, component, &output1, &host_info);
+    CanonicalizeIPAddress(test_case.input8, component, &output1, &host_info);
     output1.Complete();
 
-    EXPECT_EQ(cases[i].expected_family, host_info.family);
-    EXPECT_EQ(std::string(cases[i].expected_address_hex),
+    EXPECT_EQ(test_case.expected_family, host_info.family);
+    EXPECT_EQ(std::string(test_case.expected_address_hex),
               BytesToHexString(host_info.address, host_info.AddressLength()));
     if (host_info.family == CanonHostInfo::IPV4) {
-      EXPECT_STREQ(cases[i].expected, out_str1.c_str());
-      EXPECT_EQ(cases[i].expected_component.begin, host_info.out_host.begin);
-      EXPECT_EQ(cases[i].expected_component.len, host_info.out_host.len);
-      EXPECT_EQ(cases[i].expected_num_ipv4_components,
+      EXPECT_STREQ(test_case.expected, out_str1.c_str());
+      EXPECT_EQ(test_case.expected_component.begin, host_info.out_host.begin);
+      EXPECT_EQ(test_case.expected_component.len, host_info.out_host.len);
+      EXPECT_EQ(test_case.expected_num_ipv4_components,
                 host_info.num_ipv4_components);
     }
 
     // 16-bit version.
     std::u16string input16(
-        test_utils::TruncateWStringToUTF16(cases[i].input16));
+        test_utils::TruncateWStringToUTF16(test_case.input16));
     component = Component(0, static_cast<int>(input16.length()));
 
     std::string out_str2;
@@ -713,14 +745,14 @@
     CanonicalizeIPAddress(input16.c_str(), component, &output2, &host_info);
     output2.Complete();
 
-    EXPECT_EQ(cases[i].expected_family, host_info.family);
-    EXPECT_EQ(std::string(cases[i].expected_address_hex),
+    EXPECT_EQ(test_case.expected_family, host_info.family);
+    EXPECT_EQ(std::string(test_case.expected_address_hex),
               BytesToHexString(host_info.address, host_info.AddressLength()));
     if (host_info.family == CanonHostInfo::IPV4) {
-      EXPECT_STREQ(cases[i].expected, out_str2.c_str());
-      EXPECT_EQ(cases[i].expected_component.begin, host_info.out_host.begin);
-      EXPECT_EQ(cases[i].expected_component.len, host_info.out_host.len);
-      EXPECT_EQ(cases[i].expected_num_ipv4_components,
+      EXPECT_STREQ(test_case.expected, out_str2.c_str());
+      EXPECT_EQ(test_case.expected_component.begin, host_info.out_host.begin);
+      EXPECT_EQ(test_case.expected_component.len, host_info.out_host.len);
+      EXPECT_EQ(test_case.expected_num_ipv4_components,
                 host_info.num_ipv4_components);
     }
   }
@@ -2529,115 +2561,4 @@
   output.set_length(0);
 }
 
-TEST(URLCanonTest, URLSafetyStatus) {
-  const struct {
-    const char* host;
-    HostSafetyStatus expected_safety_status;
-  } kTestCases[] = {
-      // Empty components are ok.
-      {"", HostSafetyStatus::kOk},
-      {".", HostSafetyStatus::kOk},
-      {"..", HostSafetyStatus::kOk},
-
-      // Hostnames with purely non-numeric components are ok.
-      {"com", HostSafetyStatus::kOk},
-      {"a.com", HostSafetyStatus::kOk},
-      {"a.b.com", HostSafetyStatus::kOk},
-
-      // Hostnames with components with letters and numbers are ok.
-      {"1com", HostSafetyStatus::kOk},
-      {"0a.0com", HostSafetyStatus::kOk},
-      {"0xa.0xb.0xcom", HostSafetyStatus::kOk},
-      {"com1", HostSafetyStatus::kOk},
-      {"a1.com1", HostSafetyStatus::kOk},
-      {"a1.b1.com1", HostSafetyStatus::kOk},
-
-      // Hostnames components that are numbers that are before a final
-      // non-numeric component are ok.
-      {"1.com", HostSafetyStatus::kOk},
-      {"0.1.2com", HostSafetyStatus::kOk},
-
-      // Invalid hostnames are ok.
-      {"[", HostSafetyStatus::kOk},
-
-      // IPv6 hostnames are ok.
-      {"[::]", HostSafetyStatus::kOk},
-      {"[2001:db8::1]", HostSafetyStatus::kOk},
-
-      // IPv4 hostnames are ok.
-      {"1.2.3.4", HostSafetyStatus::kOk},
-      // IPv4 hostnames with creative representations are ok.
-      {"01.02.03.04", HostSafetyStatus::kOk},
-      {"0x1.0x2.0x3.0x4", HostSafetyStatus::kOk},
-      {"1.2", HostSafetyStatus::kOk},
-      {"1.2.3", HostSafetyStatus::kOk},
-      {"0", HostSafetyStatus::kOk},
-      {"0x0", HostSafetyStatus::kOk},
-      {"07", HostSafetyStatus::kOk},
-
-      // Hostnames with a final problematic top level domain.
-      {"a.0", HostSafetyStatus::kTopLevelDomainIsNumeric},
-      {"a.123", HostSafetyStatus::kTopLevelDomainIsNumeric},
-      {"a.123456", HostSafetyStatus::kTopLevelDomainIsNumeric},
-      {"a.999999999999999999", HostSafetyStatus::kTopLevelDomainIsNumeric},
-      {"a.0x1", HostSafetyStatus::kTopLevelDomainIsNumeric},
-      {"a.0xabcdef", HostSafetyStatus::kTopLevelDomainIsNumeric},
-      {"a.0XABCDEF", HostSafetyStatus::kTopLevelDomainIsNumeric},
-      {"a.07", HostSafetyStatus::kTopLevelDomainIsNumeric},
-      {"a.09", HostSafetyStatus::kTopLevelDomainIsNumeric},
-      {".0", HostSafetyStatus::kTopLevelDomainIsNumeric},
-      {"foo.bar.0", HostSafetyStatus::kTopLevelDomainIsNumeric},
-      {"1.bar.0", HostSafetyStatus::kTopLevelDomainIsNumeric},
-      {"a..0", HostSafetyStatus::kTopLevelDomainIsNumeric},
-      {"1..0", HostSafetyStatus::kTopLevelDomainIsNumeric},
-
-      // Hostnames with problematic two highest level domains.
-      {"a.1.2", HostSafetyStatus::kTwoHighestLevelDomainsAreNumeric},
-      {"a.0x1.0x2f", HostSafetyStatus::kTwoHighestLevelDomainsAreNumeric},
-      {"a.06.09", HostSafetyStatus::kTwoHighestLevelDomainsAreNumeric},
-  };
-
-  for (const auto& test_case : kTestCases) {
-    // Test with ASCII.
-    SCOPED_TRACE(test_case.host);
-    EXPECT_EQ(test_case.expected_safety_status,
-              CheckHostnameSafety(test_case.host,
-                                  Component(0, strlen(test_case.host))));
-
-    // Test with ASCII and terminal dot, which shouldn't affect results for
-    // anything that doesn't already end in a dot (or anything that only has
-    // dots).
-    std::string host_with_dot = test_case.host;
-    host_with_dot += ".";
-    EXPECT_EQ(test_case.expected_safety_status,
-              CheckHostnameSafety(host_with_dot.c_str(),
-                                  Component(0, host_with_dot.size())));
-
-    // Test with ASCII and characters that are not part of the component.
-    std::string host_with_bonus_characters = test_case.host;
-    host_with_bonus_characters = "00" + host_with_bonus_characters + "00";
-    EXPECT_EQ(test_case.expected_safety_status,
-              CheckHostnameSafety(host_with_bonus_characters.c_str(),
-                                  Component(2, strlen(test_case.host))));
-
-    // Test with UTF-16.
-    std::u16string utf16 = gurl_base::UTF8ToUTF16(test_case.host);
-    EXPECT_EQ(test_case.expected_safety_status,
-              CheckHostnameSafety(utf16.c_str(), Component(0, utf16.size())));
-
-    // Test with UTF-16 and terminal dot.
-    std::u16string utf16_with_dot = gurl_base::UTF8ToUTF16(host_with_dot);
-    EXPECT_EQ(test_case.expected_safety_status,
-              CheckHostnameSafety(utf16_with_dot.c_str(),
-                                  Component(0, utf16_with_dot.size())));
-
-    // Test with UTF-16 and characters that are not part of the component.
-    std::u16string utf16_with_bonus_characters =
-        gurl_base::UTF8ToUTF16(host_with_bonus_characters);
-    EXPECT_EQ(test_case.expected_safety_status,
-              CheckHostnameSafety(utf16_with_bonus_characters.c_str(),
-                                  Component(2, utf16.size())));
-  }
-}
-
 }  // namespace url
diff --git a/url/url_idna_icu.cc b/url/url_idna_icu.cc
index 4029d61..381d74e 100644
--- a/url/url_idna_icu.cc
+++ b/url/url_idna_icu.cc
@@ -11,7 +11,6 @@
 #include <ostream>
 
 #include "polyfills/base/check_op.h"
-#include "base/no_destructor.h"
 #include <unicode/uidna.h>
 #include <unicode/utypes.h>
 #include "url/url_canon_icu.h"
@@ -19,10 +18,8 @@
 
 namespace url {
 
-namespace {
-
-// A wrapper to use gurl_base::NoDestructor with ICU's UIDNA, a C pointer to
-// a UTS46/IDNA 2008 handling object opened with uidna_openUTS46().
+// Use UIDNA, a C pointer to a UTS46/IDNA 2008 handling object opened with
+// uidna_openUTS46().
 //
 // We use UTS46 with BiDiCheck to migrate from IDNA 2003 (with unassigned
 // code points allowed) to IDNA 2008 with
@@ -42,12 +39,12 @@
 // http://goo.gl/3XBhqw ).
 // See http://http://unicode.org/reports/tr46/ and references therein
 // for more details.
-struct UIDNAWrapper {
-  UIDNAWrapper() {
+UIDNA* GetUIDNA() {
+  static UIDNA* uidna = [] {
     UErrorCode err = U_ZERO_ERROR;
     // TODO(jungshik): Change options as different parties (browsers,
     // registrars, search engines) converge toward a consensus.
-    value = uidna_openUTS46(UIDNA_CHECK_BIDI, &err);
+    UIDNA* value = uidna_openUTS46(UIDNA_CHECK_BIDI, &err);
     if (U_FAILURE(err)) {
       GURL_CHECK(false) << "failed to open UTS46 data with error: "
                    << u_errorName(err)
@@ -56,16 +53,9 @@
                    << "tables for libicu. See https://crbug.com/778929.";
       value = nullptr;
     }
-  }
-
-  UIDNA* value;
-};
-
-}  // namespace
-
-UIDNA* GetUIDNA() {
-  static gurl_base::NoDestructor<UIDNAWrapper> uidna_wrapper;
-  return uidna_wrapper->value;
+    return value;
+  }();
+  return uidna;
 }
 
 // Converts the Unicode input representing a hostname to ASCII using IDN rules.
diff --git a/url/url_parse_unittest.cc b/url/url_parse_unittest.cc
index b67b550..b23dcf8 100644
--- a/url/url_parse_unittest.cc
+++ b/url/url_parse_unittest.cc
@@ -6,7 +6,7 @@
 
 #include <stddef.h>
 
-#include "base/stl_util.h"
+#include "base/cxx17_backports.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/third_party/mozilla/url_parse.h"
 
@@ -491,7 +491,7 @@
   struct FileCase {
     const char* input;
     const char* expected;
-  } file_cases[] = {
+  } extract_cases[] = {
       {"http://www.google.com", nullptr},
       {"http://www.google.com/", ""},
       {"http://www.google.com/search", "search"},
@@ -509,8 +509,8 @@
       {"http://www.google.com/foo;bar;html", "foo"},
   };
 
-  for (size_t i = 0; i < gurl_base::size(file_cases); i++) {
-    const char* url = file_cases[i].input;
+  for (size_t i = 0; i < gurl_base::size(extract_cases); i++) {
+    const char* url = extract_cases[i].input;
     int len = static_cast<int>(strlen(url));
 
     Parsed parsed;
@@ -519,7 +519,7 @@
     Component file_name;
     ExtractFileName(url, parsed.path, &file_name);
 
-    EXPECT_TRUE(ComponentMatches(url, file_cases[i].expected, file_name));
+    EXPECT_TRUE(ComponentMatches(url, extract_cases[i].expected, file_name));
   }
 }
 
diff --git a/url/url_util.cc b/url/url_util.cc
index 0c35913..470da30 100644
--- a/url/url_util.cc
+++ b/url/url_util.cc
@@ -6,7 +6,9 @@
 
 #include <stddef.h>
 #include <string.h>
+
 #include <atomic>
+#include <ostream>
 
 #include "polyfills/base/check_op.h"
 #include "base/compiler_specific.h"
diff --git a/url/url_util_unittest.cc b/url/url_util_unittest.cc
index 3dcfa76..158e3d6 100644
--- a/url/url_util_unittest.cc
+++ b/url/url_util_unittest.cc
@@ -4,7 +4,7 @@
 
 #include <stddef.h>
 
-#include "base/stl_util.h"
+#include "base/cxx17_backports.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/third_party/mozilla/url_parse.h"
 #include "url/url_canon.h"