diff --git a/common/platform/api/quiche_str_cat_test.cc b/common/platform/api/quiche_str_cat_test.cc
index 7085b8a..c9a5bfc 100644
--- a/common/platform/api/quiche_str_cat_test.cc
+++ b/common/platform/api/quiche_str_cat_test.cc
@@ -6,7 +6,7 @@
 
 #include <string>
 
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_test.h"
 
 namespace quiche {
@@ -46,7 +46,7 @@
 
   std::string strs[] = {"Hello", "Cruel", "World"};
 
-  QuicheStringPiece pieces[] = {"Hello", "Cruel", "World"};
+  absl::string_view pieces[] = {"Hello", "Cruel", "World"};
 
   const char* c_strs[] = {"Hello", "Cruel", "World"};
 
diff --git a/common/platform/api/quiche_text_utils.h b/common/platform/api/quiche_text_utils.h
index 2cf920f..0aab251 100644
--- a/common/platform/api/quiche_text_utils.h
+++ b/common/platform/api/quiche_text_utils.h
@@ -7,9 +7,9 @@
 
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_optional.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/quiche/common/platform/impl/quiche_text_utils_impl.h"
 
 namespace quiche {
@@ -18,55 +18,52 @@
 class QUICHE_EXPORT QuicheTextUtils {
  public:
   // Returns true if |data| starts with |prefix|, case sensitively.
-  static bool StartsWith(quiche::QuicheStringPiece data,
-                         quiche::QuicheStringPiece prefix) {
+  static bool StartsWith(absl::string_view data, absl::string_view prefix) {
     return quiche::QuicheTextUtilsImpl::StartsWith(data, prefix);
   }
 
   // Returns true if |data| ends with |suffix|, case sensitively.
-  static bool EndsWith(quiche::QuicheStringPiece data,
-                       quiche::QuicheStringPiece suffix) {
+  static bool EndsWith(absl::string_view data, absl::string_view suffix) {
     return quiche::QuicheTextUtilsImpl::EndsWith(data, suffix);
   }
 
   // Returns true if |data| ends with |suffix|, case insensitively.
-  static bool EndsWithIgnoreCase(quiche::QuicheStringPiece data,
-                                 quiche::QuicheStringPiece suffix) {
+  static bool EndsWithIgnoreCase(absl::string_view data,
+                                 absl::string_view suffix) {
     return quiche::QuicheTextUtilsImpl::EndsWithIgnoreCase(data, suffix);
   }
 
   // Returns a new string in which |data| has been converted to lower case.
-  static std::string ToLower(quiche::QuicheStringPiece data) {
+  static std::string ToLower(absl::string_view data) {
     return quiche::QuicheTextUtilsImpl::ToLower(data);
   }
 
   // Removes leading and trailing whitespace from |data|.
-  static void RemoveLeadingAndTrailingWhitespace(
-      quiche::QuicheStringPiece* data) {
+  static void RemoveLeadingAndTrailingWhitespace(absl::string_view* data) {
     quiche::QuicheTextUtilsImpl::RemoveLeadingAndTrailingWhitespace(data);
   }
 
   // Returns true if |in| represents a valid uint64, and stores that value in
   // |out|.
-  static bool StringToUint64(quiche::QuicheStringPiece in, uint64_t* out) {
+  static bool StringToUint64(absl::string_view in, uint64_t* out) {
     return quiche::QuicheTextUtilsImpl::StringToUint64(in, out);
   }
 
   // Returns true if |in| represents a valid int, and stores that value in
   // |out|.
-  static bool StringToInt(quiche::QuicheStringPiece in, int* out) {
+  static bool StringToInt(absl::string_view in, int* out) {
     return quiche::QuicheTextUtilsImpl::StringToInt(in, out);
   }
 
   // Returns true if |in| represents a valid uint32, and stores that value in
   // |out|.
-  static bool StringToUint32(quiche::QuicheStringPiece in, uint32_t* out) {
+  static bool StringToUint32(absl::string_view in, uint32_t* out) {
     return quiche::QuicheTextUtilsImpl::StringToUint32(in, out);
   }
 
   // Returns true if |in| represents a valid size_t, and stores that value in
   // |out|.
-  static bool StringToSizeT(quiche::QuicheStringPiece in, size_t* out) {
+  static bool StringToSizeT(absl::string_view in, size_t* out) {
     return quiche::QuicheTextUtilsImpl::StringToSizeT(in, out);
   }
 
@@ -79,13 +76,13 @@
   // hexadecimal representation.
   // Return value: 2*|length| characters of ASCII string.
   static std::string HexEncode(const char* data, size_t length) {
-    return HexEncode(quiche::QuicheStringPiece(data, length));
+    return HexEncode(absl::string_view(data, length));
   }
 
   // This converts |data.length()| bytes of binary to a
   // 2*|data.length()|-character hexadecimal representation.
   // Return value: 2*|data.length()| characters of ASCII string.
-  static std::string HexEncode(quiche::QuicheStringPiece data) {
+  static std::string HexEncode(absl::string_view data) {
     return quiche::QuicheTextUtilsImpl::HexEncode(data);
   }
 
@@ -97,7 +94,7 @@
 
   // Converts |data| from a hexadecimal ASCII string to a binary string
   // that is |data.length()/2| bytes long.
-  static std::string HexDecode(quiche::QuicheStringPiece data) {
+  static std::string HexDecode(absl::string_view data) {
     return quiche::QuicheTextUtilsImpl::HexDecode(data);
   }
 
@@ -110,7 +107,7 @@
 
   // Decodes a base64-encoded |input|.  Returns nullopt when the input is
   // invalid.
-  static QuicheOptional<std::string> Base64Decode(QuicheStringPiece input) {
+  static QuicheOptional<std::string> Base64Decode(absl::string_view input) {
     return quiche::QuicheTextUtilsImpl::Base64Decode(input);
   }
 
@@ -119,24 +116,23 @@
   // printed as '.' in the ASCII output.
   // For example, given the input "Hello, QUIC!\01\02\03\04", returns:
   // "0x0000:  4865 6c6c 6f2c 2051 5549 4321 0102 0304  Hello,.QUIC!...."
-  static std::string HexDump(quiche::QuicheStringPiece binary_data) {
+  static std::string HexDump(absl::string_view binary_data) {
     return quiche::QuicheTextUtilsImpl::HexDump(binary_data);
   }
 
   // Returns true if |data| contains any uppercase characters.
-  static bool ContainsUpperCase(quiche::QuicheStringPiece data) {
+  static bool ContainsUpperCase(absl::string_view data) {
     return quiche::QuicheTextUtilsImpl::ContainsUpperCase(data);
   }
 
   // Returns true if |data| contains only decimal digits.
-  static bool IsAllDigits(quiche::QuicheStringPiece data) {
+  static bool IsAllDigits(absl::string_view data) {
     return quiche::QuicheTextUtilsImpl::IsAllDigits(data);
   }
 
   // Splits |data| into a vector of pieces delimited by |delim|.
-  static std::vector<quiche::QuicheStringPiece> Split(
-      quiche::QuicheStringPiece data,
-      char delim) {
+  static std::vector<absl::string_view> Split(absl::string_view data,
+                                              char delim) {
     return quiche::QuicheTextUtilsImpl::Split(data, delim);
   }
 };
diff --git a/common/platform/api/quiche_text_utils_test.cc b/common/platform/api/quiche_text_utils_test.cc
index 1ca75d2..c2f302d 100644
--- a/common/platform/api/quiche_text_utils_test.cc
+++ b/common/platform/api/quiche_text_utils_test.cc
@@ -48,7 +48,7 @@
 
   for (auto* input : {"text", " text", "  text", "text ", "text  ", " text ",
                       "  text  ", "\r\n\ttext", "text\n\r\t"}) {
-    quiche::QuicheStringPiece piece(input);
+    absl::string_view piece(input);
     quiche::QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(&piece);
     EXPECT_EQ("text", piece);
   }
@@ -214,16 +214,16 @@
 }
 
 TEST_F(QuicheTextUtilsTest, Split) {
-  EXPECT_EQ(std::vector<quiche::QuicheStringPiece>({"a", "b", "c"}),
+  EXPECT_EQ(std::vector<absl::string_view>({"a", "b", "c"}),
             quiche::QuicheTextUtils::Split("a,b,c", ','));
-  EXPECT_EQ(std::vector<quiche::QuicheStringPiece>({"a", "b", "c"}),
+  EXPECT_EQ(std::vector<absl::string_view>({"a", "b", "c"}),
             quiche::QuicheTextUtils::Split("a:b:c", ':'));
-  EXPECT_EQ(std::vector<quiche::QuicheStringPiece>({"a:b:c"}),
+  EXPECT_EQ(std::vector<absl::string_view>({"a:b:c"}),
             quiche::QuicheTextUtils::Split("a:b:c", ','));
   // Leading and trailing whitespace is preserved.
-  EXPECT_EQ(std::vector<quiche::QuicheStringPiece>({"a", "b", "c"}),
+  EXPECT_EQ(std::vector<absl::string_view>({"a", "b", "c"}),
             quiche::QuicheTextUtils::Split("a,b,c", ','));
-  EXPECT_EQ(std::vector<quiche::QuicheStringPiece>({" a", "b ", " c "}),
+  EXPECT_EQ(std::vector<absl::string_view>({" a", "b ", " c "}),
             quiche::QuicheTextUtils::Split(" a:b : c ", ':'));
 }
 
diff --git a/common/quiche_data_reader.cc b/common/quiche_data_reader.cc
index 2242fea..9d76e05 100644
--- a/common/quiche_data_reader.cc
+++ b/common/quiche_data_reader.cc
@@ -6,15 +6,15 @@
 
 #include <cstring>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_logging.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 namespace quiche {
 
-QuicheDataReader::QuicheDataReader(quiche::QuicheStringPiece data)
+QuicheDataReader::QuicheDataReader(absl::string_view data)
     : QuicheDataReader(data.data(), data.length(), quiche::NETWORK_BYTE_ORDER) {
 }
 
@@ -77,7 +77,7 @@
   return true;
 }
 
-bool QuicheDataReader::ReadStringPiece16(quiche::QuicheStringPiece* result) {
+bool QuicheDataReader::ReadStringPiece16(absl::string_view* result) {
   // Read resultant length.
   uint16_t result_len;
   if (!ReadUInt16(&result_len)) {
@@ -88,7 +88,7 @@
   return ReadStringPiece(result, result_len);
 }
 
-bool QuicheDataReader::ReadStringPiece8(quiche::QuicheStringPiece* result) {
+bool QuicheDataReader::ReadStringPiece8(absl::string_view* result) {
   // Read resultant length.
   uint8_t result_len;
   if (!ReadUInt8(&result_len)) {
@@ -99,8 +99,7 @@
   return ReadStringPiece(result, result_len);
 }
 
-bool QuicheDataReader::ReadStringPiece(quiche::QuicheStringPiece* result,
-                                       size_t size) {
+bool QuicheDataReader::ReadStringPiece(absl::string_view* result, size_t size) {
   // Make sure that we have enough data to read.
   if (!CanRead(size)) {
     OnFailure();
@@ -108,7 +107,7 @@
   }
 
   // Set result.
-  *result = quiche::QuicheStringPiece(data_ + pos_, size);
+  *result = absl::string_view(data_ + pos_, size);
 
   // Iterate.
   pos_ += size;
@@ -121,7 +120,7 @@
 }
 
 bool QuicheDataReader::ReadDecimal64(size_t num_digits, uint64_t* result) {
-  quiche::QuicheStringPiece digits;
+  absl::string_view digits;
   if (!ReadStringPiece(&digits, num_digits)) {
     return false;
   }
@@ -129,22 +128,22 @@
   return QuicheTextUtils::StringToUint64(digits, result);
 }
 
-quiche::QuicheStringPiece QuicheDataReader::ReadRemainingPayload() {
-  quiche::QuicheStringPiece payload = PeekRemainingPayload();
+absl::string_view QuicheDataReader::ReadRemainingPayload() {
+  absl::string_view payload = PeekRemainingPayload();
   pos_ = len_;
   return payload;
 }
 
-quiche::QuicheStringPiece QuicheDataReader::PeekRemainingPayload() const {
-  return quiche::QuicheStringPiece(data_ + pos_, len_ - pos_);
+absl::string_view QuicheDataReader::PeekRemainingPayload() const {
+  return absl::string_view(data_ + pos_, len_ - pos_);
 }
 
-quiche::QuicheStringPiece QuicheDataReader::FullPayload() const {
-  return quiche::QuicheStringPiece(data_, len_);
+absl::string_view QuicheDataReader::FullPayload() const {
+  return absl::string_view(data_, len_);
 }
 
-quiche::QuicheStringPiece QuicheDataReader::PreviouslyReadPayload() const {
-  return quiche::QuicheStringPiece(data_, pos_);
+absl::string_view QuicheDataReader::PreviouslyReadPayload() const {
+  return absl::string_view(data_, pos_);
 }
 
 bool QuicheDataReader::ReadBytes(void* result, size_t size) {
diff --git a/common/quiche_data_reader.h b/common/quiche_data_reader.h
index f74f90d..f3911c5 100644
--- a/common/quiche_data_reader.h
+++ b/common/quiche_data_reader.h
@@ -9,10 +9,10 @@
 #include <cstdint>
 #include <limits>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_logging.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quiche {
 
@@ -30,7 +30,7 @@
  public:
   // Constructs a reader using NETWORK_BYTE_ORDER endianness.
   // Caller must provide an underlying buffer to work on.
-  explicit QuicheDataReader(quiche::QuicheStringPiece data);
+  explicit QuicheDataReader(absl::string_view data);
   // Constructs a reader using NETWORK_BYTE_ORDER endianness.
   // Caller must provide an underlying buffer to work on.
   QuicheDataReader(const char* data, const size_t len);
@@ -64,7 +64,7 @@
   //
   // Forwards the internal iterator on success.
   // Returns true on success, false otherwise.
-  bool ReadStringPiece16(quiche::QuicheStringPiece* result);
+  bool ReadStringPiece16(absl::string_view* result);
 
   // Reads a string prefixed with 8-bit length into the given output parameter.
   //
@@ -73,13 +73,13 @@
   //
   // Forwards the internal iterator on success.
   // Returns true on success, false otherwise.
-  bool ReadStringPiece8(quiche::QuicheStringPiece* result);
+  bool ReadStringPiece8(absl::string_view* result);
 
   // Reads a given number of bytes into the given buffer. The buffer
   // must be of adequate size.
   // Forwards the internal iterator on success.
   // Returns true on success, false otherwise.
-  bool ReadStringPiece(quiche::QuicheStringPiece* result, size_t size);
+  bool ReadStringPiece(absl::string_view* result, size_t size);
 
   // Reads tag represented as 32-bit unsigned integer into given output
   // parameter. Tags are in big endian on the wire (e.g., CHLO is
@@ -92,38 +92,38 @@
   // iterator on success, may forward it even in case of failure.
   bool ReadDecimal64(size_t num_digits, uint64_t* result);
 
-  // Returns the remaining payload as a quiche::QuicheStringPiece.
+  // Returns the remaining payload as a absl::string_view.
   //
   // NOTE: Does not copy but rather references strings in the underlying buffer.
   // This should be kept in mind when handling memory management!
   //
   // Forwards the internal iterator.
-  quiche::QuicheStringPiece ReadRemainingPayload();
+  absl::string_view ReadRemainingPayload();
 
-  // Returns the remaining payload as a quiche::QuicheStringPiece.
+  // Returns the remaining payload as a absl::string_view.
   //
   // NOTE: Does not copy but rather references strings in the underlying buffer.
   // This should be kept in mind when handling memory management!
   //
   // DOES NOT forward the internal iterator.
-  quiche::QuicheStringPiece PeekRemainingPayload() const;
+  absl::string_view PeekRemainingPayload() const;
 
-  // Returns the entire payload as a quiche::QuicheStringPiece.
+  // Returns the entire payload as a absl::string_view.
   //
   // NOTE: Does not copy but rather references strings in the underlying buffer.
   // This should be kept in mind when handling memory management!
   //
   // DOES NOT forward the internal iterator.
-  quiche::QuicheStringPiece FullPayload() const;
+  absl::string_view FullPayload() const;
 
   // Returns the part of the payload that has been already read as a
-  // quiche::QuicheStringPiece.
+  // absl::string_view.
   //
   // NOTE: Does not copy but rather references strings in the underlying buffer.
   // This should be kept in mind when handling memory management!
   //
   // DOES NOT forward the internal iterator.
-  quiche::QuicheStringPiece PreviouslyReadPayload() const;
+  absl::string_view PreviouslyReadPayload() const;
 
   // Reads a given number of bytes into the given buffer. The buffer
   // must be of adequate size.
diff --git a/common/quiche_data_writer.cc b/common/quiche_data_writer.cc
index 4488f72..d24a594 100644
--- a/common/quiche_data_writer.cc
+++ b/common/quiche_data_writer.cc
@@ -7,9 +7,9 @@
 #include <algorithm>
 #include <limits>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quiche {
 
@@ -65,7 +65,7 @@
                     num_bytes);
 }
 
-bool QuicheDataWriter::WriteStringPiece16(quiche::QuicheStringPiece val) {
+bool QuicheDataWriter::WriteStringPiece16(absl::string_view val) {
   if (val.size() > std::numeric_limits<uint16_t>::max()) {
     return false;
   }
@@ -75,7 +75,7 @@
   return WriteBytes(val.data(), val.size());
 }
 
-bool QuicheDataWriter::WriteStringPiece(quiche::QuicheStringPiece val) {
+bool QuicheDataWriter::WriteStringPiece(absl::string_view val) {
   return WriteBytes(val.data(), val.size());
 }
 
diff --git a/common/quiche_data_writer.h b/common/quiche_data_writer.h
index cded0fa..150657e 100644
--- a/common/quiche_data_writer.h
+++ b/common/quiche_data_writer.h
@@ -10,10 +10,10 @@
 #include <cstring>
 #include <limits>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_logging.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quiche {
 
@@ -54,8 +54,8 @@
   // correct byte order.
   bool WriteBytesToUInt64(size_t num_bytes, uint64_t value);
 
-  bool WriteStringPiece(quiche::QuicheStringPiece val);
-  bool WriteStringPiece16(quiche::QuicheStringPiece val);
+  bool WriteStringPiece(absl::string_view val);
+  bool WriteStringPiece16(absl::string_view val);
   bool WriteBytes(const void* data, size_t data_len);
   bool WriteRepeatedByte(uint8_t byte, size_t count);
   // Fills the remaining buffer with null characters.
diff --git a/common/quiche_data_writer_test.cc b/common/quiche_data_writer_test.cc
index 343e6ea..72ce2c9 100644
--- a/common/quiche_data_writer_test.cc
+++ b/common/quiche_data_writer_test.cc
@@ -7,10 +7,10 @@
 #include <cstdint>
 #include <cstring>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_test.h"
 #include "net/third_party/quiche/src/common/quiche_data_reader.h"
 #include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h"
@@ -386,43 +386,38 @@
   char expected_first_read[4] = {1, 2, 3, 4};
   char expected_remaining[12] = {5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
   QuicheDataReader reader(buffer, sizeof(buffer));
-  quiche::QuicheStringPiece previously_read_payload1 =
-      reader.PreviouslyReadPayload();
+  absl::string_view previously_read_payload1 = reader.PreviouslyReadPayload();
   EXPECT_TRUE(previously_read_payload1.empty());
   char first_read_buffer[4] = {};
   EXPECT_TRUE(reader.ReadBytes(first_read_buffer, sizeof(first_read_buffer)));
   test::CompareCharArraysWithHexError(
       "first read", first_read_buffer, sizeof(first_read_buffer),
       expected_first_read, sizeof(expected_first_read));
-  quiche::QuicheStringPiece peeked_remaining_payload =
-      reader.PeekRemainingPayload();
+  absl::string_view peeked_remaining_payload = reader.PeekRemainingPayload();
   test::CompareCharArraysWithHexError(
       "peeked_remaining_payload", peeked_remaining_payload.data(),
       peeked_remaining_payload.length(), expected_remaining,
       sizeof(expected_remaining));
-  quiche::QuicheStringPiece full_payload = reader.FullPayload();
+  absl::string_view full_payload = reader.FullPayload();
   test::CompareCharArraysWithHexError("full_payload", full_payload.data(),
                                       full_payload.length(), buffer,
                                       sizeof(buffer));
-  quiche::QuicheStringPiece previously_read_payload2 =
-      reader.PreviouslyReadPayload();
+  absl::string_view previously_read_payload2 = reader.PreviouslyReadPayload();
   test::CompareCharArraysWithHexError(
       "previously_read_payload2", previously_read_payload2.data(),
       previously_read_payload2.length(), first_read_buffer,
       sizeof(first_read_buffer));
-  quiche::QuicheStringPiece read_remaining_payload =
-      reader.ReadRemainingPayload();
+  absl::string_view read_remaining_payload = reader.ReadRemainingPayload();
   test::CompareCharArraysWithHexError(
       "read_remaining_payload", read_remaining_payload.data(),
       read_remaining_payload.length(), expected_remaining,
       sizeof(expected_remaining));
   EXPECT_TRUE(reader.IsDoneReading());
-  quiche::QuicheStringPiece full_payload2 = reader.FullPayload();
+  absl::string_view full_payload2 = reader.FullPayload();
   test::CompareCharArraysWithHexError("full_payload2", full_payload2.data(),
                                       full_payload2.length(), buffer,
                                       sizeof(buffer));
-  quiche::QuicheStringPiece previously_read_payload3 =
-      reader.PreviouslyReadPayload();
+  absl::string_view previously_read_payload3 = reader.PreviouslyReadPayload();
   test::CompareCharArraysWithHexError(
       "previously_read_payload3", previously_read_payload3.data(),
       previously_read_payload3.length(), buffer, sizeof(buffer));