diff --git a/base/json/json_parser.cc b/base/json/json_parser.cc
index 713f692..eac52a6 100644
--- a/base/json/json_parser.cc
+++ b/base/json/json_parser.cc
@@ -5,6 +5,7 @@
 #include "base/json/json_parser.h"
 
 #include <cmath>
+#include <string_view>
 #include <utility>
 #include <vector>
 
@@ -12,7 +13,6 @@
 #include "base/macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversion_utils.h"
@@ -68,7 +68,7 @@
 
 JSONParser::~JSONParser() = default;
 
-Optional<Value> JSONParser::Parse(StringPiece input) {
+Optional<Value> JSONParser::Parse(std::string_view input) {
   input_ = input;
   index_ = 0;
   line_number_ = 1;
@@ -163,30 +163,30 @@
 
 // JSONParser private //////////////////////////////////////////////////////////
 
-Optional<StringPiece> JSONParser::PeekChars(int count) {
+Optional<std::string_view> JSONParser::PeekChars(int count) {
   if (static_cast<size_t>(index_) + count > input_.length())
     return nullopt;
-  // Using StringPiece::substr() is significantly slower (according to
+  // Using std::string_view::substr() is significantly slower (according to
   // base_perftests) than constructing a substring manually.
-  return StringPiece(input_.data() + index_, count);
+  return std::string_view(input_.data() + index_, count);
 }
 
 Optional<char> JSONParser::PeekChar() {
-  Optional<StringPiece> chars = PeekChars(1);
+  Optional<std::string_view> chars = PeekChars(1);
   if (chars)
     return (*chars)[0];
   return nullopt;
 }
 
-Optional<StringPiece> JSONParser::ConsumeChars(int count) {
-  Optional<StringPiece> chars = PeekChars(count);
+Optional<std::string_view> JSONParser::ConsumeChars(int count) {
+  Optional<std::string_view> chars = PeekChars(count);
   if (chars)
     index_ += count;
   return chars;
 }
 
 Optional<char> JSONParser::ConsumeChar() {
-  Optional<StringPiece> chars = ConsumeChars(1);
+  Optional<std::string_view> chars = ConsumeChars(1);
   if (chars)
     return (*chars)[0];
   return nullopt;
@@ -268,7 +268,7 @@
 }
 
 bool JSONParser::EatComment() {
-  Optional<StringPiece> comment_start = ConsumeChars(2);
+  Optional<std::string_view> comment_start = ConsumeChars(2);
   if (!comment_start)
     return false;
 
@@ -444,7 +444,7 @@
     return false;
   }
 
-  // StringBuilder will internally build a StringPiece unless a UTF-16
+  // StringBuilder will internally build a std::string_view unless a UTF-16
   // conversion occurs, at which point it will perform a copy into a
   // std::string.
   StringBuilder string(pos());
@@ -475,12 +475,12 @@
     } else {
       // And if it is an escape sequence, the input string will be adjusted
       // (either by combining the two characters of an encoded escape sequence,
-      // or with a UTF conversion), so using StringPiece isn't possible -- force
-      // a conversion.
+      // or with a UTF conversion), so using std::string_view isn't possible --
+      // force a conversion.
       string.Convert();
 
       // Read past the escape '\' and ensure there's a character following.
-      Optional<StringPiece> escape_sequence = ConsumeChars(2);
+      Optional<std::string_view> escape_sequence = ConsumeChars(2);
       if (!escape_sequence) {
         ReportError(JSONReader::JSON_INVALID_ESCAPE, 0);
         return false;
@@ -558,7 +558,7 @@
 
 // Entry is at the first X in \uXXXX.
 bool JSONParser::DecodeUTF16(uint32_t* out_code_point) {
-  Optional<StringPiece> escape_sequence = ConsumeChars(4);
+  Optional<std::string_view> escape_sequence = ConsumeChars(4);
   if (!escape_sequence)
     return false;
 
@@ -671,7 +671,7 @@
 
   index_ = exit_index;
 
-  StringPiece num_string(num_start, end_index - start_index);
+  std::string_view num_string(num_start, end_index - start_index);
 
   int num_int;
   if (StringToInt(num_string, &num_int))
@@ -717,7 +717,7 @@
   }
 }
 
-bool JSONParser::ConsumeIfMatch(StringPiece match) {
+bool JSONParser::ConsumeIfMatch(std::string_view match) {
   if (match == PeekChars(match.size())) {
     ConsumeChars(match.size());
     return true;
diff --git a/base/json/json_parser.h b/base/json/json_parser.h
index 1289560..6bd61a4 100644
--- a/base/json/json_parser.h
+++ b/base/json/json_parser.h
@@ -10,13 +10,13 @@
 
 #include <memory>
 #include <string>
+#include <string_view>
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/json/json_reader.h"
 #include "base/macros.h"
 #include "base/optional.h"
-#include "base/strings/string_piece.h"
 
 namespace base {
 
@@ -49,7 +49,7 @@
   // result as a Value.
   // Wrap this in base::FooValue::From() to check the Value is of type Foo and
   // convert to a FooValue at the same time.
-  Optional<Value> Parse(StringPiece input);
+  Optional<Value> Parse(std::string_view input);
 
   // Returns the error code.
   JSONReader::JsonParseError error_code() const;
@@ -83,7 +83,7 @@
   };
 
   // A helper class used for parsing strings. One optimization performed is to
-  // create base::Value with a StringPiece to avoid unnecessary std::string
+  // create base::Value with a std::string_view to avoid unnecessary std::string
   // copies. This is not possible if the input string needs to be decoded from
   // UTF-16 to UTF-8, or if an escape sequence causes characters to be skipped.
   // This class centralizes that logic.
@@ -104,9 +104,9 @@
     // converted, or by appending the UTF8 bytes for the code point.
     void Append(uint32_t point);
 
-    // Converts the builder from its default StringPiece to a full std::string,
-    // performing a copy. Once a builder is converted, it cannot be made a
-    // StringPiece again.
+    // Converts the builder from its default std::string_view to a full
+    // std::string, performing a copy. Once a builder is converted, it cannot be
+    // made a std::string_view again.
     void Convert();
 
     // Returns the builder as a string, invalidating all state. This allows
@@ -128,14 +128,14 @@
 
   // Returns the next |count| bytes of the input stream, or nullopt if fewer
   // than |count| bytes remain.
-  Optional<StringPiece> PeekChars(int count);
+  Optional<std::string_view> PeekChars(int count);
 
   // Calls PeekChars() with a |count| of 1.
   Optional<char> PeekChar();
 
   // Returns the next |count| bytes of the input stream, or nullopt if fewer
   // than |count| bytes remain, and advances the parser position by |count|.
-  Optional<StringPiece> ConsumeChars(int count);
+  Optional<std::string_view> ConsumeChars(int count);
 
   // Calls ConsumeChars() with a |count| of 1.
   Optional<char> ConsumeChar();
@@ -198,7 +198,7 @@
   // consumed at the current parser position. Returns false if there are fewer
   // than |match|-length bytes or if the sequence does not match, and the
   // parser state is unchanged.
-  bool ConsumeIfMatch(StringPiece match);
+  bool ConsumeIfMatch(std::string_view match);
 
   // Sets the error information to |code| at the current column, based on
   // |index_| and |index_last_line_|, with an optional positive/negative
@@ -218,7 +218,7 @@
   const int max_depth_;
 
   // The input stream being parsed. Note: Not guaranteed to NUL-terminated.
-  StringPiece input_;
+  std::string_view input_;
 
   // The index in the input stream to which the parser is wound.
   int index_;
diff --git a/base/json/json_reader.cc b/base/json/json_reader.cc
index 3d5475e..d7eb7d9 100644
--- a/base/json/json_reader.cc
+++ b/base/json/json_reader.cc
@@ -41,7 +41,7 @@
 JSONReader::~JSONReader() = default;
 
 // static
-std::unique_ptr<Value> JSONReader::Read(StringPiece json,
+std::unique_ptr<Value> JSONReader::Read(std::string_view json,
                                         int options,
                                         int max_depth) {
   internal::JSONParser parser(options, max_depth);
@@ -51,7 +51,7 @@
 
 // static
 std::unique_ptr<Value> JSONReader::ReadAndReturnError(
-    StringPiece json,
+    std::string_view json,
     int options,
     int* error_code_out,
     std::string* error_msg_out,
@@ -103,7 +103,7 @@
   return std::string();
 }
 
-std::unique_ptr<Value> JSONReader::ReadToValue(StringPiece json) {
+std::unique_ptr<Value> JSONReader::ReadToValue(std::string_view json) {
   Optional<Value> value = parser_->Parse(json);
   return value ? std::make_unique<Value>(std::move(*value)) : nullptr;
 }
diff --git a/base/json/json_reader.h b/base/json/json_reader.h
index c4f7c8f..c454981 100644
--- a/base/json/json_reader.h
+++ b/base/json/json_reader.h
@@ -30,8 +30,7 @@
 
 #include <memory>
 #include <string>
-
-#include "base/strings/string_piece.h"
+#include <string_view>
 
 namespace base {
 
@@ -94,7 +93,7 @@
   // If |json| is not a properly formed JSON string, returns nullptr.
   // Wrap this in base::FooValue::From() to check the Value is of type Foo and
   // convert to a FooValue at the same time.
-  static std::unique_ptr<Value> Read(StringPiece json,
+  static std::unique_ptr<Value> Read(std::string_view json,
                                      int options = JSON_PARSE_RFC,
                                      int max_depth = kStackMaxDepth);
 
@@ -103,7 +102,7 @@
   // an error code and a formatted error message (including error location if
   // appropriate). Otherwise, they will be unmodified.
   static std::unique_ptr<Value> ReadAndReturnError(
-      StringPiece json,
+      std::string_view json,
       int options,  // JSONParserOptions
       int* error_code_out,
       std::string* error_msg_out,
@@ -115,7 +114,7 @@
   static std::string ErrorCodeToString(JsonParseError error_code);
 
   // Non-static version of Read() above.
-  std::unique_ptr<Value> ReadToValue(StringPiece json);
+  std::unique_ptr<Value> ReadToValue(std::string_view json);
 
   // Returns the error code if the last call to ReadToValue() failed.
   // Returns JSON_NO_ERROR otherwise.
diff --git a/base/json/json_value_converter.cc b/base/json/json_value_converter.cc
index 55506e6..ee7b094 100644
--- a/base/json/json_value_converter.cc
+++ b/base/json/json_value_converter.cc
@@ -17,8 +17,8 @@
   return value.GetAsString(field);
 }
 
-bool BasicValueConverter<string16>::Convert(const base::Value& value,
-                                            string16* field) const {
+bool BasicValueConverter<std::u16string>::Convert(const base::Value& value,
+                                                  std::u16string* field) const {
   return value.GetAsString(field);
 }
 
diff --git a/base/json/json_value_converter.h b/base/json/json_value_converter.h
index d91bead..f3030f2 100644
--- a/base/json/json_value_converter.h
+++ b/base/json/json_value_converter.h
@@ -9,13 +9,12 @@
 
 #include <memory>
 #include <string>
+#include <string_view>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
 #include "base/values.h"
 
 // JSONValueConverter converts a JSON value into a C++ struct in a
@@ -70,8 +69,8 @@
 //
 // Sometimes JSON format uses string representations for other types such
 // like enum, timestamp, or URL.  You can use RegisterCustomField method
-// and specify a function to convert a StringPiece to your type.
-//   bool ConvertFunc(StringPiece s, YourEnum* result) {
+// and specify a function to convert a std::string_view to your type.
+//   bool ConvertFunc(std::string_view s, YourEnum* result) {
 //     // do something and return true if succeed...
 //   }
 //   struct Message {
@@ -158,11 +157,12 @@
 };
 
 template <>
-class BasicValueConverter<string16> : public ValueConverter<string16> {
+class BasicValueConverter<std::u16string>
+    : public ValueConverter<std::u16string> {
  public:
   BasicValueConverter() = default;
 
-  bool Convert(const base::Value& value, string16* field) const override;
+  bool Convert(const base::Value& value, std::u16string* field) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BasicValueConverter);
@@ -211,7 +211,7 @@
 template <typename FieldType>
 class CustomFieldConverter : public ValueConverter<FieldType> {
  public:
-  typedef bool (*ConvertFunc)(StringPiece value, FieldType* field);
+  typedef bool (*ConvertFunc)(std::string_view value, FieldType* field);
 
   explicit CustomFieldConverter(ConvertFunc convert_func)
       : convert_func_(convert_func) {}
@@ -367,10 +367,11 @@
   }
 
   void RegisterStringField(const std::string& field_name,
-                           string16 StructType::*field) {
+                           std::u16string StructType::*field) {
     fields_.push_back(
-        std::make_unique<internal::FieldConverter<StructType, string16>>(
-            field_name, field, new internal::BasicValueConverter<string16>));
+        std::make_unique<internal::FieldConverter<StructType, std::u16string>>(
+            field_name, field,
+            new internal::BasicValueConverter<std::u16string>));
   }
 
   void RegisterBoolField(const std::string& field_name,
@@ -398,7 +399,7 @@
   template <typename FieldType>
   void RegisterCustomField(const std::string& field_name,
                            FieldType StructType::*field,
-                           bool (*convert_func)(StringPiece, FieldType*)) {
+                           bool (*convert_func)(std::string_view, FieldType*)) {
     fields_.push_back(
         std::make_unique<internal::FieldConverter<StructType, FieldType>>(
             field_name, field,
@@ -436,10 +437,12 @@
 
   void RegisterRepeatedString(
       const std::string& field_name,
-      std::vector<std::unique_ptr<string16>> StructType::*field) {
-    fields_.push_back(std::make_unique<internal::FieldConverter<
-                          StructType, std::vector<std::unique_ptr<string16>>>>(
-        field_name, field, new internal::RepeatedValueConverter<string16>));
+      std::vector<std::unique_ptr<std::u16string>> StructType::*field) {
+    fields_.push_back(
+        std::make_unique<internal::FieldConverter<
+            StructType, std::vector<std::unique_ptr<std::u16string>>>>(
+            field_name, field,
+            new internal::RepeatedValueConverter<std::u16string>));
   }
 
   void RegisterRepeatedDouble(
diff --git a/base/json/string_escape.cc b/base/json/string_escape.cc
index 471a9d3..ea674f5 100644
--- a/base/json/string_escape.cc
+++ b/base/json/string_escape.cc
@@ -116,38 +116,41 @@
 
 }  // namespace
 
-bool EscapeJSONString(StringPiece str, bool put_in_quotes, std::string* dest) {
-  return EscapeJSONStringImpl(str, put_in_quotes, dest);
-}
-
-bool EscapeJSONString(StringPiece16 str,
+bool EscapeJSONString(std::string_view str,
                       bool put_in_quotes,
                       std::string* dest) {
   return EscapeJSONStringImpl(str, put_in_quotes, dest);
 }
 
-std::string GetQuotedJSONString(StringPiece str) {
+bool EscapeJSONString(std::u16string_view str,
+                      bool put_in_quotes,
+                      std::string* dest) {
+  return EscapeJSONStringImpl(str, put_in_quotes, dest);
+}
+
+std::string GetQuotedJSONString(std::string_view str) {
   std::string dest;
   bool ok = EscapeJSONStringImpl(str, true, &dest);
   DCHECK(ok);
   return dest;
 }
 
-std::string GetQuotedJSONString(StringPiece16 str) {
+std::string GetQuotedJSONString(std::u16string_view str) {
   std::string dest;
   bool ok = EscapeJSONStringImpl(str, true, &dest);
   DCHECK(ok);
   return dest;
 }
 
-std::string EscapeBytesAsInvalidJSONString(StringPiece str,
+std::string EscapeBytesAsInvalidJSONString(std::string_view str,
                                            bool put_in_quotes) {
   std::string dest;
 
   if (put_in_quotes)
     dest.push_back('"');
 
-  for (StringPiece::const_iterator it = str.begin(); it != str.end(); ++it) {
+  for (std::string_view::const_iterator it = str.begin(); it != str.end();
+       ++it) {
     unsigned char c = *it;
     if (EscapeSpecialCodePoint(c, &dest))
       continue;
diff --git a/base/json/string_escape.h b/base/json/string_escape.h
index d318b6a..ada5179 100644
--- a/base/json/string_escape.h
+++ b/base/json/string_escape.h
@@ -8,8 +8,7 @@
 #define BASE_JSON_STRING_ESCAPE_H_
 
 #include <string>
-
-#include "base/strings/string_piece.h"
+#include <string_view>
 
 namespace base {
 
@@ -25,17 +24,21 @@
 //
 // If |put_in_quotes| is true, then a leading and trailing double-quote mark
 // will be appended to |dest| as well.
-bool EscapeJSONString(StringPiece str, bool put_in_quotes, std::string* dest);
+bool EscapeJSONString(std::string_view str,
+                      bool put_in_quotes,
+                      std::string* dest);
 
-// Performs a similar function to the UTF-8 StringPiece version above,
+// Performs a similar function to the UTF-8 std::string_view version above,
 // converting UTF-16 code units to UTF-8 code units and escaping non-printing
 // control characters. On return, |dest| will contain a valid UTF-8 JSON string.
-bool EscapeJSONString(StringPiece16 str, bool put_in_quotes, std::string* dest);
+bool EscapeJSONString(std::u16string_view str,
+                      bool put_in_quotes,
+                      std::string* dest);
 
 // Helper functions that wrap the above two functions but return the value
 // instead of appending. |put_in_quotes| is always true.
-std::string GetQuotedJSONString(StringPiece str);
-std::string GetQuotedJSONString(StringPiece16 str);
+std::string GetQuotedJSONString(std::string_view str);
+std::string GetQuotedJSONString(std::u16string_view str);
 
 // Given an arbitrary byte string |str|, this will escape all non-ASCII bytes
 // as \uXXXX escape sequences. This function is *NOT* meant to be used with
@@ -48,7 +51,8 @@
 //
 // The output of this function takes the *appearance* of JSON but is not in
 // fact valid according to RFC 4627.
-std::string EscapeBytesAsInvalidJSONString(StringPiece str, bool put_in_quotes);
+std::string EscapeBytesAsInvalidJSONString(std::string_view str,
+                                           bool put_in_quotes);
 
 }  // namespace base