diff --git a/base/files/file_path.cc b/base/files/file_path.cc
index f0e1acb..3ecb009 100644
--- a/base/files/file_path.cc
+++ b/base/files/file_path.cc
@@ -171,7 +171,7 @@
 FilePath::FilePath(FilePath&& that) noexcept = default;
 
 FilePath::FilePath(StringPieceType path) {
-  path.CopyToString(&path_);
+  path_.assign(path);
   StringType::size_type nul_pos = path_.find(kStringTerminator);
   if (nul_pos != StringType::npos)
     path_.erase(nul_pos, StringType::npos);
@@ -401,7 +401,7 @@
 
   StringType ext = Extension();
   StringType ret = RemoveExtension().value();
-  suffix.AppendToString(&ret);
+  ret.append(suffix);
   ret.append(ext);
   return FilePath(ret);
 }
@@ -429,7 +429,7 @@
       *(str.end() - 1) != kExtensionSeparator) {
     str.append(1, kExtensionSeparator);
   }
-  extension.AppendToString(&str);
+  str.append(extension);
   return FilePath(str);
 }
 
@@ -446,7 +446,7 @@
   StringType str = no_ext.value();
   if (extension[0] != kExtensionSeparator)
     str.append(1, kExtensionSeparator);
-  extension.AppendToString(&str);
+  str.append(extension);
   return FilePath(str);
 }
 
@@ -456,7 +456,7 @@
 
   StringType::size_type nul_pos = component.find(kStringTerminator);
   if (nul_pos != StringPieceType::npos) {
-    component.substr(0, nul_pos).CopyToString(&without_nuls);
+    without_nuls.assign(component.substr(0, nul_pos));
     appended = StringPieceType(without_nuls);
   }
 
@@ -490,7 +490,7 @@
     }
   }
 
-  appended.AppendToString(&new_path.path_);
+  new_path.path_.append(appended);
   return new_path;
 }
 
diff --git a/base/files/file_path.h b/base/files/file_path.h
index a85c1aa..a8322c4 100644
--- a/base/files/file_path.h
+++ b/base/files/file_path.h
@@ -152,8 +152,8 @@
   typedef std::string StringType;
 #endif  // OS_WIN
 
-  typedef BasicStringPiece<StringType> StringPieceType;
-  typedef StringType::value_type CharType;
+  using CharType = StringType::value_type;
+  using StringPieceType = std::basic_string_view<CharType>;
 
   // Null-terminated array of separators used to separate components in
   // hierarchical paths.  Each character in this array is a valid separator,
diff --git a/base/files/file_util_posix.cc b/base/files/file_util_posix.cc
index 966abc0..0749ac9 100644
--- a/base/files/file_util_posix.cc
+++ b/base/files/file_util_posix.cc
@@ -184,7 +184,7 @@
 // https://www.gnu.org/software/libc/manual/html_node/Opening-Streams.html for
 // details.
 std::string AppendModeCharacter(StringPiece mode, char mode_char) {
-  std::string result(mode.as_string());
+  std::string result(mode);
   size_t comma_pos = result.find(',');
   result.insert(comma_pos == std::string::npos ? result.length() : comma_pos, 1,
                 mode_char);
diff --git a/base/logging.h b/base/logging.h
index 95c96ed..cba1c55 100644
--- a/base/logging.h
+++ b/base/logging.h
@@ -17,7 +17,7 @@
 #include "base/callback_forward.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
-#include "base/strings/string_piece_forward.h"
+#include "base/strings/string_piece.h"
 #include "base/template_util.h"
 #include "util/build_config.h"
 
diff --git a/base/md5.cc b/base/md5.cc
index c66f7b2..0b50e56 100644
--- a/base/md5.cc
+++ b/base/md5.cc
@@ -24,6 +24,7 @@
 #include "base/md5.h"
 
 #include <stddef.h>
+#include <string.h>
 
 namespace {
 
diff --git a/base/md5.h b/base/md5.h
index 16a0a6f..802645c 100644
--- a/base/md5.h
+++ b/base/md5.h
@@ -8,6 +8,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <string>
+
 #include "base/strings/string_piece.h"
 
 namespace base {
diff --git a/base/strings/string_number_conversions.cc b/base/strings/string_number_conversions.cc
index 01375f5..5f94a56 100644
--- a/base/strings/string_number_conversions.cc
+++ b/base/strings/string_number_conversions.cc
@@ -112,9 +112,9 @@
 };
 
 template <>
-class WhitespaceHelper<char16> {
+class WhitespaceHelper<char16_t> {
  public:
-  static bool Invoke(char16 c) { return 0 != iswspace(c); }
+  static bool Invoke(char16_t c) { return 0 != iswspace(c); }
 };
 
 template <typename CHAR>
diff --git a/base/strings/string_piece.cc b/base/strings/string_piece.cc
deleted file mode 100644
index 612298a..0000000
--- a/base/strings/string_piece.cc
+++ /dev/null
@@ -1,440 +0,0 @@
-// Copyright (c) 2012 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.
-// Copied from strings/stringpiece.cc with modifications
-
-#include "base/strings/string_piece.h"
-
-#include <limits.h>
-
-#include <algorithm>
-#include <ostream>
-
-#include "base/logging.h"
-
-namespace base {
-namespace {
-
-// For each character in characters_wanted, sets the index corresponding
-// to the ASCII code of that character to 1 in table.  This is used by
-// the find_.*_of methods below to tell whether or not a character is in
-// the lookup table in constant time.
-// The argument `table' must be an array that is large enough to hold all
-// the possible values of an unsigned char.  Thus it should be be declared
-// as follows:
-//   bool table[UCHAR_MAX + 1]
-inline void BuildLookupTable(const StringPiece& characters_wanted,
-                             bool* table) {
-  const size_t length = characters_wanted.length();
-  const char* const data = characters_wanted.data();
-  for (size_t i = 0; i < length; ++i) {
-    table[static_cast<unsigned char>(data[i])] = true;
-  }
-}
-
-}  // namespace
-
-// MSVC doesn't like complex extern templates and DLLs.
-#if !defined(COMPILER_MSVC)
-template class BasicStringPiece<std::string>;
-template class BasicStringPiece<string16>;
-#endif
-
-bool operator==(const StringPiece& x, const StringPiece& y) {
-  if (x.size() != y.size())
-    return false;
-
-  return CharTraits<StringPiece::value_type>::compare(x.data(), y.data(),
-                                                      x.size()) == 0;
-}
-
-std::ostream& operator<<(std::ostream& o, const StringPiece& piece) {
-  o.write(piece.data(), static_cast<std::streamsize>(piece.size()));
-  return o;
-}
-
-namespace internal {
-
-template <typename STR>
-void CopyToStringT(const BasicStringPiece<STR>& self, STR* target) {
-  if (self.empty())
-    target->clear();
-  else
-    target->assign(self.data(), self.size());
-}
-
-void CopyToString(const StringPiece& self, std::string* target) {
-  CopyToStringT(self, target);
-}
-
-void CopyToString(const StringPiece16& self, string16* target) {
-  CopyToStringT(self, target);
-}
-
-template <typename STR>
-void AppendToStringT(const BasicStringPiece<STR>& self, STR* target) {
-  if (!self.empty())
-    target->append(self.data(), self.size());
-}
-
-void AppendToString(const StringPiece& self, std::string* target) {
-  AppendToStringT(self, target);
-}
-
-void AppendToString(const StringPiece16& self, string16* target) {
-  AppendToStringT(self, target);
-}
-
-template <typename STR>
-size_t copyT(const BasicStringPiece<STR>& self,
-             typename STR::value_type* buf,
-             size_t n,
-             size_t pos) {
-  size_t ret = std::min(self.size() - pos, n);
-  memcpy(buf, self.data() + pos, ret * sizeof(typename STR::value_type));
-  return ret;
-}
-
-size_t copy(const StringPiece& self, char* buf, size_t n, size_t pos) {
-  return copyT(self, buf, n, pos);
-}
-
-size_t copy(const StringPiece16& self, char16* buf, size_t n, size_t pos) {
-  return copyT(self, buf, n, pos);
-}
-
-template <typename STR>
-size_t findT(const BasicStringPiece<STR>& self,
-             const BasicStringPiece<STR>& s,
-             size_t pos) {
-  if (pos > self.size())
-    return BasicStringPiece<STR>::npos;
-
-  typename BasicStringPiece<STR>::const_iterator result =
-      std::search(self.begin() + pos, self.end(), s.begin(), s.end());
-  const size_t xpos = static_cast<size_t>(result - self.begin());
-  return xpos + s.size() <= self.size() ? xpos : BasicStringPiece<STR>::npos;
-}
-
-size_t find(const StringPiece& self, const StringPiece& s, size_t pos) {
-  return findT(self, s, pos);
-}
-
-size_t find(const StringPiece16& self, const StringPiece16& s, size_t pos) {
-  return findT(self, s, pos);
-}
-
-template <typename STR>
-size_t findT(const BasicStringPiece<STR>& self,
-             typename STR::value_type c,
-             size_t pos) {
-  if (pos >= self.size())
-    return BasicStringPiece<STR>::npos;
-
-  typename BasicStringPiece<STR>::const_iterator result =
-      std::find(self.begin() + pos, self.end(), c);
-  return result != self.end() ? static_cast<size_t>(result - self.begin())
-                              : BasicStringPiece<STR>::npos;
-}
-
-size_t find(const StringPiece& self, char c, size_t pos) {
-  return findT(self, c, pos);
-}
-
-size_t find(const StringPiece16& self, char16 c, size_t pos) {
-  return findT(self, c, pos);
-}
-
-template <typename STR>
-size_t rfindT(const BasicStringPiece<STR>& self,
-              const BasicStringPiece<STR>& s,
-              size_t pos) {
-  if (self.size() < s.size())
-    return BasicStringPiece<STR>::npos;
-
-  if (s.empty())
-    return std::min(self.size(), pos);
-
-  typename BasicStringPiece<STR>::const_iterator last =
-      self.begin() + std::min(self.size() - s.size(), pos) + s.size();
-  typename BasicStringPiece<STR>::const_iterator result =
-      std::find_end(self.begin(), last, s.begin(), s.end());
-  return result != last ? static_cast<size_t>(result - self.begin())
-                        : BasicStringPiece<STR>::npos;
-}
-
-size_t rfind(const StringPiece& self, const StringPiece& s, size_t pos) {
-  return rfindT(self, s, pos);
-}
-
-size_t rfind(const StringPiece16& self, const StringPiece16& s, size_t pos) {
-  return rfindT(self, s, pos);
-}
-
-template <typename STR>
-size_t rfindT(const BasicStringPiece<STR>& self,
-              typename STR::value_type c,
-              size_t pos) {
-  if (self.size() == 0)
-    return BasicStringPiece<STR>::npos;
-
-  for (size_t i = std::min(pos, self.size() - 1);; --i) {
-    if (self.data()[i] == c)
-      return i;
-    if (i == 0)
-      break;
-  }
-  return BasicStringPiece<STR>::npos;
-}
-
-size_t rfind(const StringPiece& self, char c, size_t pos) {
-  return rfindT(self, c, pos);
-}
-
-size_t rfind(const StringPiece16& self, char16 c, size_t pos) {
-  return rfindT(self, c, pos);
-}
-
-// 8-bit version using lookup table.
-size_t find_first_of(const StringPiece& self,
-                     const StringPiece& s,
-                     size_t pos) {
-  if (self.size() == 0 || s.size() == 0)
-    return StringPiece::npos;
-
-  // Avoid the cost of BuildLookupTable() for a single-character search.
-  if (s.size() == 1)
-    return find(self, s.data()[0], pos);
-
-  bool lookup[UCHAR_MAX + 1] = {false};
-  BuildLookupTable(s, lookup);
-  for (size_t i = pos; i < self.size(); ++i) {
-    if (lookup[static_cast<unsigned char>(self.data()[i])]) {
-      return i;
-    }
-  }
-  return StringPiece::npos;
-}
-
-// 16-bit brute force version.
-size_t find_first_of(const StringPiece16& self,
-                     const StringPiece16& s,
-                     size_t pos) {
-  StringPiece16::const_iterator found =
-      std::find_first_of(self.begin() + pos, self.end(), s.begin(), s.end());
-  if (found == self.end())
-    return StringPiece16::npos;
-  return found - self.begin();
-}
-
-// 8-bit version using lookup table.
-size_t find_first_not_of(const StringPiece& self,
-                         const StringPiece& s,
-                         size_t pos) {
-  if (self.size() == 0)
-    return StringPiece::npos;
-
-  if (s.size() == 0)
-    return 0;
-
-  // Avoid the cost of BuildLookupTable() for a single-character search.
-  if (s.size() == 1)
-    return find_first_not_of(self, s.data()[0], pos);
-
-  bool lookup[UCHAR_MAX + 1] = {false};
-  BuildLookupTable(s, lookup);
-  for (size_t i = pos; i < self.size(); ++i) {
-    if (!lookup[static_cast<unsigned char>(self.data()[i])]) {
-      return i;
-    }
-  }
-  return StringPiece::npos;
-}
-
-// 16-bit brute-force version.
-size_t find_first_not_of(const StringPiece16& self,
-                         const StringPiece16& s,
-                         size_t pos) {
-  if (self.size() == 0)
-    return StringPiece16::npos;
-
-  for (size_t self_i = pos; self_i < self.size(); ++self_i) {
-    bool found = false;
-    for (size_t s_i = 0; s_i < s.size(); ++s_i) {
-      if (self[self_i] == s[s_i]) {
-        found = true;
-        break;
-      }
-    }
-    if (!found)
-      return self_i;
-  }
-  return StringPiece16::npos;
-}
-
-template <typename STR>
-size_t find_first_not_ofT(const BasicStringPiece<STR>& self,
-                          typename STR::value_type c,
-                          size_t pos) {
-  if (self.size() == 0)
-    return BasicStringPiece<STR>::npos;
-
-  for (; pos < self.size(); ++pos) {
-    if (self.data()[pos] != c) {
-      return pos;
-    }
-  }
-  return BasicStringPiece<STR>::npos;
-}
-
-size_t find_first_not_of(const StringPiece& self, char c, size_t pos) {
-  return find_first_not_ofT(self, c, pos);
-}
-
-size_t find_first_not_of(const StringPiece16& self, char16 c, size_t pos) {
-  return find_first_not_ofT(self, c, pos);
-}
-
-// 8-bit version using lookup table.
-size_t find_last_of(const StringPiece& self, const StringPiece& s, size_t pos) {
-  if (self.size() == 0 || s.size() == 0)
-    return StringPiece::npos;
-
-  // Avoid the cost of BuildLookupTable() for a single-character search.
-  if (s.size() == 1)
-    return rfind(self, s.data()[0], pos);
-
-  bool lookup[UCHAR_MAX + 1] = {false};
-  BuildLookupTable(s, lookup);
-  for (size_t i = std::min(pos, self.size() - 1);; --i) {
-    if (lookup[static_cast<unsigned char>(self.data()[i])])
-      return i;
-    if (i == 0)
-      break;
-  }
-  return StringPiece::npos;
-}
-
-// 16-bit brute-force version.
-size_t find_last_of(const StringPiece16& self,
-                    const StringPiece16& s,
-                    size_t pos) {
-  if (self.size() == 0)
-    return StringPiece16::npos;
-
-  for (size_t self_i = std::min(pos, self.size() - 1);; --self_i) {
-    for (size_t s_i = 0; s_i < s.size(); s_i++) {
-      if (self.data()[self_i] == s[s_i])
-        return self_i;
-    }
-    if (self_i == 0)
-      break;
-  }
-  return StringPiece16::npos;
-}
-
-// 8-bit version using lookup table.
-size_t find_last_not_of(const StringPiece& self,
-                        const StringPiece& s,
-                        size_t pos) {
-  if (self.size() == 0)
-    return StringPiece::npos;
-
-  size_t i = std::min(pos, self.size() - 1);
-  if (s.size() == 0)
-    return i;
-
-  // Avoid the cost of BuildLookupTable() for a single-character search.
-  if (s.size() == 1)
-    return find_last_not_of(self, s.data()[0], pos);
-
-  bool lookup[UCHAR_MAX + 1] = {false};
-  BuildLookupTable(s, lookup);
-  for (;; --i) {
-    if (!lookup[static_cast<unsigned char>(self.data()[i])])
-      return i;
-    if (i == 0)
-      break;
-  }
-  return StringPiece::npos;
-}
-
-// 16-bit brute-force version.
-size_t find_last_not_of(const StringPiece16& self,
-                        const StringPiece16& s,
-                        size_t pos) {
-  if (self.size() == 0)
-    return StringPiece::npos;
-
-  for (size_t self_i = std::min(pos, self.size() - 1);; --self_i) {
-    bool found = false;
-    for (size_t s_i = 0; s_i < s.size(); s_i++) {
-      if (self.data()[self_i] == s[s_i]) {
-        found = true;
-        break;
-      }
-    }
-    if (!found)
-      return self_i;
-    if (self_i == 0)
-      break;
-  }
-  return StringPiece16::npos;
-}
-
-template <typename STR>
-size_t find_last_not_ofT(const BasicStringPiece<STR>& self,
-                         typename STR::value_type c,
-                         size_t pos) {
-  if (self.size() == 0)
-    return BasicStringPiece<STR>::npos;
-
-  for (size_t i = std::min(pos, self.size() - 1);; --i) {
-    if (self.data()[i] != c)
-      return i;
-    if (i == 0)
-      break;
-  }
-  return BasicStringPiece<STR>::npos;
-}
-
-size_t find_last_not_of(const StringPiece& self, char c, size_t pos) {
-  return find_last_not_ofT(self, c, pos);
-}
-
-size_t find_last_not_of(const StringPiece16& self, char16 c, size_t pos) {
-  return find_last_not_ofT(self, c, pos);
-}
-
-template <typename STR>
-BasicStringPiece<STR> substrT(const BasicStringPiece<STR>& self,
-                              size_t pos,
-                              size_t n) {
-  if (pos > self.size())
-    pos = self.size();
-  if (n > self.size() - pos)
-    n = self.size() - pos;
-  return BasicStringPiece<STR>(self.data() + pos, n);
-}
-
-StringPiece substr(const StringPiece& self, size_t pos, size_t n) {
-  return substrT(self, pos, n);
-}
-
-StringPiece16 substr(const StringPiece16& self, size_t pos, size_t n) {
-  return substrT(self, pos, n);
-}
-
-#if DCHECK_IS_ON()
-void AssertIteratorsInOrder(std::string::const_iterator begin,
-                            std::string::const_iterator end) {
-  DCHECK(begin <= end) << "StringPiece iterators swapped or invalid.";
-}
-void AssertIteratorsInOrder(string16::const_iterator begin,
-                            string16::const_iterator end) {
-  DCHECK(begin <= end) << "StringPiece iterators swapped or invalid.";
-}
-#endif
-
-}  // namespace internal
-}  // namespace base
diff --git a/base/strings/string_piece.h b/base/strings/string_piece.h
index 0722269..fa215ef 100644
--- a/base/strings/string_piece.h
+++ b/base/strings/string_piece.h
@@ -22,412 +22,15 @@
 #ifndef BASE_STRINGS_STRING_PIECE_H_
 #define BASE_STRINGS_STRING_PIECE_H_
 
-#include <stddef.h>
-
-#include <iosfwd>
-#include <string>
-
-#include "base/logging.h"
-#include "base/strings/char_traits.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece_forward.h"
+#include <string_view>
 
 namespace base {
 
-// internal --------------------------------------------------------------------
-
-// Many of the StringPiece functions use different implementations for the
-// 8-bit and 16-bit versions, and we don't want lots of template expansions in
-// this (very common) header that will slow down compilation.
-//
-// So here we define overloaded functions called by the StringPiece template.
-// For those that share an implementation, the two versions will expand to a
-// template internal to the .cc file.
-namespace internal {
-
-void CopyToString(const StringPiece& self, std::string* target);
-void CopyToString(const StringPiece16& self, string16* target);
-
-void AppendToString(const StringPiece& self, std::string* target);
-void AppendToString(const StringPiece16& self, string16* target);
-
-size_t copy(const StringPiece& self, char* buf, size_t n, size_t pos);
-size_t copy(const StringPiece16& self, char16* buf, size_t n, size_t pos);
-
-size_t find(const StringPiece& self, const StringPiece& s, size_t pos);
-size_t find(const StringPiece16& self, const StringPiece16& s, size_t pos);
-size_t find(const StringPiece& self, char c, size_t pos);
-size_t find(const StringPiece16& self, char16 c, size_t pos);
-
-size_t rfind(const StringPiece& self, const StringPiece& s, size_t pos);
-size_t rfind(const StringPiece16& self, const StringPiece16& s, size_t pos);
-size_t rfind(const StringPiece& self, char c, size_t pos);
-size_t rfind(const StringPiece16& self, char16 c, size_t pos);
-
-size_t find_first_of(const StringPiece& self, const StringPiece& s, size_t pos);
-size_t find_first_of(const StringPiece16& self,
-                     const StringPiece16& s,
-                     size_t pos);
-
-size_t find_first_not_of(const StringPiece& self,
-                         const StringPiece& s,
-                         size_t pos);
-size_t find_first_not_of(const StringPiece16& self,
-                         const StringPiece16& s,
-                         size_t pos);
-size_t find_first_not_of(const StringPiece& self, char c, size_t pos);
-size_t find_first_not_of(const StringPiece16& self, char16 c, size_t pos);
-
-size_t find_last_of(const StringPiece& self, const StringPiece& s, size_t pos);
-size_t find_last_of(const StringPiece16& self,
-                    const StringPiece16& s,
-                    size_t pos);
-size_t find_last_of(const StringPiece& self, char c, size_t pos);
-size_t find_last_of(const StringPiece16& self, char16 c, size_t pos);
-
-size_t find_last_not_of(const StringPiece& self,
-                        const StringPiece& s,
-                        size_t pos);
-size_t find_last_not_of(const StringPiece16& self,
-                        const StringPiece16& s,
-                        size_t pos);
-size_t find_last_not_of(const StringPiece16& self, char16 c, size_t pos);
-size_t find_last_not_of(const StringPiece& self, char c, size_t pos);
-
-StringPiece substr(const StringPiece& self, size_t pos, size_t n);
-StringPiece16 substr(const StringPiece16& self, size_t pos, size_t n);
-
-#if DCHECK_IS_ON()
-// Asserts that begin <= end to catch some errors with iterator usage.
-void AssertIteratorsInOrder(std::string::const_iterator begin,
-                            std::string::const_iterator end);
-void AssertIteratorsInOrder(string16::const_iterator begin,
-                            string16::const_iterator end);
-#endif
-
-}  // namespace internal
-
-// BasicStringPiece ------------------------------------------------------------
-
-// Defines the types, methods, operators, and data members common to both
-// StringPiece and StringPiece16. Do not refer to this class directly, but
-// rather to BasicStringPiece, StringPiece, or StringPiece16.
-//
-// This is templatized by string class type rather than character type, so
-// BasicStringPiece<std::string> or BasicStringPiece<base::string16>.
-template <typename STRING_TYPE>
-class BasicStringPiece {
- public:
-  // Standard STL container boilerplate.
-  typedef size_t size_type;
-  typedef typename STRING_TYPE::value_type value_type;
-  typedef const value_type* pointer;
-  typedef const value_type& reference;
-  typedef const value_type& const_reference;
-  typedef ptrdiff_t difference_type;
-  typedef const value_type* const_iterator;
-  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
-  static const size_type npos;
-
- public:
-  // We provide non-explicit singleton constructors so users can pass
-  // in a "const char*" or a "string" wherever a "StringPiece" is
-  // expected (likewise for char16, string16, StringPiece16).
-  constexpr BasicStringPiece() : ptr_(NULL), length_(0) {}
-  // TODO(dcheng): Construction from nullptr is not allowed for
-  // std::basic_string_view, so remove the special handling for it.
-  // Note: This doesn't just use STRING_TYPE::traits_type::length(), since that
-  // isn't constexpr until C++17.
-  constexpr BasicStringPiece(const value_type* str)
-      : ptr_(str), length_(!str ? 0 : CharTraits<value_type>::length(str)) {}
-  BasicStringPiece(const STRING_TYPE& str)
-      : ptr_(str.data()), length_(str.size()) {}
-  constexpr BasicStringPiece(const value_type* offset, size_type len)
-      : ptr_(offset), length_(len) {}
-  BasicStringPiece(const typename STRING_TYPE::const_iterator& begin,
-                   const typename STRING_TYPE::const_iterator& end) {
-#if DCHECK_IS_ON()
-    // This assertion is done out-of-line to avoid bringing in logging.h and
-    // instantiating logging macros for every instantiation.
-    internal::AssertIteratorsInOrder(begin, end);
-#endif
-    length_ = static_cast<size_t>(std::distance(begin, end));
-
-    // The length test before assignment is to avoid dereferencing an iterator
-    // that may point to the end() of a string.
-    ptr_ = length_ > 0 ? &*begin : nullptr;
-  }
-
-  // data() may return a pointer to a buffer with embedded NULs, and the
-  // returned buffer may or may not be null terminated.  Therefore it is
-  // typically a mistake to pass data() to a routine that expects a NUL
-  // terminated string.
-  constexpr const value_type* data() const { return ptr_; }
-  constexpr size_type size() const { return length_; }
-  constexpr size_type length() const { return length_; }
-  bool empty() const { return length_ == 0; }
-
-  void clear() {
-    ptr_ = NULL;
-    length_ = 0;
-  }
-  void set(const value_type* data, size_type len) {
-    ptr_ = data;
-    length_ = len;
-  }
-  void set(const value_type* str) {
-    ptr_ = str;
-    length_ = str ? STRING_TYPE::traits_type::length(str) : 0;
-  }
-
-  constexpr value_type operator[](size_type i) const {
-    CHECK(i < length_);
-    return ptr_[i];
-  }
-
-  value_type front() const {
-    CHECK_NE(0UL, length_);
-    return ptr_[0];
-  }
-
-  value_type back() const {
-    CHECK_NE(0UL, length_);
-    return ptr_[length_ - 1];
-  }
-
-  constexpr void remove_prefix(size_type n) {
-    CHECK(n <= length_);
-    ptr_ += n;
-    length_ -= n;
-  }
-
-  constexpr void remove_suffix(size_type n) {
-    CHECK(n <= length_);
-    length_ -= n;
-  }
-
-  constexpr int compare(BasicStringPiece x) const noexcept {
-    int r = CharTraits<value_type>::compare(
-        ptr_, x.ptr_, (length_ < x.length_ ? length_ : x.length_));
-    if (r == 0) {
-      if (length_ < x.length_)
-        r = -1;
-      else if (length_ > x.length_)
-        r = +1;
-    }
-    return r;
-  }
-
-  // This is the style of conversion preferred by std::string_view in C++17.
-  explicit operator STRING_TYPE() const { return as_string(); }
-
-  STRING_TYPE as_string() const {
-    // std::string doesn't like to take a NULL pointer even with a 0 size.
-    return empty() ? STRING_TYPE() : STRING_TYPE(data(), size());
-  }
-
-  const_iterator begin() const { return ptr_; }
-  const_iterator end() const { return ptr_ + length_; }
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(ptr_ + length_);
-  }
-  const_reverse_iterator rend() const { return const_reverse_iterator(ptr_); }
-
-  size_type max_size() const { return length_; }
-  size_type capacity() const { return length_; }
-
-  // Sets the value of the given string target type to be the current string.
-  // This saves a temporary over doing |a = b.as_string()|
-  void CopyToString(STRING_TYPE* target) const {
-    internal::CopyToString(*this, target);
-  }
-
-  void AppendToString(STRING_TYPE* target) const {
-    internal::AppendToString(*this, target);
-  }
-
-  size_type copy(value_type* buf, size_type n, size_type pos = 0) const {
-    return internal::copy(*this, buf, n, pos);
-  }
-
-  // Does "this" start with "x"
-  constexpr bool starts_with(BasicStringPiece x) const noexcept {
-    return (
-        (this->length_ >= x.length_) &&
-        (CharTraits<value_type>::compare(this->ptr_, x.ptr_, x.length_) == 0));
-  }
-
-  // Does "this" end with "x"
-  constexpr bool ends_with(BasicStringPiece x) const noexcept {
-    return ((this->length_ >= x.length_) &&
-            (CharTraits<value_type>::compare(
-                 this->ptr_ + (this->length_ - x.length_), x.ptr_, x.length_) ==
-             0));
-  }
-
-  // find: Search for a character or substring at a given offset.
-  size_type find(const BasicStringPiece<STRING_TYPE>& s,
-                 size_type pos = 0) const {
-    return internal::find(*this, s, pos);
-  }
-  size_type find(value_type c, size_type pos = 0) const {
-    return internal::find(*this, c, pos);
-  }
-
-  // rfind: Reverse find.
-  size_type rfind(const BasicStringPiece& s,
-                  size_type pos = BasicStringPiece::npos) const {
-    return internal::rfind(*this, s, pos);
-  }
-  size_type rfind(value_type c, size_type pos = BasicStringPiece::npos) const {
-    return internal::rfind(*this, c, pos);
-  }
-
-  // find_first_of: Find the first occurence of one of a set of characters.
-  size_type find_first_of(const BasicStringPiece& s, size_type pos = 0) const {
-    return internal::find_first_of(*this, s, pos);
-  }
-  size_type find_first_of(value_type c, size_type pos = 0) const {
-    return find(c, pos);
-  }
-
-  // find_first_not_of: Find the first occurence not of a set of characters.
-  size_type find_first_not_of(const BasicStringPiece& s,
-                              size_type pos = 0) const {
-    return internal::find_first_not_of(*this, s, pos);
-  }
-  size_type find_first_not_of(value_type c, size_type pos = 0) const {
-    return internal::find_first_not_of(*this, c, pos);
-  }
-
-  // find_last_of: Find the last occurence of one of a set of characters.
-  size_type find_last_of(const BasicStringPiece& s,
-                         size_type pos = BasicStringPiece::npos) const {
-    return internal::find_last_of(*this, s, pos);
-  }
-  size_type find_last_of(value_type c,
-                         size_type pos = BasicStringPiece::npos) const {
-    return rfind(c, pos);
-  }
-
-  // find_last_not_of: Find the last occurence not of a set of characters.
-  size_type find_last_not_of(const BasicStringPiece& s,
-                             size_type pos = BasicStringPiece::npos) const {
-    return internal::find_last_not_of(*this, s, pos);
-  }
-  size_type find_last_not_of(value_type c,
-                             size_type pos = BasicStringPiece::npos) const {
-    return internal::find_last_not_of(*this, c, pos);
-  }
-
-  // substr.
-  BasicStringPiece substr(size_type pos,
-                          size_type n = BasicStringPiece::npos) const {
-    return internal::substr(*this, pos, n);
-  }
-
- protected:
-  const value_type* ptr_;
-  size_type length_;
-};
-
-template <typename STRING_TYPE>
-const typename BasicStringPiece<STRING_TYPE>::size_type
-    BasicStringPiece<STRING_TYPE>::npos =
-        typename BasicStringPiece<STRING_TYPE>::size_type(-1);
-
-// MSVC doesn't like complex extern templates and DLLs.
-#if !defined(COMPILER_MSVC)
-extern template class BasicStringPiece<std::string>;
-extern template class BasicStringPiece<string16>;
-#endif
-
-// StingPiece operators --------------------------------------------------------
-
-bool operator==(const StringPiece& x, const StringPiece& y);
-
-inline bool operator!=(const StringPiece& x, const StringPiece& y) {
-  return !(x == y);
-}
-
-inline bool operator<(const StringPiece& x, const StringPiece& y) {
-  const int r = CharTraits<StringPiece::value_type>::compare(
-      x.data(), y.data(), (x.size() < y.size() ? x.size() : y.size()));
-  return ((r < 0) || ((r == 0) && (x.size() < y.size())));
-}
-
-inline bool operator>(const StringPiece& x, const StringPiece& y) {
-  return y < x;
-}
-
-inline bool operator<=(const StringPiece& x, const StringPiece& y) {
-  return !(x > y);
-}
-
-inline bool operator>=(const StringPiece& x, const StringPiece& y) {
-  return !(x < y);
-}
-
-// StringPiece16 operators -----------------------------------------------------
-
-inline bool operator==(const StringPiece16& x, const StringPiece16& y) {
-  if (x.size() != y.size())
-    return false;
-
-  return CharTraits<StringPiece16::value_type>::compare(x.data(), y.data(),
-                                                        x.size()) == 0;
-}
-
-inline bool operator!=(const StringPiece16& x, const StringPiece16& y) {
-  return !(x == y);
-}
-
-inline bool operator<(const StringPiece16& x, const StringPiece16& y) {
-  const int r = CharTraits<StringPiece16::value_type>::compare(
-      x.data(), y.data(), (x.size() < y.size() ? x.size() : y.size()));
-  return ((r < 0) || ((r == 0) && (x.size() < y.size())));
-}
-
-inline bool operator>(const StringPiece16& x, const StringPiece16& y) {
-  return y < x;
-}
-
-inline bool operator<=(const StringPiece16& x, const StringPiece16& y) {
-  return !(x > y);
-}
-
-inline bool operator>=(const StringPiece16& x, const StringPiece16& y) {
-  return !(x < y);
-}
-
-std::ostream& operator<<(std::ostream& o, const StringPiece& piece);
-
-// Hashing ---------------------------------------------------------------------
-
-// We provide appropriate hash functions so StringPiece and StringPiece16 can
-// be used as keys in hash sets and maps.
-
-// This hash function is copied from base/strings/string16.h. We don't use the
-// ones already defined for string and string16 directly because it would
-// require the string constructors to be called, which we don't want.
-#define HASH_STRING_PIECE(StringPieceType, string_piece)         \
-  std::size_t result = 0;                                        \
-  for (StringPieceType::const_iterator i = string_piece.begin(); \
-       i != string_piece.end(); ++i)                             \
-    result = (result * 131) + *i;                                \
-  return result;
-
-struct StringPieceHash {
-  std::size_t operator()(const StringPiece& sp) const {
-    HASH_STRING_PIECE(StringPiece, sp);
-  }
-};
-struct StringPiece16Hash {
-  std::size_t operator()(const StringPiece16& sp16) const {
-    HASH_STRING_PIECE(StringPiece16, sp16);
-  }
-};
+// Temporary definitions. These should be removed and code using the standard
+// ones.
+using StringPiece = std::string_view;
+using StringPiece16 = std::u16string_view;
+using WStringPiece = std::wstring_view;
 
 }  // namespace base
 
diff --git a/base/strings/string_piece_forward.h b/base/strings/string_piece_forward.h
deleted file mode 100644
index 86c1d5f..0000000
--- a/base/strings/string_piece_forward.h
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2017 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.
-
-// Forward declaration of StringPiece types from base/strings/string_piece.h
-
-#ifndef BASE_STRINGS_STRING_PIECE_FORWARD_H_
-#define BASE_STRINGS_STRING_PIECE_FORWARD_H_
-
-#include <string>
-
-#include "base/strings/string16.h"
-
-namespace base {
-
-template <typename STRING_TYPE>
-class BasicStringPiece;
-typedef BasicStringPiece<std::string> StringPiece;
-typedef BasicStringPiece<string16> StringPiece16;
-
-}  // namespace base
-
-#endif  // BASE_STRINGS_STRING_PIECE_FORWARD_H_
diff --git a/base/strings/string_split.cc b/base/strings/string_split.cc
index e9b5c96..a57d537 100644
--- a/base/strings/string_split.cc
+++ b/base/strings/string_split.cc
@@ -14,34 +14,15 @@
 
 namespace {
 
-// PieceToOutputType converts a StringPiece as needed to a given output type,
-// which is either the same type of StringPiece (a NOP) or the corresponding
-// non-piece string type.
-//
-// The default converter is a NOP, it works when the OutputType is the
-// correct StringPiece.
-template <typename Str, typename OutputType>
-OutputType PieceToOutputType(BasicStringPiece<Str> piece) {
-  return piece;
-}
-template <>  // Convert StringPiece to std::string
-std::string PieceToOutputType<std::string, std::string>(StringPiece piece) {
-  return piece.as_string();
-}
-template <>  // Convert StringPiece16 to string16.
-string16 PieceToOutputType<string16, string16>(StringPiece16 piece) {
-  return piece.as_string();
-}
-
 // Returns either the ASCII or UTF-16 whitespace.
-template <typename Str>
-BasicStringPiece<Str> WhitespaceForType();
+template <typename char_type>
+std::basic_string_view<char_type> WhitespaceForType();
 template <>
-StringPiece16 WhitespaceForType<string16>() {
+StringPiece16 WhitespaceForType<char16_t>() {
   return kWhitespaceUTF16;
 }
 template <>
-StringPiece WhitespaceForType<std::string>() {
+StringPiece WhitespaceForType<char>() {
   return kWhitespaceASCII;
 }
 
@@ -69,36 +50,39 @@
 // multiple-character delimiters.
 //
 // DelimiterType is either a character (Str::value_type) or a string piece of
-// multiple characters (BasicStringPiece<Str>). StringPiece has a version of
-// find for both of these cases, and the single-character version is the most
+// multiple characters (std::basic_string_view<char>). StringPiece has a version
+// of find for both of these cases, and the single-character version is the most
 // common and can be implemented faster, which is why this is a template.
-template <typename Str, typename OutputStringType, typename DelimiterType>
-static std::vector<OutputStringType> SplitStringT(BasicStringPiece<Str> str,
-                                                  DelimiterType delimiter,
-                                                  WhitespaceHandling whitespace,
-                                                  SplitResult result_type) {
+template <typename char_type, typename OutputStringType, typename DelimiterType>
+static std::vector<OutputStringType> SplitStringT(
+    std::basic_string_view<char_type> str,
+    DelimiterType delimiter,
+    WhitespaceHandling whitespace,
+    SplitResult result_type) {
   std::vector<OutputStringType> result;
   if (str.empty())
     return result;
 
+  using ViewType = std::basic_string_view<char_type>;
+
   size_t start = 0;
-  while (start != Str::npos) {
+  while (start != ViewType::npos) {
     size_t end = FindFirstOf(str, delimiter, start);
 
-    BasicStringPiece<Str> piece;
-    if (end == Str::npos) {
+    ViewType piece;
+    if (end == ViewType::npos) {
       piece = str.substr(start);
-      start = Str::npos;
+      start = ViewType::npos;
     } else {
       piece = str.substr(start, end - start);
       start = end + 1;
     }
 
     if (whitespace == TRIM_WHITESPACE)
-      piece = TrimString(piece, WhitespaceForType<Str>(), TRIM_ALL);
+      piece = TrimString(piece, WhitespaceForType<char_type>(), TRIM_ALL);
 
     if (result_type == SPLIT_WANT_ALL || !piece.empty())
-      result.push_back(PieceToOutputType<Str, OutputStringType>(piece));
+      result.emplace_back(piece);
   }
   return result;
 }
@@ -116,7 +100,7 @@
   if (end_key_pos == std::string::npos) {
     return false;  // No delimiter.
   }
-  input.substr(0, end_key_pos).CopyToString(&result_pair.first);
+  result_pair.first.assign(input.substr(0, end_key_pos));
 
   // Find the value string.
   StringPiece remains = input.substr(end_key_pos, input.size() - end_key_pos);
@@ -124,19 +108,19 @@
   if (begin_value_pos == StringPiece::npos) {
     return false;  // No value.
   }
-  remains.substr(begin_value_pos, remains.size() - begin_value_pos)
-      .CopyToString(&result_pair.second);
+  result_pair.second.assign(
+      remains.substr(begin_value_pos, remains.size() - begin_value_pos));
 
   return true;
 }
 
-template <typename Str, typename OutputStringType>
-void SplitStringUsingSubstrT(BasicStringPiece<Str> input,
-                             BasicStringPiece<Str> delimiter,
+template <typename char_type, typename OutputStringType>
+void SplitStringUsingSubstrT(std::basic_string_view<char_type> input,
+                             std::basic_string_view<char_type> delimiter,
                              WhitespaceHandling whitespace,
                              SplitResult result_type,
                              std::vector<OutputStringType>* result) {
-  using Piece = BasicStringPiece<Str>;
+  using Piece = std::basic_string_view<char_type>;
   using size_type = typename Piece::size_type;
 
   result->clear();
@@ -148,10 +132,10 @@
                      : input.substr(begin_index, end_index - begin_index);
 
     if (whitespace == TRIM_WHITESPACE)
-      term = TrimString(term, WhitespaceForType<Str>(), TRIM_ALL);
+      term = TrimString(term, WhitespaceForType<char_type>(), TRIM_ALL);
 
     if (result_type == SPLIT_WANT_ALL || !term.empty())
-      result->push_back(PieceToOutputType<Str, OutputStringType>(term));
+      result->emplace_back(term);
   }
 }
 
@@ -162,11 +146,11 @@
                                      WhitespaceHandling whitespace,
                                      SplitResult result_type) {
   if (separators.size() == 1) {
-    return SplitStringT<std::string, std::string, char>(
-        input, separators[0], whitespace, result_type);
+    return SplitStringT<char, std::string, char>(input, separators[0],
+                                                 whitespace, result_type);
   }
-  return SplitStringT<std::string, std::string, StringPiece>(
-      input, separators, whitespace, result_type);
+  return SplitStringT<char, std::string, StringPiece>(input, separators,
+                                                      whitespace, result_type);
 }
 
 std::vector<string16> SplitString(StringPiece16 input,
@@ -174,10 +158,10 @@
                                   WhitespaceHandling whitespace,
                                   SplitResult result_type) {
   if (separators.size() == 1) {
-    return SplitStringT<string16, string16, char16>(input, separators[0],
+    return SplitStringT<char16_t, string16, char16>(input, separators[0],
                                                     whitespace, result_type);
   }
-  return SplitStringT<string16, string16, StringPiece16>(
+  return SplitStringT<char16_t, string16, StringPiece16>(
       input, separators, whitespace, result_type);
 }
 
@@ -186,11 +170,11 @@
                                           WhitespaceHandling whitespace,
                                           SplitResult result_type) {
   if (separators.size() == 1) {
-    return SplitStringT<std::string, StringPiece, char>(
-        input, separators[0], whitespace, result_type);
+    return SplitStringT<char, StringPiece, char>(input, separators[0],
+                                                 whitespace, result_type);
   }
-  return SplitStringT<std::string, StringPiece, StringPiece>(
-      input, separators, whitespace, result_type);
+  return SplitStringT<char, StringPiece, StringPiece>(input, separators,
+                                                      whitespace, result_type);
 }
 
 std::vector<StringPiece16> SplitStringPiece(StringPiece16 input,
@@ -198,10 +182,10 @@
                                             WhitespaceHandling whitespace,
                                             SplitResult result_type) {
   if (separators.size() == 1) {
-    return SplitStringT<string16, StringPiece16, char16>(
+    return SplitStringT<char16_t, StringPiece16, char16>(
         input, separators[0], whitespace, result_type);
   }
-  return SplitStringT<string16, StringPiece16, StringPiece16>(
+  return SplitStringT<char16_t, StringPiece16, StringPiece16>(
       input, separators, whitespace, result_type);
 }
 
diff --git a/base/strings/string_tokenizer.h b/base/strings/string_tokenizer.h
index 9c3b5fa..50deb88 100644
--- a/base/strings/string_tokenizer.h
+++ b/base/strings/string_tokenizer.h
@@ -142,9 +142,9 @@
   const_iterator token_begin() const { return token_begin_; }
   const_iterator token_end() const { return token_end_; }
   str token() const { return str(token_begin_, token_end_); }
-  BasicStringPiece<str> token_piece() const {
-    return BasicStringPiece<str>(&*token_begin_,
-                                 std::distance(token_begin_, token_end_));
+  std::basic_string_view<typename str::value_type> token_piece() const {
+    return std::basic_string_view<typename str::value_type>(
+        &*token_begin_, std::distance(token_begin_, token_end_));
   }
 
  private:
diff --git a/base/strings/string_util.cc b/base/strings/string_util.cc
index f3e8257..f6ee491 100644
--- a/base/strings/string_util.cc
+++ b/base/strings/string_util.cc
@@ -49,21 +49,6 @@
   return elem1.parameter < elem2.parameter;
 }
 
-// Overloaded function to append one string onto the end of another. Having a
-// separate overload for |source| as both string and StringPiece allows for more
-// efficient usage from functions templated to work with either type (avoiding a
-// redundant call to the BasicStringPiece constructor in both cases).
-template <typename string_type>
-inline void AppendToString(string_type* target, const string_type& source) {
-  target->append(source);
-}
-
-template <typename string_type>
-inline void AppendToString(string_type* target,
-                           const BasicStringPiece<string_type>& source) {
-  source.AppendToString(target);
-}
-
 // Assuming that a pointer is the size of a "machine word", then
 // uintptr_t is an integer type that is also a machine word.
 typedef uintptr_t MachineWord;
@@ -103,7 +88,8 @@
 namespace {
 
 template <typename StringType>
-StringType ToLowerASCIIImpl(BasicStringPiece<StringType> str) {
+StringType ToLowerASCIIImpl(
+    std::basic_string_view<typename StringType::value_type> str) {
   StringType ret;
   ret.reserve(str.size());
   for (size_t i = 0; i < str.size(); i++)
@@ -112,7 +98,8 @@
 }
 
 template <typename StringType>
-StringType ToUpperASCIIImpl(BasicStringPiece<StringType> str) {
+StringType ToUpperASCIIImpl(
+    std::basic_string_view<typename StringType::value_type> str) {
   StringType ret;
   ret.reserve(str.size());
   for (size_t i = 0; i < str.size(); i++)
@@ -139,8 +126,9 @@
 }
 
 template <class StringType>
-int CompareCaseInsensitiveASCIIT(BasicStringPiece<StringType> a,
-                                 BasicStringPiece<StringType> b) {
+int CompareCaseInsensitiveASCIIT(
+    std::basic_string_view<typename StringType::value_type> a,
+    std::basic_string_view<typename StringType::value_type> b) {
   // Find the first characters that aren't equal and compare them.  If the end
   // of one of the strings is found before a nonequal character, the lengths
   // of the strings are compared.
@@ -186,10 +174,11 @@
 }
 
 template <class StringType>
-bool ReplaceCharsT(const StringType& input,
-                   BasicStringPiece<StringType> find_any_of_these,
-                   BasicStringPiece<StringType> replace_with,
-                   StringType* output);
+bool ReplaceCharsT(
+    const StringType& input,
+    std::basic_string_view<typename StringType::value_type> find_any_of_these,
+    std::basic_string_view<typename StringType::value_type> replace_with,
+    StringType* output);
 
 bool ReplaceChars(const string16& input,
                   StringPiece16 replace_chars,
@@ -219,15 +208,16 @@
 }
 
 template <typename Str>
-TrimPositions TrimStringT(const Str& input,
-                          BasicStringPiece<Str> trim_chars,
-                          TrimPositions positions,
-                          Str* output) {
+TrimPositions TrimStringT(
+    const Str& input,
+    std::basic_string_view<typename Str::value_type> trim_chars,
+    TrimPositions positions,
+    Str* output) {
   // Find the edges of leading/trailing whitespace as desired. Need to use
   // a StringPiece version of input to be able to call find* on it with the
   // StringPiece version of trim_chars (normally the trim_chars will be a
   // constant so avoid making a copy).
-  BasicStringPiece<Str> input_piece(input);
+  std::basic_string_view<typename Str::value_type> input_piece(input);
   const size_t last_char = input.length() - 1;
   const size_t first_good_char = (positions & TRIM_LEADING)
                                      ? input_piece.find_first_not_of(trim_chars)
@@ -267,12 +257,16 @@
   return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
 }
 
-template <typename Str>
-BasicStringPiece<Str> TrimStringPieceT(BasicStringPiece<Str> input,
-                                       BasicStringPiece<Str> trim_chars,
-                                       TrimPositions positions) {
+template <typename char_type>
+std::basic_string_view<char_type> TrimStringPieceT(
+    std::basic_string_view<char_type> input,
+    std::basic_string_view<char_type> trim_chars,
+    TrimPositions positions) {
   size_t begin =
       (positions & TRIM_LEADING) ? input.find_first_not_of(trim_chars) : 0;
+  if (begin == std::basic_string_view<char_type>::npos)
+    return std::basic_string_view<char_type>();  // All trimmed.
+
   size_t end = (positions & TRIM_TRAILING)
                    ? input.find_last_not_of(trim_chars) + 1
                    : input.size();
@@ -474,8 +468,9 @@
 // string piece gives additional flexibility for the caller (doesn't have to be
 // null terminated) so we choose the StringPiece route.
 template <typename Str>
-static inline bool DoLowerCaseEqualsASCII(BasicStringPiece<Str> str,
-                                          StringPiece lowercase_ascii) {
+static inline bool DoLowerCaseEqualsASCII(
+    std::basic_string_view<typename Str::value_type> str,
+    StringPiece lowercase_ascii) {
   if (str.size() != lowercase_ascii.size())
     return false;
   for (size_t i = 0; i < str.size(); i++) {
@@ -499,23 +494,22 @@
   return std::equal(ascii.begin(), ascii.end(), str.begin());
 }
 
-template <typename Str>
-bool StartsWithT(BasicStringPiece<Str> str,
-                 BasicStringPiece<Str> search_for,
+template <typename char_type>
+bool StartsWithT(std::basic_string_view<char_type> str,
+                 std::basic_string_view<char_type> search_for,
                  CompareCase case_sensitivity) {
   if (search_for.size() > str.size())
     return false;
 
-  BasicStringPiece<Str> source = str.substr(0, search_for.size());
+  std::basic_string_view<char_type> source = str.substr(0, search_for.size());
 
   switch (case_sensitivity) {
     case CompareCase::SENSITIVE:
       return source == search_for;
 
     case CompareCase::INSENSITIVE_ASCII:
-      return std::equal(
-          search_for.begin(), search_for.end(), source.begin(),
-          CaseInsensitiveCompareASCII<typename Str::value_type>());
+      return std::equal(search_for.begin(), search_for.end(), source.begin(),
+                        CaseInsensitiveCompareASCII<char_type>());
 
     default:
       NOTREACHED();
@@ -526,23 +520,23 @@
 bool StartsWith(StringPiece str,
                 StringPiece search_for,
                 CompareCase case_sensitivity) {
-  return StartsWithT<std::string>(str, search_for, case_sensitivity);
+  return StartsWithT(str, search_for, case_sensitivity);
 }
 
 bool StartsWith(StringPiece16 str,
                 StringPiece16 search_for,
                 CompareCase case_sensitivity) {
-  return StartsWithT<string16>(str, search_for, case_sensitivity);
+  return StartsWithT(str, search_for, case_sensitivity);
 }
 
 template <typename Str>
-bool EndsWithT(BasicStringPiece<Str> str,
-               BasicStringPiece<Str> search_for,
+bool EndsWithT(std::basic_string_view<typename Str::value_type> str,
+               std::basic_string_view<typename Str::value_type> search_for,
                CompareCase case_sensitivity) {
   if (search_for.size() > str.size())
     return false;
 
-  BasicStringPiece<Str> source =
+  std::basic_string_view<typename Str::value_type> source =
       str.substr(str.size() - search_for.size(), search_for.size());
 
   switch (case_sensitivity) {
@@ -620,7 +614,7 @@
 // A Matcher for DoReplaceMatchesAfterOffset() that matches substrings.
 template <class StringType>
 struct SubstringMatcher {
-  BasicStringPiece<StringType> find_this;
+  std::basic_string_view<typename StringType::value_type> find_this;
 
   size_t Find(const StringType& input, size_t pos) {
     return input.find(find_this.data(), pos, find_this.length());
@@ -631,7 +625,7 @@
 // A Matcher for DoReplaceMatchesAfterOffset() that matches single characters.
 template <class StringType>
 struct CharacterMatcher {
-  BasicStringPiece<StringType> find_any_of_these;
+  std::basic_string_view<typename StringType::value_type> find_any_of_these;
 
   size_t Find(const StringType& input, size_t pos) {
     return input.find_first_of(find_any_of_these.data(), pos,
@@ -648,11 +642,12 @@
 // This is parameterized on a |Matcher| traits type, so that it can be the
 // implementation for both ReplaceChars() and ReplaceSubstringsAfterOffset().
 template <class StringType, class Matcher>
-bool DoReplaceMatchesAfterOffset(StringType* str,
-                                 size_t initial_offset,
-                                 Matcher matcher,
-                                 BasicStringPiece<StringType> replace_with,
-                                 ReplaceType replace_type) {
+bool DoReplaceMatchesAfterOffset(
+    StringType* str,
+    size_t initial_offset,
+    Matcher matcher,
+    std::basic_string_view<typename StringType::value_type> replace_with,
+    ReplaceType replace_type) {
   using CharTraits = typename StringType::traits_type;
 
   const size_t find_length = matcher.MatchSize();
@@ -791,10 +786,11 @@
 }
 
 template <class StringType>
-bool ReplaceCharsT(const StringType& input,
-                   BasicStringPiece<StringType> find_any_of_these,
-                   BasicStringPiece<StringType> replace_with,
-                   StringType* output) {
+bool ReplaceCharsT(
+    const StringType& input,
+    std::basic_string_view<typename StringType::value_type> find_any_of_these,
+    std::basic_string_view<typename StringType::value_type> replace_with,
+    StringType* output) {
   // Commonly, this is called with output and input being the same string; in
   // that case, this assignment is inexpensive.
   *output = input;
@@ -863,34 +859,30 @@
 #endif
 
 // Generic version for all JoinString overloads. |list_type| must be a sequence
-// (std::vector or std::initializer_list) of strings/StringPieces (std::string,
-// string16, StringPiece or StringPiece16). |string_type| is either std::string
-// or string16.
-template <typename list_type, typename string_type>
-static string_type JoinStringT(const list_type& parts,
-                               BasicStringPiece<string_type> sep) {
+// (std::vector or std::initializer_list) of strings/string_views of any type.
+template <typename char_type, typename list_type>
+static std::basic_string<char_type> JoinStringT(
+    const list_type& parts,
+    std::basic_string_view<char_type> sep) {
   if (parts.size() == 0)
-    return string_type();
+    return std::basic_string<char_type>();
 
   // Pre-allocate the eventual size of the string. Start with the size of all of
   // the separators (note that this *assumes* parts.size() > 0).
   size_t total_size = (parts.size() - 1) * sep.size();
   for (const auto& part : parts)
     total_size += part.size();
-  string_type result;
+  std::basic_string<char_type> result;
   result.reserve(total_size);
 
   auto iter = parts.begin();
   DCHECK(iter != parts.end());
-  AppendToString(&result, *iter);
+  result.append(*iter);
   ++iter;
 
   for (; iter != parts.end(); ++iter) {
-    sep.AppendToString(&result);
-    // Using the overloaded AppendToString allows this template function to work
-    // on both strings and StringPieces without creating an intermediate
-    // StringPiece object.
-    AppendToString(&result, *iter);
+    result.append(sep);
+    result.append(*iter);
   }
 
   // Sanity-check that we pre-allocated correctly.
diff --git a/base/strings/utf_string_conversion_utils.cc b/base/strings/utf_string_conversion_utils.cc
index 4e5f890..838471c 100644
--- a/base/strings/utf_string_conversion_utils.cc
+++ b/base/strings/utf_string_conversion_utils.cc
@@ -30,7 +30,7 @@
   return IsValidCodepoint(code_point);
 }
 
-bool ReadUnicodeCharacter(const char16* src,
+bool ReadUnicodeCharacter(const char16_t* src,
                           int32_t src_len,
                           int32_t* char_index,
                           uint32_t* code_point) {
@@ -107,7 +107,7 @@
 }
 
 // Instantiate versions we know callers will need.
-template void PrepareForUTF8Output(const char16*, size_t, std::string*);
+template void PrepareForUTF8Output(const char16_t*, size_t, std::string*);
 
 template <typename STRING>
 void PrepareForUTF16Or32Output(const char* src,
diff --git a/base/strings/utf_string_conversion_utils.h b/base/strings/utf_string_conversion_utils.h
index 78cbde7..3f14808 100644
--- a/base/strings/utf_string_conversion_utils.h
+++ b/base/strings/utf_string_conversion_utils.h
@@ -47,7 +47,7 @@
                           uint32_t* code_point_out);
 
 // Reads a UTF-16 character. The usage is the same as the 8-bit version above.
-bool ReadUnicodeCharacter(const char16* src,
+bool ReadUnicodeCharacter(const char16_t* src,
                           int32_t src_len,
                           int32_t* char_index,
                           uint32_t* code_point);
diff --git a/build/gen.py b/build/gen.py
index 3d9406c..5011ea9 100755
--- a/build/gen.py
+++ b/build/gen.py
@@ -407,7 +407,6 @@
         'base/memory/weak_ptr.cc',
         'base/sha1.cc',
         'base/strings/string_number_conversions.cc',
-        'base/strings/string_piece.cc',
         'base/strings/string_split.cc',
         'base/strings/string_util.cc',
         'base/strings/string_util_constants.cc',
diff --git a/tools/gn/bundle_data.cc b/tools/gn/bundle_data.cc
index 4251c8f..9de0e8c 100644
--- a/tools/gn/bundle_data.cc
+++ b/tools/gn/bundle_data.cc
@@ -5,6 +5,7 @@
 #include "tools/gn/bundle_data.h"
 
 #include "base/logging.h"
+#include "base/strings/string_util.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/label_pattern.h"
 #include "tools/gn/output_file.h"
@@ -31,15 +32,20 @@
   //    .*\.xcassets/[^/]*\.launchimage/[^/]*
   bool is_file_from_asset_catalog = false;
   base::StringPiece dir = FindDirNoTrailingSeparator(source);
-  if (source.ends_with("/Contents.json") && dir.ends_with(".xcassets")) {
+  if (base::EndsWith(source, "/Contents.json", base::CompareCase::SENSITIVE) &&
+      base::EndsWith(dir, ".xcassets", base::CompareCase::SENSITIVE)) {
     is_file_from_asset_catalog = true;
-  } else if (dir.ends_with(".appiconset") || dir.ends_with(".imageset") ||
-             dir.ends_with(".launchimage") || dir.ends_with(".colorset")) {
+  } else if (base::EndsWith(dir, ".appiconset", base::CompareCase::SENSITIVE) ||
+             base::EndsWith(dir, ".imageset", base::CompareCase::SENSITIVE) ||
+             base::EndsWith(dir, ".launchimage",
+                            base::CompareCase::SENSITIVE) ||
+             base::EndsWith(dir, ".colorset", base::CompareCase::SENSITIVE)) {
     dir = FindDirNoTrailingSeparator(dir);
-    is_file_from_asset_catalog = dir.ends_with(".xcassets");
+    is_file_from_asset_catalog =
+        base::EndsWith(dir, ".xcassets", base::CompareCase::SENSITIVE);
   }
   if (is_file_from_asset_catalog && asset_catalog) {
-    std::string asset_catalog_path = dir.as_string();
+    std::string asset_catalog_path(dir);
     *asset_catalog = SourceFile(std::move(asset_catalog_path));
   }
   return is_file_from_asset_catalog;
diff --git a/tools/gn/c_include_iterator_unittest.cc b/tools/gn/c_include_iterator_unittest.cc
index a88537c..aa1f99a 100644
--- a/tools/gn/c_include_iterator_unittest.cc
+++ b/tools/gn/c_include_iterator_unittest.cc
@@ -132,7 +132,7 @@
   CIncludeIterator iter(&file);
   for (size_t group = 0; group < kGroupCount; group++) {
     EXPECT_TRUE(iter.GetNextIncludeString(&contents, &range));
-    EXPECT_EQ(include, contents.as_string());
+    EXPECT_EQ(include, std::string(contents));
   }
   EXPECT_FALSE(iter.GetNextIncludeString(&contents, &range));
 }
diff --git a/tools/gn/command_args.cc b/tools/gn/command_args.cc
index 096ba8f..26b8bd6 100644
--- a/tools/gn/command_args.cc
+++ b/tools/gn/command_args.cc
@@ -72,7 +72,7 @@
   // normal comment that has a space after the # will be indented 4 spaces
   // (which makes our formatting come out nicely). If the comment is indented
   // from there, we want to preserve that indenting.
-  std::string line_stripped = line.substr(line.find('#') + 1).as_string();
+  std::string line_stripped(line.substr(line.find('#') + 1));
   if (pad)
     return "   " + line_stripped;
 
@@ -131,7 +131,7 @@
     if (!comment.empty())
       OutputString("\n" + comment);
   } else {
-    OutputString("      (Internally set; try `gn help " + name.as_string() +
+    OutputString("      (Internally set; try `gn help " + std::string(name) +
                  "`.)\n");
   }
 }
@@ -139,7 +139,7 @@
 // Override value is null if there is no override.
 void PrintArgHelp(const base::StringPiece& name,
                   const Args::ValueWithOverride& val) {
-  OutputString(name.as_string(), DECORATION_YELLOW);
+  OutputString(std::string(name), DECORATION_YELLOW);
   OutputString("\n");
 
   if (val.has_override) {
@@ -259,7 +259,7 @@
     for (const auto& arg : args) {
       if (overrides_only && !arg.second.has_override)
         continue;
-      OutputString(arg.first.as_string());
+      OutputString(std::string(arg.first));
       OutputString(" = ");
       if (arg.second.has_override)
         OutputString(arg.second.override_value.ToString(true));
diff --git a/tools/gn/command_clean.cc b/tools/gn/command_clean.cc
index b354039..32aaf77 100644
--- a/tools/gn/command_clean.cc
+++ b/tools/gn/command_clean.cc
@@ -33,7 +33,7 @@
   std::string result;
   int num_blank_lines = 0;
   for (const auto& line : lines) {
-    line.AppendToString(&result);
+    result.append(line);
     result.push_back('\n');
     if (line.empty())
       ++num_blank_lines;
diff --git a/tools/gn/command_format.cc b/tools/gn/command_format.cc
index 4249c2f..a8604a5 100644
--- a/tools/gn/command_format.cc
+++ b/tools/gn/command_format.cc
@@ -265,7 +265,7 @@
 Printer::~Printer() = default;
 
 void Printer::Print(base::StringPiece str) {
-  str.AppendToString(&output_);
+  output_.append(str);
 }
 
 void Printer::PrintMargin() {
@@ -274,7 +274,7 @@
 
 void Printer::TrimAndPrintToken(const Token& token) {
   std::string trimmed;
-  TrimWhitespaceASCII(token.value().as_string(), base::TRIM_ALL, &trimmed);
+  TrimWhitespaceASCII(std::string(token.value()), base::TRIM_ALL, &trimmed);
   Print(trimmed);
 }
 
@@ -335,9 +335,8 @@
 void Printer::SortIfSourcesOrDeps(const BinaryOpNode* binop) {
   if (const Comments* comments = binop->comments()) {
     const std::vector<Token>& before = comments->before();
-    if (!before.empty() &&
-        (before.front().value().as_string() == "# NOSORT" ||
-         before.back().value().as_string() == "# NOSORT")) {
+    if (!before.empty() && (before.front().value() == "# NOSORT" ||
+                            before.back().value() == "# NOSORT")) {
       // Allow disabling of sort for specific actions that might be
       // order-sensitive.
       return;
@@ -645,7 +644,7 @@
     Printer sub_left;
     InitializeSub(&sub_left);
     sub_left.Expr(binop->left(), prec_left,
-                  std::string(" ") + binop->op().value().as_string());
+                  std::string(" ") + std::string(binop->op().value()));
     bool left_is_multiline = CountLines(sub_left.String()) > 1;
     // Avoid walking the whole left redundantly times (see timing of Format.046)
     // so pull the output and comments from subprinter.
@@ -1063,7 +1062,8 @@
   return false;
 }
 
-void DoFormat(const ParseNode* root, TreeDumpMode dump_tree,
+void DoFormat(const ParseNode* root,
+              TreeDumpMode dump_tree,
               std::string* output) {
   if (dump_tree == TreeDumpMode::kPlainText) {
     std::ostringstream os;
@@ -1071,8 +1071,8 @@
     fprintf(stderr, "%s", os.str().c_str());
   } else if (dump_tree == TreeDumpMode::kJSON) {
     std::string os;
-    base::JSONWriter::WriteWithOptions(root->GetJSONNode(),
-        base::JSONWriter::OPTIONS_PRETTY_PRINT, &os);
+    base::JSONWriter::WriteWithOptions(
+        root->GetJSONNode(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &os);
     fprintf(stderr, "%s", os.c_str());
   }
 
@@ -1146,17 +1146,19 @@
       base::CommandLine::ForCurrentProcess()->HasSwitch(kSwitchDryRun);
   TreeDumpMode dump_tree = TreeDumpMode::kInactive;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(kSwitchDumpTree)) {
-    std::string tree_type = base::CommandLine::ForCurrentProcess()->
-        GetSwitchValueASCII(kSwitchDumpTree);
+    std::string tree_type =
+        base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+            kSwitchDumpTree);
     if (tree_type == kSwitchDumpTreeJSON) {
       dump_tree = TreeDumpMode::kJSON;
     } else if (tree_type.empty() || tree_type == kSwitchDumpTreeText) {
       dump_tree = TreeDumpMode::kPlainText;
     } else {
-      Err(Location(),
-          tree_type + " is an invalid value for --dump-tree. Specify "
-          "\"" + kSwitchDumpTreeText + "\" or \"" + kSwitchDumpTreeJSON +
-          "\".\n")
+      Err(Location(), tree_type +
+                          " is an invalid value for --dump-tree. Specify "
+                          "\"" +
+                          kSwitchDumpTreeText + "\" or \"" +
+                          kSwitchDumpTreeJSON + "\".\n")
           .PrintToStdout();
       return 1;
     }
@@ -1200,8 +1202,7 @@
   // parallel.
   for (const auto& arg : args) {
     Err err;
-    SourceFile file =
-        source_dir.ResolveRelativeFile(Value(nullptr, arg), &err);
+    SourceFile file = source_dir.ResolveRelativeFile(Value(nullptr, arg), &err);
     if (err.has_error()) {
       err.PrintToStdout();
       return 1;
diff --git a/tools/gn/command_help.cc b/tools/gn/command_help.cc
index 7145da4..987f506 100644
--- a/tools/gn/command_help.cc
+++ b/tools/gn/command_help.cc
@@ -366,7 +366,7 @@
     OutputString("Run `gn help` for a list of available topics.\n",
                  DECORATION_NONE);
   } else {
-    OutputString("Did you mean `gn help " + suggestion.as_string() + "`?\n",
+    OutputString("Did you mean `gn help " + std::string(suggestion) + "`?\n",
                  DECORATION_NONE);
   }
   return 1;
diff --git a/tools/gn/create_bundle_target_generator.cc b/tools/gn/create_bundle_target_generator.cc
index a54d171..2c5a3af 100644
--- a/tools/gn/create_bundle_target_generator.cc
+++ b/tools/gn/create_bundle_target_generator.cc
@@ -125,7 +125,7 @@
       return false;
 
     xcode_extra_attributes.insert(
-        std::make_pair(iter.first.as_string(), iter.second.string_value()));
+        std::make_pair(std::string(iter.first), iter.second.string_value()));
   }
 
   target_->bundle_data().xcode_extra_attributes() =
diff --git a/tools/gn/err.cc b/tools/gn/err.cc
index fe4db20..4f60964 100644
--- a/tools/gn/err.cc
+++ b/tools/gn/err.cc
@@ -22,7 +22,7 @@
   size_t end = line_off + 1;
   while (end < data.size() && !Tokenizer::IsNewline(data, end))
     end++;
-  return data.substr(line_off, end - line_off).as_string();
+  return std::string(data.substr(line_off, end - line_off));
 }
 
 void FillRangeOnLine(const LocationRange& range,
diff --git a/tools/gn/filesystem_utils.cc b/tools/gn/filesystem_utils.cc
index 727e2f3..ea4dfb8 100644
--- a/tools/gn/filesystem_utils.cc
+++ b/tools/gn/filesystem_utils.cc
@@ -226,7 +226,7 @@
 #if defined(OS_WIN)
   return base::FilePath(base::UTF8ToUTF16(sp));
 #else
-  return base::FilePath(sp.as_string());
+  return base::FilePath(sp);
 #endif
 }
 
@@ -572,7 +572,7 @@
                 // On Windows, if the source_root does not start with a slash,
                 // append one here for consistency.
                 if (!IsSlash(source_root[0])) {
-                  path->insert(0, "/" + source_root.as_string());
+                  path->insert(0, "/" + std::string(source_root));
                   source_root_len++;
                 } else {
                   path->insert(0, source_root.data(), source_root_len);
@@ -704,7 +704,8 @@
                        const SourceDir& dest_dir,
                        const base::StringPiece& source_root) {
   std::string ret;
-  DCHECK(source_root.empty() || !source_root.ends_with("/"));
+  DCHECK(source_root.empty() ||
+         !base::EndsWith(source_root, "/", base::CompareCase::SENSITIVE));
 
   bool input_is_source_path =
       (input.size() >= 2 && input[0] == '/' && input[1] == '/');
@@ -714,14 +715,14 @@
     std::string input_full;
     std::string dest_full;
     if (input_is_source_path) {
-      source_root.AppendToString(&input_full);
+      input_full.append(source_root);
       input_full.push_back('/');
       input_full.append(input, 2, std::string::npos);
     } else {
       input_full.append(input);
     }
     if (dest_dir.is_source_absolute()) {
-      source_root.AppendToString(&dest_full);
+      dest_full.append(source_root);
       dest_full.push_back('/');
       dest_full.append(dest_dir.value(), 2, std::string::npos);
     } else {
diff --git a/tools/gn/filesystem_utils_unittest.cc b/tools/gn/filesystem_utils_unittest.cc
index 32b30f6..2f8df44 100644
--- a/tools/gn/filesystem_utils_unittest.cc
+++ b/tools/gn/filesystem_utils_unittest.cc
@@ -26,17 +26,17 @@
 
 TEST(FilesystemUtils, FindExtension) {
   std::string input;
-  EXPECT_EQ("", FindExtension(&input).as_string());
+  EXPECT_EQ("", FindExtension(&input));
   input = "foo/bar/baz";
-  EXPECT_EQ("", FindExtension(&input).as_string());
+  EXPECT_EQ("", FindExtension(&input));
   input = "foo.";
-  EXPECT_EQ("", FindExtension(&input).as_string());
+  EXPECT_EQ("", FindExtension(&input));
   input = "f.o.bar";
-  EXPECT_EQ("bar", FindExtension(&input).as_string());
+  EXPECT_EQ("bar", FindExtension(&input));
   input = "foo.bar/";
-  EXPECT_EQ("", FindExtension(&input).as_string());
+  EXPECT_EQ("", FindExtension(&input));
   input = "foo.bar/baz";
-  EXPECT_EQ("", FindExtension(&input).as_string());
+  EXPECT_EQ("", FindExtension(&input));
 }
 
 TEST(FilesystemUtils, FindFilenameOffset) {
diff --git a/tools/gn/function_get_path_info.cc b/tools/gn/function_get_path_info.cc
index 08f7e8c..b392490 100644
--- a/tools/gn/function_get_path_info.cc
+++ b/tools/gn/function_get_path_info.cc
@@ -63,10 +63,10 @@
 
   switch (what) {
     case WHAT_FILE: {
-      return FindFilename(&input_string).as_string();
+      return std::string(FindFilename(&input_string));
     }
     case WHAT_NAME: {
-      std::string file = FindFilename(&input_string).as_string();
+      std::string file(FindFilename(&input_string));
       size_t extension_offset = FindExtensionOffset(file);
       if (extension_offset == std::string::npos)
         return file;
@@ -74,7 +74,7 @@
       return file.substr(0, extension_offset - 1);
     }
     case WHAT_EXTENSION: {
-      return FindExtension(&input_string).as_string();
+      return std::string(FindExtension(&input_string));
     }
     case WHAT_DIR: {
       base::StringPiece dir_incl_slash = FindDir(&input_string);
@@ -87,7 +87,7 @@
         return std::string("/.");
       if (dir_incl_slash == "//")
         return std::string("//.");
-      return dir_incl_slash.substr(0, dir_incl_slash.size() - 1).as_string();
+      return std::string(dir_incl_slash.substr(0, dir_incl_slash.size() - 1));
     }
     case WHAT_GEN_DIR: {
       return DirectoryWithNoLastSlash(GetSubBuildDirAsSourceDir(
diff --git a/tools/gn/functions.cc b/tools/gn/functions.cc
index 05033c8..c0a64ac 100644
--- a/tools/gn/functions.cc
+++ b/tools/gn/functions.cc
@@ -1175,7 +1175,7 @@
   int64_t n = 0;
   std::string val(str);
   size_t start_pos = 0;
-  while((start_pos = val.find(old, start_pos)) != std::string::npos) {
+  while ((start_pos = val.find(old, start_pos)) != std::string::npos) {
     val.replace(start_pos, old.length(), new_);
     start_pos += new_.length();
     if (++n >= max)
@@ -1315,7 +1315,7 @@
                   Err* err) {
   const Token& name = function->function();
 
-  std::string template_name = function->function().value().as_string();
+  std::string template_name(function->function().value());
   const Template* templ = scope->GetTemplate(template_name);
   if (templ) {
     Value args = args_list->Execute(scope, err);
diff --git a/tools/gn/generated_file_target_generator.cc b/tools/gn/generated_file_target_generator.cc
index 2971221..023e5d4 100644
--- a/tools/gn/generated_file_target_generator.cc
+++ b/tools/gn/generated_file_target_generator.cc
@@ -72,9 +72,9 @@
     const ParseNode* origin) {
   if (contents_defined_) {
     *err_ =
-        Err(origin, variable.as_string() + " won't be used.",
+        Err(origin, std::string(variable) + " won't be used.",
             "\"contents\" is defined on this target, and so setting " +
-                variable.as_string() +
+                std::string(variable) +
                 " will have no effect as no metdata collection will occur.");
     return false;
   }
diff --git a/tools/gn/header_checker.cc b/tools/gn/header_checker.cc
index dca7302..14784b7 100644
--- a/tools/gn/header_checker.cc
+++ b/tools/gn/header_checker.cc
@@ -120,8 +120,10 @@
 HeaderChecker::HeaderChecker(const BuildSettings* build_settings,
                              const std::vector<const Target*>& targets,
                              bool check_generated)
-    : build_settings_(build_settings), check_generated_(check_generated),
-      lock_(), task_count_cv_() {
+    : build_settings_(build_settings),
+      check_generated_(check_generated),
+      lock_(),
+      task_count_cv_() {
   for (auto* target : targets)
     AddTargetToFileMap(target, &file_map_);
 }
@@ -249,7 +251,7 @@
     Err* err) const {
   using base::FilePath;
 
-  Value relative_file_value(nullptr, relative_file_path.as_string());
+  Value relative_file_value(nullptr, std::string(relative_file_path));
   auto it = std::find_if(
       include_dirs.begin(), include_dirs.end(),
       [relative_file_value, err, this](const SourceDir& dir) -> bool {
diff --git a/tools/gn/label_pattern.cc b/tools/gn/label_pattern.cc
index f5e6b9c..bed4d86 100644
--- a/tools/gn/label_pattern.cc
+++ b/tools/gn/label_pattern.cc
@@ -55,9 +55,7 @@
                            const SourceDir& dir,
                            const base::StringPiece& name,
                            const Label& toolchain_label)
-    : toolchain_(toolchain_label), type_(type), dir_(dir) {
-  name.CopyToString(&name_);
-}
+    : toolchain_(toolchain_label), type_(type), dir_(dir), name_(name) {}
 
 LabelPattern::LabelPattern(const LabelPattern& other) = default;
 
@@ -103,8 +101,8 @@
       return LabelPattern();
     }
 
-    std::string toolchain_string =
-        str.substr(open_paren + 1, close_paren - open_paren - 1).as_string();
+    std::string toolchain_string(
+        str.substr(open_paren + 1, close_paren - open_paren - 1));
     if (toolchain_string.find('*') != std::string::npos) {
       *err = Err(value, "Can't have a wildcard in the toolchain.");
       return LabelPattern();
diff --git a/tools/gn/operators.cc b/tools/gn/operators.cc
index 40ea900..24b17c0 100644
--- a/tools/gn/operators.cc
+++ b/tools/gn/operators.cc
@@ -118,7 +118,7 @@
           "\n"
           "If you really wanted to do this, do:\n"
           "  " +
-              base_str.as_string() + " = " + base_str.as_string() +
+              std::string(base_str) + " = " + std::string(base_str) +
               "\n"
               "to copy it into the current scope before doing this operation.");
     } else {
@@ -246,7 +246,7 @@
                               const Value& right) {
   std::string msg = std::string("You can't do <") +
                     Value::DescribeType(left.type()) + "> " +
-                    op_node->op().value().as_string() + " <" +
+                    std::string(op_node->op().value()) + " <" +
                     Value::DescribeType(right.type()) + ">.";
   if (left.type() == Value::LIST) {
     // Append extra hint for list stuff.
diff --git a/tools/gn/output_conversion.cc b/tools/gn/output_conversion.cc
index 7f62896..77e9a4f 100644
--- a/tools/gn/output_conversion.cc
+++ b/tools/gn/output_conversion.cc
@@ -56,7 +56,7 @@
     if (!first)
       out << ",\n";
     Indent(indent, out);
-    out << "\"" << pair.first.as_string() << "\": ";
+    out << "\"" << pair.first << "\": ";
     if (pair.second.type() == Value::SCOPE)
       RenderScopeToJSON(pair.second, out, indent + 1);
     else if (pair.second.type() == Value::LIST)
@@ -103,8 +103,7 @@
   Scope::KeyValueMap scope_values;
   output.scope_value()->GetCurrentScopeValues(&scope_values);
   for (const auto& pair : scope_values) {
-    out << "  " << pair.first.as_string() << " = " << pair.second.ToString(true)
-        << "\n";
+    out << "  " << pair.first << " = " << pair.second.ToString(true) << "\n";
   }
 }
 
diff --git a/tools/gn/parse_tree.cc b/tools/gn/parse_tree.cc
index 821fb7e..337b3b2 100644
--- a/tools/gn/parse_tree.cc
+++ b/tools/gn/parse_tree.cc
@@ -13,6 +13,7 @@
 #include "base/json/string_escape.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/operators.h"
 #include "tools/gn/scope.h"
@@ -51,7 +52,8 @@
 std::tuple<base::StringPiece, base::StringPiece> SplitAtFirst(
     base::StringPiece str,
     char c) {
-  if (!str.starts_with("\"") || !str.ends_with("\""))
+  if (!base::StartsWith(str, "\"", base::CompareCase::SENSITIVE) ||
+      !base::EndsWith(str, "\"", base::CompareCase::SENSITIVE))
     return std::make_tuple(str, base::StringPiece());
 
   str = str.substr(1, str.length() - 2);
@@ -146,7 +148,7 @@
 }
 
 base::Value ParseNode::CreateJSONNode(const char* type,
-    const base::StringPiece& value) const {
+                                      const base::StringPiece& value) const {
   base::Value dict(base::Value::Type::DICTIONARY);
   dict.SetKey(kJsonNodeType, base::Value(type));
   dict.SetKey(kJsonNodeValue, base::Value(value));
@@ -305,7 +307,7 @@
   if (max_len == 0) {
     *err = Err(index_->GetRange(), "Array subscript out of range.",
                "You gave me " + base::Int64ToString(index_int) + " but the " +
-               "array has no elements.");
+                   "array has no elements.");
     return false;
   }
   size_t index_sizet = static_cast<size_t>(index_int);
@@ -806,7 +808,9 @@
       return Value(this, false);
     case Token::INTEGER: {
       base::StringPiece s = value_.value();
-      if ((s.starts_with("0") && s.size() > 1) || s.starts_with("-0")) {
+      if ((base::StartsWith(s, "0", base::CompareCase::SENSITIVE) &&
+           s.size() > 1) ||
+          base::StartsWith(s, "-0", base::CompareCase::SENSITIVE)) {
         if (s == "-0")
           *err = MakeErrorDescribing("Negative zero doesn't make sense");
         else
@@ -909,7 +913,7 @@
 
 base::Value BlockCommentNode::GetJSONNode() const {
   std::string escaped;
-  base::EscapeJSONString(comment_.value().as_string(), false, &escaped);
+  base::EscapeJSONString(std::string(comment_.value()), false, &escaped);
   return CreateJSONNode("BLOCK_COMMENT", escaped);
 }
 
diff --git a/tools/gn/parser.cc b/tools/gn/parser.cc
index 0065afd..ea498a4 100644
--- a/tools/gn/parser.cc
+++ b/tools/gn/parser.cc
@@ -435,8 +435,7 @@
   PrefixFunc prefix = expressions_[token.type()].prefix;
 
   if (prefix == nullptr) {
-    *err_ = Err(token, std::string("Unexpected token '") +
-                           token.value().as_string() + std::string("'"));
+    *err_ = Err(token, "Unexpected token '" + std::string(token.value()) + "'");
     return std::unique_ptr<ParseNode>();
   }
 
@@ -449,9 +448,8 @@
     const Token& next_token = Consume();
     InfixFunc infix = expressions_[next_token.type()].infix;
     if (infix == nullptr) {
-      *err_ = Err(next_token, std::string("Unexpected token '") +
-                                  next_token.value().as_string() +
-                                  std::string("'"));
+      *err_ = Err(next_token,
+                  "Unexpected token '" + std::string(next_token.value()) + "'");
       return std::unique_ptr<ParseNode>();
     }
     left = (this->*infix)(std::move(left), next_token);
@@ -521,7 +519,7 @@
   if (!right) {
     if (!has_error()) {
       *err_ = Err(token, "Expected right-hand side for '" +
-                             token.value().as_string() + "'");
+                             std::string(token.value()) + "'");
     }
     return std::unique_ptr<ParseNode>();
   }
@@ -899,8 +897,9 @@
   return std::string(value, ' ');
 }
 
-void RenderToText(const base::Value& node, int indent_level,
-    std::ostringstream& os) {
+void RenderToText(const base::Value& node,
+                  int indent_level,
+                  std::ostringstream& os) {
   const base::Value* child = node.FindKey(std::string("child"));
   std::string node_type(node.FindKey("type")->GetString());
   if (node_type == "ACCESSOR") {
@@ -908,7 +907,7 @@
     // for the base.
     os << IndentFor(indent_level) << node_type << std::endl;
     os << IndentFor(indent_level + 1) << node.FindKey("value")->GetString()
-        << std::endl;
+       << std::endl;
   } else {
     os << IndentFor(indent_level) << node_type;
     if (node.FindKey("value")) {
@@ -918,20 +917,20 @@
   }
   if (node.FindKey(kJsonBeforeComment)) {
     for (auto& v : node.FindKey(kJsonBeforeComment)->GetList()) {
-      os << IndentFor(indent_level + 1) <<
-          "+BEFORE_COMMENT(\"" << v.GetString() << "\")\n";
+      os << IndentFor(indent_level + 1) << "+BEFORE_COMMENT(\"" << v.GetString()
+         << "\")\n";
     }
   }
   if (node.FindKey(kJsonSuffixComment)) {
     for (auto& v : node.FindKey(kJsonSuffixComment)->GetList()) {
-      os << IndentFor(indent_level + 1) <<
-          "+SUFFIX_COMMENT(\"" << v.GetString() << "\")\n";
+      os << IndentFor(indent_level + 1) << "+SUFFIX_COMMENT(\"" << v.GetString()
+         << "\")\n";
     }
   }
   if (node.FindKey(kJsonAfterComment)) {
     for (auto& v : node.FindKey(kJsonAfterComment)->GetList()) {
-      os << IndentFor(indent_level + 1) <<
-          "+AFTER_COMMENT(\"" << v.GetString() << "\")\n";
+      os << IndentFor(indent_level + 1) << "+AFTER_COMMENT(\"" << v.GetString()
+         << "\")\n";
     }
   }
   if (child) {
diff --git a/tools/gn/rust_values_generator.cc b/tools/gn/rust_values_generator.cc
index 910d5af..c29282e 100644
--- a/tools/gn/rust_values_generator.cc
+++ b/tools/gn/rust_values_generator.cc
@@ -199,7 +199,7 @@
 
     // Insert into the aliased_deps map.
     target_->rust_values().aliased_deps().emplace(std::move(dep_label),
-                                                  pair.first.as_string());
+                                                  pair.first);
   }
 
   return true;
diff --git a/tools/gn/scope.cc b/tools/gn/scope.cc
index dd1a576..40d4a86 100644
--- a/tools/gn/scope.cc
+++ b/tools/gn/scope.cc
@@ -220,7 +220,7 @@
 void Scope::MarkAllUsed(const std::set<std::string>& excluded_values) {
   for (auto& cur : values_) {
     if (!excluded_values.empty() &&
-        excluded_values.find(cur.first.as_string()) != excluded_values.end()) {
+        excluded_values.find(std::string(cur.first)) != excluded_values.end()) {
       continue;  // Skip this excluded value.
     }
     cur.second.used = true;
@@ -250,7 +250,7 @@
   for (const auto& pair : values_) {
     if (!pair.second.used) {
       std::string help =
-          "You set the variable \"" + pair.first.as_string() +
+          "You set the variable \"" + std::string(pair.first) +
           "\" here and it was unused before it went\nout of scope.";
 
       const BinaryOpNode* binary = pair.second.value.origin()->AsBinaryOp();
@@ -302,7 +302,7 @@
     if (options.skip_private_vars && IsPrivateVar(current_name))
       continue;  // Skip this private var.
     if (!options.excluded_values.empty() &&
-        options.excluded_values.find(current_name.as_string()) !=
+        options.excluded_values.find(std::string(current_name)) !=
             options.excluded_values.end()) {
       continue;  // Skip this excluded value.
     }
@@ -315,7 +315,7 @@
         std::string desc_string(desc_for_err);
         *err = Err(node_for_err, "Value collision.",
                    "This " + desc_string + " contains \"" +
-                       current_name.as_string() + "\"");
+                       std::string(current_name) + "\"");
         err->AppendSubErr(
             Err(pair.second.value, "defined here.",
                 "Which would clobber the one in your current scope"));
diff --git a/tools/gn/scope.h b/tools/gn/scope.h
index 6c26cdb..f7d70ca 100644
--- a/tools/gn/scope.h
+++ b/tools/gn/scope.h
@@ -338,8 +338,7 @@
     Value value;
   };
 
-  typedef std::unordered_map<base::StringPiece, Record, base::StringPieceHash>
-      RecordMap;
+  using RecordMap = std::unordered_map<base::StringPiece, Record>;
 
   void AddProvider(ProgrammaticProvider* p);
   void RemoveProvider(ProgrammaticProvider* p);
diff --git a/tools/gn/string_utils.h b/tools/gn/string_utils.h
index 744714a..c77daca 100644
--- a/tools/gn/string_utils.h
+++ b/tools/gn/string_utils.h
@@ -5,6 +5,7 @@
 #ifndef TOOLS_GN_STRING_UTILS_H_
 #define TOOLS_GN_STRING_UTILS_H_
 
+#include <string>
 #include <vector>
 
 #include "base/strings/string_piece.h"
diff --git a/tools/gn/substitution_writer.cc b/tools/gn/substitution_writer.cc
index 41be9b4..8b884c6 100644
--- a/tools/gn/substitution_writer.cc
+++ b/tools/gn/substitution_writer.cc
@@ -354,7 +354,7 @@
       return source.value();
     to_rebase = source.value();
   } else if (type == &SubstitutionSourceNamePart) {
-    return FindFilenameNoExtension(&source.value()).as_string();
+    return std::string(FindFilenameNoExtension(&source.value()));
   } else if (type == &SubstitutionSourceFilePart) {
     return source.GetName();
   } else if (type == &SubstitutionSourceDir) {
diff --git a/tools/gn/value.cc b/tools/gn/value.cc
index a54db03..c8cde58 100644
--- a/tools/gn/value.cc
+++ b/tools/gn/value.cc
@@ -37,29 +37,19 @@
 }
 
 Value::Value(const ParseNode* origin, bool bool_val)
-    : type_(BOOLEAN),
-      boolean_value_(bool_val),
-      origin_(origin) {}
+    : type_(BOOLEAN), boolean_value_(bool_val), origin_(origin) {}
 
 Value::Value(const ParseNode* origin, int64_t int_val)
-    : type_(INTEGER),
-      int_value_(int_val),
-      origin_(origin) {}
+    : type_(INTEGER), int_value_(int_val), origin_(origin) {}
 
 Value::Value(const ParseNode* origin, std::string str_val)
-    : type_(STRING),
-      string_value_(std::move(str_val)),
-      origin_(origin) {}
+    : type_(STRING), string_value_(std::move(str_val)), origin_(origin) {}
 
 Value::Value(const ParseNode* origin, const char* str_val)
-    : type_(STRING),
-      string_value_(str_val),
-      origin_(origin) {}
+    : type_(STRING), string_value_(str_val), origin_(origin) {}
 
 Value::Value(const ParseNode* origin, std::unique_ptr<Scope> scope)
-    : type_(SCOPE),
-      scope_value_(std::move(scope)),
-      origin_(origin) {}
+    : type_(SCOPE), scope_value_(std::move(scope)), origin_(origin) {}
 
 Value::Value(const Value& other) : type_(other.type_), origin_(other.origin_) {
   switch (type_) {
@@ -217,7 +207,7 @@
 
       std::string result = "{\n";
       for (const auto& pair : scope_values) {
-        result += "  " + pair.first.as_string() + " = " +
+        result += "  " + std::string(pair.first) + " = " +
                   pair.second.ToString(true) + "\n";
       }
       result += "}";
diff --git a/tools/gn/visual_studio_writer.cc b/tools/gn/visual_studio_writer.cc
index 9d9aa21..217075b 100644
--- a/tools/gn/visual_studio_writer.cc
+++ b/tools/gn/visual_studio_writer.cc
@@ -700,7 +700,7 @@
       base::StringPiece filter_path = FindParentDir(&target_relative_path);
 
       if (!filter_path.empty()) {
-        std::string filter_path_str = filter_path.as_string();
+        std::string filter_path_str(filter_path);
         while (processed_filters.find(filter_path_str) ==
                processed_filters.end()) {
           auto it = processed_filters.insert(filter_path_str).first;
@@ -708,7 +708,7 @@
               ->SubElement("Filter", XmlAttributes("Include", filter_path_str))
               ->SubElement("UniqueIdentifier")
               ->Text(MakeGuid(filter_path_str, kGuidSeedFilter));
-          filter_path_str = FindParentDir(&(*it)).as_string();
+          filter_path_str = std::string(FindParentDir(&(*it)));
           if (filter_path_str.empty())
             break;
         }
@@ -815,9 +815,10 @@
     if (it != processed_paths.end()) {
       project->parent_folder = it->second;
     } else {
-      std::string folder_path_str = folder_path.as_string();
+      std::string folder_path_str(folder_path);
       std::unique_ptr<SolutionEntry> folder = std::make_unique<SolutionEntry>(
-          FindLastDirComponent(SourceDir(std::string(folder_path))).as_string(),
+          std::string(
+              FindLastDirComponent(SourceDir(std::string(folder_path)))),
           folder_path_str, MakeGuid(folder_path_str, kGuidSeedFolder));
       project->parent_folder = folder.get();
       processed_paths[folder_path] = folder.get();
@@ -863,10 +864,10 @@
       } else {
         std::unique_ptr<SolutionEntry> new_folder =
             std::make_unique<SolutionEntry>(
-                FindLastDirComponent(SourceDir(std::string(parent_path)))
-                    .as_string(),
-                parent_path.as_string(),
-                MakeGuid(parent_path.as_string(), kGuidSeedFolder));
+                std::string(
+                    FindLastDirComponent(SourceDir(std::string(parent_path)))),
+                std::string(parent_path),
+                MakeGuid(std::string(parent_path), kGuidSeedFolder));
         processed_paths[parent_path] = new_folder.get();
         folder = new_folder.get();
         additional_folders.push_back(std::move(new_folder));
diff --git a/tools/gn/xcode_object.cc b/tools/gn/xcode_object.cc
index bd5c440..248661a 100644
--- a/tools/gn/xcode_object.cc
+++ b/tools/gn/xcode_object.cc
@@ -560,8 +560,8 @@
   }
 
   if (!group) {
-    children_.push_back(std::make_unique<PBXGroup>(component.as_string(),
-                                                   component.as_string()));
+    children_.push_back(std::make_unique<PBXGroup>(std::string(component),
+                                                   std::string(component)));
     group = static_cast<PBXGroup*>(children_.back().get());
   }
 
diff --git a/tools/gn/xml_element_writer.h b/tools/gn/xml_element_writer.h
index 4aa5f7e..1f68a7d 100644
--- a/tools/gn/xml_element_writer.h
+++ b/tools/gn/xml_element_writer.h
@@ -5,8 +5,8 @@
 #ifndef TOOLS_GN_XML_ELEMENT_WRITER_H_
 #define TOOLS_GN_XML_ELEMENT_WRITER_H_
 
-#include <iosfwd>
 #include <memory>
+#include <ostream>
 #include <string>
 #include <utility>
 #include <vector>