diff --git a/quic/core/chlo_extractor.cc b/quic/core/chlo_extractor.cc
index 1605b26..53c3246 100644
--- a/quic/core/chlo_extractor.cc
+++ b/quic/core/chlo_extractor.cc
@@ -4,6 +4,7 @@
 
 #include "net/third_party/quiche/src/quic/core/chlo_extractor.h"
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake_message.h"
@@ -14,7 +15,6 @@
 #include "net/third_party/quiche/src/quic/core/frames/quic_ack_frequency_frame.h"
 #include "net/third_party/quiche/src/quic/core/quic_framer.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.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 quic {
@@ -39,10 +39,9 @@
       const QuicVersionNegotiationPacket& /*packet*/) override {}
   void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
                      QuicConnectionId /*new_connection_id*/,
-                     quiche::QuicheStringPiece /*retry_token*/,
-                     quiche::QuicheStringPiece /*retry_integrity_tag*/,
-                     quiche::QuicheStringPiece /*retry_without_tag*/) override {
-  }
+                     absl::string_view /*retry_token*/,
+                     absl::string_view /*retry_integrity_tag*/,
+                     absl::string_view /*retry_without_tag*/) override {}
   bool OnUnauthenticatedPublicHeader(const QuicPacketHeader& header) override;
   bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override;
   void OnDecryptedPacket(EncryptionLevel /*level*/) override {}
@@ -89,7 +88,7 @@
   void OnHandshakeMessage(const CryptoHandshakeMessage& message) override;
 
   // Shared implementation between OnStreamFrame and OnCryptoFrame.
-  bool OnHandshakeData(quiche::QuicheStringPiece data);
+  bool OnHandshakeData(absl::string_view data);
 
   bool found_chlo() { return found_chlo_; }
   bool chlo_contains_tags() { return chlo_contains_tags_; }
@@ -153,7 +152,7 @@
     // CHLO will be sent in CRYPTO frames in v47 and above.
     return false;
   }
-  quiche::QuicheStringPiece data(frame.data_buffer, frame.data_length);
+  absl::string_view data(frame.data_buffer, frame.data_length);
   if (QuicUtils::IsCryptoStreamId(framer_->transport_version(),
                                   frame.stream_id) &&
       frame.offset == 0 && quiche::QuicheTextUtils::StartsWith(data, "CHLO")) {
@@ -167,14 +166,14 @@
     // CHLO will be in stream frames before v47.
     return false;
   }
-  quiche::QuicheStringPiece data(frame.data_buffer, frame.data_length);
+  absl::string_view data(frame.data_buffer, frame.data_length);
   if (frame.offset == 0 && quiche::QuicheTextUtils::StartsWith(data, "CHLO")) {
     return OnHandshakeData(data);
   }
   return true;
 }
 
-bool ChloFramerVisitor::OnHandshakeData(quiche::QuicheStringPiece data) {
+bool ChloFramerVisitor::OnHandshakeData(absl::string_view data) {
   CryptoFramer crypto_framer;
   crypto_framer.set_visitor(this);
   if (!crypto_framer.ProcessInput(data)) {
diff --git a/quic/core/chlo_extractor_test.cc b/quic/core/chlo_extractor_test.cc
index 1b6a616..3c968be 100644
--- a/quic/core/chlo_extractor_test.cc
+++ b/quic/core/chlo_extractor_test.cc
@@ -8,6 +8,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_framer.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
@@ -15,7 +16,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/first_flight.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -33,7 +33,7 @@
     version_ = version;
     connection_id_ = connection_id;
     chlo_ = chlo.DebugString();
-    quiche::QuicheStringPiece alpn_value;
+    absl::string_view alpn_value;
     if (chlo.GetStringPiece(kALPN, &alpn_value)) {
       alpn_ = std::string(alpn_value);
     }
@@ -55,7 +55,7 @@
  public:
   ChloExtractorTest() : version_(GetParam()) {}
 
-  void MakePacket(quiche::QuicheStringPiece data,
+  void MakePacket(absl::string_view data,
                   bool munge_offset,
                   bool munge_stream_id) {
     QuicPacketHeader header;
diff --git a/quic/core/quic_bandwidth.cc b/quic/core/quic_bandwidth.cc
index ad2c032..144a176 100644
--- a/quic/core/quic_bandwidth.cc
+++ b/quic/core/quic_bandwidth.cc
@@ -7,8 +7,8 @@
 #include <cinttypes>
 #include <string>
 
+#include "absl/strings/string_view.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 quic {
 
diff --git a/quic/core/quic_config.cc b/quic/core/quic_config.cc
index 0d1cd27..5ea6b24 100644
--- a/quic/core/quic_config.cc
+++ b/quic/core/quic_config.cc
@@ -10,6 +10,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake_message.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
@@ -23,7 +24,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_macros.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_uint128.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -411,7 +411,7 @@
     const CryptoHandshakeMessage& peer_hello,
     HelloType /*hello_type*/,
     std::string* error_details) {
-  quiche::QuicheStringPiece address;
+  absl::string_view address;
   if (!peer_hello.GetStringPiece(tag_, &address)) {
     if (presence_ == PRESENCE_REQUIRED) {
       *error_details = "Missing " + QuicTagToString(tag_);
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index a2f32b6..00bfa6b 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -15,6 +15,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_utils.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
@@ -41,7 +42,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_string_utils.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 quic {
@@ -887,12 +887,11 @@
 }
 
 // Handles retry for client connection.
-void QuicConnection::OnRetryPacket(
-    QuicConnectionId original_connection_id,
-    QuicConnectionId new_connection_id,
-    quiche::QuicheStringPiece retry_token,
-    quiche::QuicheStringPiece retry_integrity_tag,
-    quiche::QuicheStringPiece retry_without_tag) {
+void QuicConnection::OnRetryPacket(QuicConnectionId original_connection_id,
+                                   QuicConnectionId new_connection_id,
+                                   absl::string_view retry_token,
+                                   absl::string_view retry_integrity_tag,
+                                   absl::string_view retry_without_tag) {
   DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
   if (version().HasRetryIntegrityTag()) {
     if (!CryptoUtils::ValidateRetryIntegrityTag(
@@ -1691,7 +1690,7 @@
   }
   MaybeUpdateAckTimeout();
   visitor_->OnMessageReceived(
-      quiche::QuicheStringPiece(frame.data, frame.message_length));
+      absl::string_view(frame.data, frame.message_length));
   return connected_;
 }
 
@@ -2197,8 +2196,8 @@
   }
   QUIC_DVLOG(2) << ENDPOINT << "Received encrypted " << packet.length()
                 << " bytes:" << std::endl
-                << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
-                       packet.data(), packet.length()));
+                << quiche::QuicheTextUtils::HexDump(
+                       absl::string_view(packet.data(), packet.length()));
   QUIC_BUG_IF(current_packet_data_ != nullptr)
       << "ProcessUdpPacket must not be called while processing a packet.";
   if (debug_visitor_ != nullptr) {
@@ -2718,7 +2717,7 @@
   QUIC_DVLOG(2) << ENDPOINT << packet->encryption_level << " packet number "
                 << packet_number << " of length " << encrypted_length << ": "
                 << std::endl
-                << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
+                << quiche::QuicheTextUtils::HexDump(absl::string_view(
                        packet->encrypted_buffer, encrypted_length));
 
   // Measure the RTT from before the write begins to avoid underestimating the
@@ -2817,8 +2816,8 @@
       QuicPacketLength encapsulated_length =
           QuicLegacyVersionEncapsulator::Encapsulate(
               legacy_version_encapsulation_sni_,
-              quiche::QuicheStringPiece(packet->encrypted_buffer,
-                                        packet->encrypted_length),
+              absl::string_view(packet->encrypted_buffer,
+                                packet->encrypted_length),
               server_connection_id_, framer_.creation_time(),
               GetLimitedMaxPacketSize(long_term_mtu_),
               const_cast<char*>(packet->encrypted_buffer));
@@ -2831,7 +2830,7 @@
             << "Successfully performed Legacy Version Encapsulation on "
             << packet->encryption_level << " packet number " << packet_number
             << " of length " << encrypted_length << ": " << std::endl
-            << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
+            << quiche::QuicheTextUtils::HexDump(absl::string_view(
                    packet->encrypted_buffer, encrypted_length));
       } else {
         QUIC_BUG << ENDPOINT
@@ -4134,9 +4133,9 @@
   QUIC_DVLOG(2) << ENDPOINT
                 << "Sending path probe packet for server connection ID "
                 << server_connection_id_ << std::endl
-                << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
-                       probing_packet->encrypted_buffer,
-                       probing_packet->encrypted_length));
+                << quiche::QuicheTextUtils::HexDump(
+                       absl::string_view(probing_packet->encrypted_buffer,
+                                         probing_packet->encrypted_length));
   WriteResult result = probing_writer->WritePacket(
       probing_packet->encrypted_buffer, probing_packet->encrypted_length,
       self_address().host(), peer_address, per_packet_options_);
@@ -4268,11 +4267,11 @@
   return uber_received_packet_manager_.IsAckFrameUpdated();
 }
 
-quiche::QuicheStringPiece QuicConnection::GetCurrentPacket() {
+absl::string_view QuicConnection::GetCurrentPacket() {
   if (current_packet_data_ == nullptr) {
-    return quiche::QuicheStringPiece();
+    return absl::string_view();
   }
-  return quiche::QuicheStringPiece(current_packet_data_, last_size_);
+  return absl::string_view(current_packet_data_, last_size_);
 }
 
 bool QuicConnection::MaybeConsiderAsMemoryCorruption(
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 06488e5..3c37fa7 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -11,6 +11,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/congestion_control/loss_detection_interface.h"
 #include "net/third_party/quiche/src/quic/core/congestion_control/send_algorithm_interface.h"
 #include "net/third_party/quiche/src/quic/core/crypto/null_decrypter.h"
@@ -42,7 +43,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/simple_session_notifier.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.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"
 
 using testing::_;
 using testing::AnyNumber;
@@ -116,9 +116,7 @@
   ~StrictTaggingDecrypter() override {}
 
   // TaggingQuicDecrypter
-  uint8_t GetTag(quiche::QuicheStringPiece /*ciphertext*/) override {
-    return tag_;
-  }
+  uint8_t GetTag(absl::string_view /*ciphertext*/) override { return tag_; }
 
   // Use a distinct value starting with 0xFFFFFF, which is never used by TLS.
   uint32_t cipher_id() const override { return 0xFFFFFFF1; }
@@ -252,7 +250,7 @@
   }
 
   QuicConsumedData SendStreamDataWithString(QuicStreamId id,
-                                            quiche::QuicheStringPiece data,
+                                            absl::string_view data,
                                             QuicStreamOffset offset,
                                             StreamSendingState state) {
     ScopedPacketFlusher flusher(this);
@@ -273,7 +271,7 @@
 
   QuicConsumedData SendApplicationDataAtLevel(EncryptionLevel encryption_level,
                                               QuicStreamId id,
-                                              quiche::QuicheStringPiece data,
+                                              absl::string_view data,
                                               QuicStreamOffset offset,
                                               StreamSendingState state) {
     ScopedPacketFlusher flusher(this);
@@ -310,7 +308,7 @@
   // tests for some cases for this stream.
   QuicConsumedData SendCryptoStreamData() {
     QuicStreamOffset offset = 0;
-    quiche::QuicheStringPiece data("chlo");
+    absl::string_view data("chlo");
     if (!QuicVersionUsesCryptoFrames(transport_version())) {
       return SendCryptoDataWithString(data, offset);
     }
@@ -326,12 +324,12 @@
     return QuicConsumedData(bytes_written, /*fin_consumed*/ false);
   }
 
-  QuicConsumedData SendCryptoDataWithString(quiche::QuicheStringPiece data,
+  QuicConsumedData SendCryptoDataWithString(absl::string_view data,
                                             QuicStreamOffset offset) {
     return SendCryptoDataWithString(data, offset, ENCRYPTION_INITIAL);
   }
 
-  QuicConsumedData SendCryptoDataWithString(quiche::QuicheStringPiece data,
+  QuicConsumedData SendCryptoDataWithString(absl::string_view data,
                                             QuicStreamOffset offset,
                                             EncryptionLevel encryption_level) {
     if (!QuicVersionUsesCryptoFrames(transport_version())) {
@@ -604,9 +602,9 @@
                     version()),
         creator_(QuicConnectionPeer::GetPacketCreator(&connection_)),
         manager_(QuicConnectionPeer::GetSentPacketManager(&connection_)),
-        frame1_(0, false, 0, quiche::QuicheStringPiece(data1)),
-        frame2_(0, false, 3, quiche::QuicheStringPiece(data2)),
-        crypto_frame_(ENCRYPTION_INITIAL, 0, quiche::QuicheStringPiece(data1)),
+        frame1_(0, false, 0, absl::string_view(data1)),
+        frame2_(0, false, 3, absl::string_view(data2)),
+        crypto_frame_(ENCRYPTION_INITIAL, 0, absl::string_view(data1)),
         packet_number_length_(PACKET_4BYTE_PACKET_NUMBER),
         connection_id_included_(CONNECTION_ID_PRESENT),
         notifier_(&connection_),
@@ -750,7 +748,7 @@
     }
     return QuicFrame(QuicStreamFrame(
         QuicUtils::GetCryptoStreamId(connection_.transport_version()), false,
-        0u, quiche::QuicheStringPiece()));
+        0u, absl::string_view()));
   }
 
   void ProcessFramePacket(QuicFrame frame) {
@@ -1006,7 +1004,7 @@
   }
 
   QuicByteCount SendStreamDataToPeer(QuicStreamId id,
-                                     quiche::QuicheStringPiece data,
+                                     absl::string_view data,
                                      QuicStreamOffset offset,
                                      StreamSendingState state,
                                      QuicPacketNumber* last_packet) {
@@ -1043,7 +1041,7 @@
 
   void SendPing() { notifier_.WriteOrBufferPing(); }
 
-  MessageStatus SendMessage(quiche::QuicheStringPiece message) {
+  MessageStatus SendMessage(absl::string_view message) {
     connection_.SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
     QuicMemSliceStorage storage(nullptr, 0, nullptr, 0);
     return connection_.SendMessage(
@@ -3123,7 +3121,7 @@
   QuicStreamFrame* frame = writer_->stream_frames()[0].get();
   EXPECT_EQ(stream_id, frame->stream_id);
   EXPECT_EQ("ABCDEF",
-            quiche::QuicheStringPiece(frame->data_buffer, frame->data_length));
+            absl::string_view(frame->data_buffer, frame->data_length));
 }
 
 TEST_P(QuicConnectionTest, FramePackingSendvQueued) {
@@ -8254,7 +8252,7 @@
     connection_.SetFromConfig(config);
   }
   std::string message(connection_.GetCurrentLargestMessagePayload() * 2, 'a');
-  quiche::QuicheStringPiece message_data(message);
+  absl::string_view message_data(message);
   QuicMemSliceStorage storage(nullptr, 0, nullptr, 0);
   {
     QuicConnection::ScopedPacketFlusher flusher(&connection_);
@@ -8267,7 +8265,7 @@
               connection_.SendMessage(
                   1,
                   MakeSpan(connection_.helper()->GetStreamSendBufferAllocator(),
-                           quiche::QuicheStringPiece(
+                           absl::string_view(
                                message_data.data(),
                                connection_.GetCurrentLargestMessagePayload()),
                            &storage),
@@ -8288,7 +8286,7 @@
             connection_.SendMessage(
                 3,
                 MakeSpan(connection_.helper()->GetStreamSendBufferAllocator(),
-                         quiche::QuicheStringPiece(
+                         absl::string_view(
                              message_data.data(),
                              connection_.GetCurrentLargestMessagePayload() + 1),
                          &storage),
@@ -10305,7 +10303,7 @@
   frames.push_back(QuicFrame(QuicStreamFrame(
       QuicUtils::GetFirstBidirectionalStreamId(
           connection_.version().transport_version, Perspective::IS_CLIENT),
-      false, 0u, quiche::QuicheStringPiece())));
+      false, 0u, absl::string_view())));
   QuicAckFrame ack_frame = InitAckFrame(1);
   frames.push_back(QuicFrame(&ack_frame));
   // Receiving stream frame causes something to send.
@@ -11044,7 +11042,7 @@
   frames.push_back(QuicFrame(&ack_frame));
   frames.push_back(QuicFrame(QuicStreamFrame(
       GetNthClientInitiatedStreamId(0, connection_.transport_version()), true,
-      0u, quiche::QuicheStringPiece())));
+      0u, absl::string_view())));
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
@@ -11767,7 +11765,7 @@
   frames1.push_back(QuicFrame(&crypto_frame_));
   QuicFrames frames2;
   QuicCryptoFrame crypto_frame(ENCRYPTION_HANDSHAKE, 0,
-                               quiche::QuicheStringPiece(data1));
+                               absl::string_view(data1));
   frames2.push_back(QuicFrame(&crypto_frame));
   ProcessCoalescedPacket(
       {{2, frames1, ENCRYPTION_INITIAL}, {3, frames2, ENCRYPTION_HANDSHAKE}});
@@ -11798,7 +11796,7 @@
 
   QuicFrames frames2;
   QuicCryptoFrame crypto_frame(ENCRYPTION_HANDSHAKE, 0,
-                               quiche::QuicheStringPiece(data1));
+                               absl::string_view(data1));
   frames2.push_back(QuicFrame(&crypto_frame));
   EXPECT_CALL(debug_visitor, OnZeroRttPacketAcked()).Times(0);
   EXPECT_CALL(visitor_, OnCryptoFrame(_)).Times(1);
diff --git a/quic/core/quic_crypto_client_handshaker_test.cc b/quic/core/quic_crypto_client_handshaker_test.cc
index 3ea08a5..cfae506 100644
--- a/quic/core/quic_crypto_client_handshaker_test.cc
+++ b/quic/core/quic_crypto_client_handshaker_test.cc
@@ -6,10 +6,10 @@
 
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/proto/crypto_server_config_proto.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace {
@@ -34,7 +34,7 @@
       const uint16_t /*port*/,
       const std::string& /*server_config*/,
       QuicTransportVersion /*transport_version*/,
-      quiche::QuicheStringPiece /*chlo_hash*/,
+      absl::string_view /*chlo_hash*/,
       const std::vector<std::string>& /*certs*/,
       const std::string& /*cert_sct*/,
       const std::string& /*signature*/,
@@ -74,7 +74,7 @@
                 const std::string& hostname,
                 const std::string& /*server_config*/,
                 QuicTransportVersion /*transport_version*/,
-                quiche::QuicheStringPiece /*chlo_hash*/,
+                absl::string_view /*chlo_hash*/,
                 std::unique_ptr<Callback> callback) override {
     QuicReferenceCountedPointer<ProofSource::Chain> chain =
         GetCertChain(server_address, client_address, hostname);
@@ -99,7 +99,7 @@
       const QuicSocketAddress& /*client_address*/,
       const std::string& /*hostname*/,
       uint16_t /*signature_algorit*/,
-      quiche::QuicheStringPiece /*in*/,
+      absl::string_view /*in*/,
       std::unique_ptr<SignatureCallback> callback) override {
     callback->Run(true, "Dummy signature", /*details=*/nullptr);
   }
diff --git a/quic/core/quic_crypto_server_stream.cc b/quic/core/quic_crypto_server_stream.cc
index 5fc6839..e8f99eb 100644
--- a/quic/core/quic_crypto_server_stream.cc
+++ b/quic/core/quic_crypto_server_stream.cc
@@ -7,10 +7,10 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/sha.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.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 quic {
@@ -286,8 +286,8 @@
                 << message.DebugString();
   if (!QuicVersionUsesCryptoFrames(transport_version())) {
     const QuicData& data = message.GetSerialized();
-    WriteOrBufferData(quiche::QuicheStringPiece(data.data(), data.length()),
-                      false, nullptr);
+    WriteOrBufferData(absl::string_view(data.data(), data.length()), false,
+                      nullptr);
   } else {
     SendHandshakeMessage(message);
   }
@@ -418,7 +418,7 @@
     return;
   }
 
-  quiche::QuicheStringPiece user_agent_id;
+  absl::string_view user_agent_id;
   message.GetStringPiece(quic::kUAID, &user_agent_id);
   if (!session()->user_agent_id().has_value() && !user_agent_id.empty()) {
     session()->SetUserAgentId(std::string(user_agent_id));
@@ -430,7 +430,7 @@
 
   if (num_handshake_messages_ == 1) {
     // Client attempts zero RTT handshake by sending a non-inchoate CHLO.
-    quiche::QuicheStringPiece public_value;
+    absl::string_view public_value;
     zero_rtt_attempted_ = message.GetStringPiece(kPUBS, &public_value);
   }
 
diff --git a/quic/core/quic_crypto_server_stream_test.cc b/quic/core/quic_crypto_server_stream_test.cc
index 9ff7dc0..2831dc0 100644
--- a/quic/core/quic_crypto_server_stream_test.cc
+++ b/quic/core/quic_crypto_server_stream_test.cc
@@ -9,6 +9,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/aes_128_gcm_12_encrypter.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
@@ -32,7 +33,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/fake_proof_source.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_crypto_server_config_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 class QuicConnection;
@@ -96,7 +96,7 @@
         .Times(testing::AnyNumber());
     EXPECT_CALL(*server_session_, SelectAlpn(_))
         .WillRepeatedly(
-            [this](const std::vector<quiche::QuicheStringPiece>& alpns) {
+            [this](const std::vector<absl::string_view>& alpns) {
               return std::find(
                   alpns.cbegin(), alpns.cend(),
                   AlpnForVersion(server_session_->connection()->version()));
diff --git a/quic/core/quic_crypto_stream.cc b/quic/core/quic_crypto_stream.cc
index ae2f067..6d41f0e 100644
--- a/quic/core/quic_crypto_stream.cc
+++ b/quic/core/quic_crypto_stream.cc
@@ -6,6 +6,7 @@
 
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_utils.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection.h"
@@ -16,7 +17,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.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"
 
 namespace quic {
 
@@ -108,8 +108,7 @@
     EncryptionLevel level) {
   struct iovec iov;
   while (sequencer->GetReadableRegion(&iov)) {
-    quiche::QuicheStringPiece data(static_cast<char*>(iov.iov_base),
-                                   iov.iov_len);
+    absl::string_view data(static_cast<char*>(iov.iov_base), iov.iov_len);
     if (!crypto_message_parser()->ProcessInput(data, level)) {
       OnUnrecoverableError(crypto_message_parser()->error(),
                            crypto_message_parser()->error_detail());
@@ -126,8 +125,8 @@
   }
 }
 
-bool QuicCryptoStream::ExportKeyingMaterial(quiche::QuicheStringPiece label,
-                                            quiche::QuicheStringPiece context,
+bool QuicCryptoStream::ExportKeyingMaterial(absl::string_view label,
+                                            absl::string_view context,
                                             size_t result_len,
                                             std::string* result) const {
   if (!one_rtt_keys_available()) {
@@ -141,7 +140,7 @@
 }
 
 void QuicCryptoStream::WriteCryptoData(EncryptionLevel level,
-                                       quiche::QuicheStringPiece data) {
+                                       absl::string_view data) {
   if (!QuicVersionUsesCryptoFrames(session()->transport_version())) {
     // The QUIC crypto handshake takes care of setting the appropriate
     // encryption level before writing data. Since that is the only handshake
diff --git a/quic/core/quic_crypto_stream.h b/quic/core/quic_crypto_stream.h
index d73d970..21bdde6 100644
--- a/quic/core/quic_crypto_stream.h
+++ b/quic/core/quic_crypto_stream.h
@@ -9,6 +9,7 @@
 #include <cstddef>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_utils.h"
@@ -17,7 +18,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_stream.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -64,14 +64,13 @@
   // dependent on |label|, |context|, and the stream's negotiated subkey secret.
   // Returns false if the handshake has not been confirmed or the parameters are
   // invalid (e.g. |label| contains null bytes); returns true on success.
-  bool ExportKeyingMaterial(quiche::QuicheStringPiece label,
-                            quiche::QuicheStringPiece context,
+  bool ExportKeyingMaterial(absl::string_view label,
+                            absl::string_view context,
                             size_t result_len,
                             std::string* result) const;
 
   // Writes |data| to the QuicStream at level |level|.
-  virtual void WriteCryptoData(EncryptionLevel level,
-                               quiche::QuicheStringPiece data);
+  virtual void WriteCryptoData(EncryptionLevel level, absl::string_view data);
 
   // Returns the ssl_early_data_reason_t describing why 0-RTT was accepted or
   // rejected. Note that the value returned by this function may vary during the
diff --git a/quic/core/quic_data_reader.cc b/quic/core/quic_data_reader.cc
index c82e051..572845d 100644
--- a/quic/core/quic_data_reader.cc
+++ b/quic/core/quic_data_reader.cc
@@ -4,17 +4,17 @@
 
 #include "net/third_party/quiche/src/quic/core/quic_data_reader.h"
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.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 quic {
 
-QuicDataReader::QuicDataReader(quiche::QuicheStringPiece data)
+QuicDataReader::QuicDataReader(absl::string_view data)
     : quiche::QuicheDataReader(data) {}
 
 QuicDataReader::QuicDataReader(const char* data, const size_t len)
@@ -165,8 +165,7 @@
   return false;
 }
 
-bool QuicDataReader::ReadStringPieceVarInt62(
-    quiche::QuicheStringPiece* result) {
+bool QuicDataReader::ReadStringPieceVarInt62(absl::string_view* result) {
   uint64_t result_length;
   if (!ReadVarInt62(&result_length)) {
     return false;
diff --git a/quic/core/quic_data_reader.h b/quic/core/quic_data_reader.h
index 13499ea..dd613b0 100644
--- a/quic/core/quic_data_reader.h
+++ b/quic/core/quic_data_reader.h
@@ -8,10 +8,10 @@
 #include <cstddef>
 #include <cstdint>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/common/quiche_data_reader.h"
 
 namespace quic {
@@ -34,7 +34,7 @@
  public:
   // Constructs a reader using NETWORK_BYTE_ORDER endianness.
   // Caller must provide an underlying buffer to work on.
-  explicit QuicDataReader(quiche::QuicheStringPiece data);
+  explicit QuicDataReader(absl::string_view data);
   // Constructs a reader using NETWORK_BYTE_ORDER endianness.
   // Caller must provide an underlying buffer to work on.
   QuicDataReader(const char* data, const size_t len);
@@ -85,7 +85,7 @@
   //
   // Forwards the internal iterator on success.
   // Returns true on success, false otherwise.
-  bool ReadStringPieceVarInt62(quiche::QuicheStringPiece* result);
+  bool ReadStringPieceVarInt62(absl::string_view* result);
 };
 
 }  // namespace quic
diff --git a/quic/core/quic_data_writer.cc b/quic/core/quic_data_writer.cc
index 41c374c..3603984 100644
--- a/quic/core/quic_data_writer.cc
+++ b/quic/core/quic_data_writer.cc
@@ -7,13 +7,13 @@
 #include <algorithm>
 #include <limits>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
 #include "net/third_party/quiche/src/quic/core/quic_constants.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.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 quic {
 
@@ -234,7 +234,7 @@
 }
 
 bool QuicDataWriter::WriteStringPieceVarInt62(
-    const quiche::QuicheStringPiece& string_piece) {
+    const absl::string_view& string_piece) {
   if (!WriteVarInt62(string_piece.size())) {
     return false;
   }
diff --git a/quic/core/quic_data_writer.h b/quic/core/quic_data_writer.h
index 3926c1a..4296b21 100644
--- a/quic/core/quic_data_writer.h
+++ b/quic/core/quic_data_writer.h
@@ -8,10 +8,10 @@
 #include <cstddef>
 #include <cstdint>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/common/quiche_data_writer.h"
 
 namespace quic {
@@ -69,7 +69,7 @@
 
   // Writes a string piece as a consecutive length/content pair. The
   // length is VarInt62 encoded.
-  bool WriteStringPieceVarInt62(const quiche::QuicheStringPiece& string_piece);
+  bool WriteStringPieceVarInt62(const absl::string_view& string_piece);
 
   // Utility function to return the number of bytes needed to encode
   // the given value using IETF VarInt62 encoding. Returns the number
diff --git a/quic/core/quic_data_writer_test.cc b/quic/core/quic_data_writer_test.cc
index e05af21..1aa4f3f 100644
--- a/quic/core/quic_data_writer_test.cc
+++ b/quic/core/quic_data_writer_test.cc
@@ -7,6 +7,7 @@
 #include <cstdint>
 #include <cstring>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
 #include "net/third_party/quiche/src/quic/core/quic_data_reader.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
@@ -18,7 +19,6 @@
 #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/test_tools/quiche_test_utils.h"
 
 namespace quic {
@@ -1227,24 +1227,22 @@
   quiche::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();
   quiche::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();
   quiche::test::CompareCharArraysWithHexError(
       "full_payload", full_payload.data(), full_payload.length(), buffer,
       sizeof(buffer));
-  quiche::QuicheStringPiece read_remaining_payload =
-      reader.ReadRemainingPayload();
+  absl::string_view read_remaining_payload = reader.ReadRemainingPayload();
   quiche::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();
   quiche::test::CompareCharArraysWithHexError(
       "full_payload2", full_payload2.data(), full_payload2.length(), buffer,
       sizeof(buffer));
@@ -1253,14 +1251,13 @@
 TEST_P(QuicDataWriterTest, StringPieceVarInt62) {
   char inner_buffer[16] = {1, 2,  3,  4,  5,  6,  7,  8,
                            9, 10, 11, 12, 13, 14, 15, 16};
-  quiche::QuicheStringPiece inner_payload_write(inner_buffer,
-                                                sizeof(inner_buffer));
+  absl::string_view inner_payload_write(inner_buffer, sizeof(inner_buffer));
   char buffer[sizeof(inner_buffer) + sizeof(uint8_t)] = {};
   QuicDataWriter writer(sizeof(buffer), buffer);
   EXPECT_TRUE(writer.WriteStringPieceVarInt62(inner_payload_write));
   EXPECT_EQ(0u, writer.remaining());
   QuicDataReader reader(buffer, sizeof(buffer));
-  quiche::QuicheStringPiece inner_payload_read;
+  absl::string_view inner_payload_read;
   EXPECT_TRUE(reader.ReadStringPieceVarInt62(&inner_payload_read));
   quiche::test::CompareCharArraysWithHexError(
       "inner_payload", inner_payload_write.data(), inner_payload_write.length(),
diff --git a/quic/core/quic_datagram_queue_test.cc b/quic/core/quic_datagram_queue_test.cc
index 34ccccc..fb31e30 100644
--- a/quic/core/quic_datagram_queue_test.cc
+++ b/quic/core/quic_datagram_queue_test.cc
@@ -4,6 +4,7 @@
 
 #include "net/third_party/quiche/src/quic/core/quic_datagram_queue.h"
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_buffer_allocator.h"
 #include "net/third_party/quiche/src/quic/core/quic_time.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
@@ -11,7 +12,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.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"
 
 namespace quic {
 namespace test {
@@ -41,7 +41,7 @@
     session_.SetCryptoStream(new EstablishedCryptoStream(&session_));
   }
 
-  QuicMemSlice CreateMemSlice(quiche::QuicheStringPiece data) {
+  QuicMemSlice CreateMemSlice(absl::string_view data) {
     QuicUniqueBufferPtr buffer =
         MakeUniqueBuffer(helper_.GetStreamSendBufferAllocator(), data.size());
     memcpy(buffer.get(), data.data(), data.size());
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index 972a9ac..ac40b0a 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -7,6 +7,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/chlo_extractor.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
@@ -22,7 +23,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_stack_trace.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 quic {
@@ -190,12 +190,12 @@
   void OnChlo(QuicTransportVersion version,
               QuicConnectionId /*server_connection_id*/,
               const CryptoHandshakeMessage& chlo) override {
-    quiche::QuicheStringPiece alpn_value;
+    absl::string_view alpn_value;
     if (chlo.GetStringPiece(kALPN, &alpn_value)) {
       alpn_ = std::string(alpn_value);
     }
     if (version == LegacyVersionForEncapsulation().transport_version) {
-      quiche::QuicheStringPiece qlve_value;
+      absl::string_view qlve_value;
       if (chlo.GetStringPiece(kQLVE, &qlve_value)) {
         legacy_version_encapsulation_inner_packet_ = std::string(qlve_value);
       }
@@ -231,7 +231,7 @@
   ParsedQuicVersion parsed_version = ParsedQuicVersion::Unsupported();
   QuicConnectionId destination_connection_id, source_connection_id;
   bool retry_token_present;
-  quiche::QuicheStringPiece retry_token;
+  absl::string_view retry_token;
   std::string detailed_error;
   const QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
       QuicEncryptedPacket(legacy_version_encapsulation_inner_packet.data(),
@@ -338,12 +338,12 @@
                                    const QuicReceivedPacket& packet) {
   QUIC_DVLOG(2) << "Dispatcher received encrypted " << packet.length()
                 << " bytes:" << std::endl
-                << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
-                       packet.data(), packet.length()));
+                << quiche::QuicheTextUtils::HexDump(
+                       absl::string_view(packet.data(), packet.length()));
   ReceivedPacketInfo packet_info(self_address, peer_address, packet);
   std::string detailed_error;
   bool retry_token_present;
-  quiche::QuicheStringPiece retry_token;
+  absl::string_view retry_token;
   const QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
       packet, expected_server_connection_id_length_, &packet_info.form,
       &packet_info.long_packet_type, &packet_info.version_flag,
diff --git a/quic/core/quic_dispatcher.h b/quic/core/quic_dispatcher.h
index e4c61e5..cdc4edc 100644
--- a/quic/core/quic_dispatcher.h
+++ b/quic/core/quic_dispatcher.h
@@ -12,6 +12,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_compressed_certs_cache.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
 #include "net/third_party/quiche/src/quic/core/quic_blocked_writer_interface.h"
@@ -25,7 +26,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_version_manager.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -140,7 +140,7 @@
       QuicConnectionId server_connection_id,
       const QuicSocketAddress& self_address,
       const QuicSocketAddress& peer_address,
-      quiche::QuicheStringPiece alpn,
+      absl::string_view alpn,
       const ParsedQuicVersion& version) = 0;
 
   // Tries to validate and dispatch packet based on available information.
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index ae0d594..db1020e 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -135,7 +135,7 @@
               (QuicConnectionId connection_id,
                const QuicSocketAddress& self_address,
                const QuicSocketAddress& peer_address,
-               quiche::QuicheStringPiece alpn,
+               absl::string_view alpn,
                const quic::ParsedQuicVersion& version),
               (override));
 
@@ -605,7 +605,7 @@
   ParsedQuicVersion parsed_version = ParsedQuicVersion::Unsupported();
   QuicConnectionId destination_connection_id, source_connection_id;
   bool retry_token_present;
-  quiche::QuicheStringPiece retry_token;
+  absl::string_view retry_token;
   std::string detailed_error;
   const QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
       QuicEncryptedPacket(packets[0]->data(), packets[0]->length()),
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index cbf1959..6b9f0c1 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -11,6 +11,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake_message.h"
@@ -45,7 +46,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_stack_trace.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.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 quic {
@@ -295,14 +295,14 @@
   return NUM_ENCRYPTION_LEVELS;
 }
 
-quiche::QuicheStringPiece TruncateErrorString(quiche::QuicheStringPiece error) {
+absl::string_view TruncateErrorString(absl::string_view error) {
   if (error.length() <= kMaxErrorStringLength) {
     return error;
   }
-  return quiche::QuicheStringPiece(error.data(), kMaxErrorStringLength);
+  return absl::string_view(error.data(), kMaxErrorStringLength);
 }
 
-size_t TruncatedErrorStringSize(const quiche::QuicheStringPiece& error) {
+size_t TruncatedErrorStringSize(const absl::string_view& error) {
   if (error.length() < kMaxErrorStringLength) {
     return error.length();
   }
@@ -1547,14 +1547,13 @@
     const size_t retry_token_length =
         bytes_remaining - kRetryIntegrityTagLength;
     DCHECK_GT(retry_token_length, 0u);
-    quiche::QuicheStringPiece retry_token;
+    absl::string_view retry_token;
     if (!reader->ReadStringPiece(&retry_token, retry_token_length)) {
       set_detailed_error("Failed to read retry token.");
       return false;
     }
-    quiche::QuicheStringPiece retry_without_tag =
-        reader->PreviouslyReadPayload();
-    quiche::QuicheStringPiece integrity_tag = reader->ReadRemainingPayload();
+    absl::string_view retry_without_tag = reader->PreviouslyReadPayload();
+    absl::string_view integrity_tag = reader->ReadRemainingPayload();
     DCHECK_EQ(integrity_tag.length(), kRetryIntegrityTagLength);
     visitor_->OnRetryPacket(EmptyQuicConnectionId(),
                             header.source_connection_id, retry_token,
@@ -1591,11 +1590,11 @@
     return false;
   }
 
-  quiche::QuicheStringPiece retry_token = reader->ReadRemainingPayload();
+  absl::string_view retry_token = reader->ReadRemainingPayload();
   visitor_->OnRetryPacket(original_destination_connection_id,
                           header.source_connection_id, retry_token,
-                          /*retry_integrity_tag=*/quiche::QuicheStringPiece(),
-                          /*retry_without_tag=*/quiche::QuicheStringPiece());
+                          /*retry_integrity_tag=*/absl::string_view(),
+                          /*retry_without_tag=*/absl::string_view());
   return true;
 }
 
@@ -1611,8 +1610,7 @@
     return;
   }
 
-  quiche::QuicheStringPiece remaining_data =
-      encrypted_reader.PeekRemainingPayload();
+  absl::string_view remaining_data = encrypted_reader.PeekRemainingPayload();
   DCHECK_EQ(remaining_data.length(), remaining_bytes_length);
 
   const char* coalesced_data =
@@ -1695,8 +1693,7 @@
       perspective_ == Perspective::IS_CLIENT) {
     // Peek possible stateless reset token. Will only be used on decryption
     // failure.
-    quiche::QuicheStringPiece remaining =
-        encrypted_reader->PeekRemainingPayload();
+    absl::string_view remaining = encrypted_reader->PeekRemainingPayload();
     if (remaining.length() >= sizeof(header->possible_stateless_reset_token)) {
       header->has_possible_stateless_reset_token = true;
       memcpy(&header->possible_stateless_reset_token,
@@ -1710,7 +1707,7 @@
     return false;
   }
 
-  quiche::QuicheStringPiece associated_data;
+  absl::string_view associated_data;
   std::vector<char> ad_storage;
   QuicPacketNumber base_packet_number;
   if (header->form == IETF_QUIC_SHORT_HEADER_PACKET ||
@@ -1736,8 +1733,7 @@
                                   &full_packet_number, &ad_storage)) {
         hp_removal_failed = true;
       }
-      associated_data =
-          quiche::QuicheStringPiece(ad_storage.data(), ad_storage.size());
+      associated_data = absl::string_view(ad_storage.data(), ad_storage.size());
     } else if (!ProcessAndCalculatePacketNumber(
                    encrypted_reader, header->packet_number_length,
                    base_packet_number, &full_packet_number)) {
@@ -1801,8 +1797,7 @@
     return false;
   }
 
-  quiche::QuicheStringPiece encrypted =
-      encrypted_reader->ReadRemainingPayload();
+  absl::string_view encrypted = encrypted_reader->ReadRemainingPayload();
   if (!version_.HasHeaderProtection()) {
     associated_data = GetAssociatedDataFromEncryptedPacket(
         version_.transport_version, packet,
@@ -1906,16 +1901,14 @@
     return false;
   }
 
-  quiche::QuicheStringPiece encrypted =
-      encrypted_reader->ReadRemainingPayload();
-  quiche::QuicheStringPiece associated_data =
-      GetAssociatedDataFromEncryptedPacket(
-          version_.transport_version, packet,
-          GetIncludedDestinationConnectionIdLength(*header),
-          GetIncludedSourceConnectionIdLength(*header), header->version_flag,
-          header->nonce != nullptr, header->packet_number_length,
-          header->retry_token_length_length, header->retry_token.length(),
-          header->length_length);
+  absl::string_view encrypted = encrypted_reader->ReadRemainingPayload();
+  absl::string_view associated_data = GetAssociatedDataFromEncryptedPacket(
+      version_.transport_version, packet,
+      GetIncludedDestinationConnectionIdLength(*header),
+      GetIncludedSourceConnectionIdLength(*header), header->version_flag,
+      header->nonce != nullptr, header->packet_number_length,
+      header->retry_token_length_length, header->retry_token.length(),
+      header->length_length);
 
   size_t decrypted_length = 0;
   EncryptionLevel decrypted_level;
@@ -1995,7 +1988,7 @@
   }
   // TODO(satyamshekhar): validate nonce to protect against DoS.
 
-  quiche::QuicheStringPiece address;
+  absl::string_view address;
   if (reset->GetStringPiece(kCADR, &address)) {
     QuicSocketAddressCoder address_coder;
     if (address_coder.Decode(address.data(), address.length())) {
@@ -2004,7 +1997,7 @@
     }
   }
 
-  quiche::QuicheStringPiece endpoint_id;
+  absl::string_view endpoint_id;
   if (perspective_ == Perspective::IS_CLIENT &&
       reset->GetStringPiece(kEPID, &endpoint_id)) {
     packet.endpoint_id = std::string(endpoint_id);
@@ -3476,8 +3469,8 @@
     return false;
   }
 
-  // TODO(ianswett): Don't use quiche::QuicheStringPiece as an intermediary.
-  quiche::QuicheStringPiece data;
+  // TODO(ianswett): Don't use absl::string_view as an intermediary.
+  absl::string_view data;
   if (has_data_length) {
     if (!reader->ReadStringPiece16(&data)) {
       set_detailed_error("Unable to read frame data.");
@@ -3538,8 +3531,8 @@
     frame->fin = false;
   }
 
-  // TODO(ianswett): Don't use quiche::QuicheStringPiece as an intermediary.
-  quiche::QuicheStringPiece data;
+  // TODO(ianswett): Don't use absl::string_view as an intermediary.
+  absl::string_view data;
   if (!reader->ReadStringPiece(&data, frame->data_length)) {
     set_detailed_error("Unable to read frame data.");
     return false;
@@ -3566,8 +3559,8 @@
   }
   frame->data_length = len;
 
-  // TODO(ianswett): Don't use quiche::QuicheStringPiece as an intermediary.
-  quiche::QuicheStringPiece data;
+  // TODO(ianswett): Don't use absl::string_view as an intermediary.
+  absl::string_view data;
   if (!reader->ReadStringPiece(&data, frame->data_length)) {
     set_detailed_error("Unable to read frame data.");
     return false;
@@ -4069,7 +4062,7 @@
   frame->wire_error_code = error_code;
   frame->quic_error_code = static_cast<QuicErrorCode>(error_code);
 
-  quiche::QuicheStringPiece error_details;
+  absl::string_view error_details;
   if (!reader->ReadStringPiece16(&error_details)) {
     set_detailed_error("Unable to read connection close error details.");
     return false;
@@ -4101,7 +4094,7 @@
   }
   frame->last_good_stream_id = static_cast<QuicStreamId>(stream_id);
 
-  quiche::QuicheStringPiece reason_phrase;
+  absl::string_view reason_phrase;
   if (!reader->ReadStringPiece16(&reason_phrase)) {
     set_detailed_error("Unable to read goaway reason.");
     return false;
@@ -4155,7 +4148,7 @@
                                      bool no_message_length,
                                      QuicMessageFrame* frame) {
   if (no_message_length) {
-    quiche::QuicheStringPiece remaining(reader->ReadRemainingPayload());
+    absl::string_view remaining(reader->ReadRemainingPayload());
     frame->data = remaining.data();
     frame->message_length = remaining.length();
     return true;
@@ -4167,7 +4160,7 @@
     return false;
   }
 
-  quiche::QuicheStringPiece message_piece;
+  absl::string_view message_piece;
   if (!reader->ReadStringPiece(&message_piece, message_length)) {
     set_detailed_error("Unable to read message data");
     return false;
@@ -4180,7 +4173,7 @@
 }
 
 // static
-quiche::QuicheStringPiece QuicFramer::GetAssociatedDataFromEncryptedPacket(
+absl::string_view QuicFramer::GetAssociatedDataFromEncryptedPacket(
     QuicTransportVersion version,
     const QuicEncryptedPacket& encrypted,
     QuicConnectionIdLength destination_connection_id_length,
@@ -4192,7 +4185,7 @@
     uint64_t retry_token_length,
     QuicVariableLengthIntegerLength length_length) {
   // TODO(ianswett): This is identical to QuicData::AssociatedData.
-  return quiche::QuicheStringPiece(
+  return absl::string_view(
       encrypted.data(),
       GetStartOfEncryptedData(version, destination_connection_id_length,
                               source_connection_id_length, includes_version,
@@ -4297,10 +4290,10 @@
   size_t output_length = 0;
   if (!encrypter_[level]->EncryptPacket(
           packet_number.ToUint64(),
-          quiche::QuicheStringPiece(buffer, ad_len),  // Associated data
-          quiche::QuicheStringPiece(buffer + ad_len,
-                                    total_len - ad_len),  // Plaintext
-          buffer + ad_len,                                // Destination buffer
+          absl::string_view(buffer, ad_len),  // Associated data
+          absl::string_view(buffer + ad_len,
+                            total_len - ad_len),  // Plaintext
+          buffer + ad_len,                        // Destination buffer
           &output_length, buffer_len - ad_len)) {
     RaiseError(QUIC_ENCRYPTION_FAILURE);
     return 0;
@@ -4339,7 +4332,7 @@
   // Sample the ciphertext and generate the mask to use for header protection.
   size_t sample_offset = pn_offset + 4;
   QuicDataReader sample_reader(buffer, buffer_len);
-  quiche::QuicheStringPiece sample;
+  absl::string_view sample;
   if (!sample_reader.Seek(sample_offset) ||
       !sample_reader.ReadStringPiece(&sample, kHPSampleLen)) {
     QUIC_BUG << "Not enough bytes to sample: sample_offset " << sample_offset
@@ -4434,11 +4427,11 @@
 
   // Read a sample from the ciphertext and compute the mask to use for header
   // protection.
-  quiche::QuicheStringPiece remaining_packet = reader->PeekRemainingPayload();
+  absl::string_view remaining_packet = reader->PeekRemainingPayload();
   QuicDataReader sample_reader(remaining_packet);
 
   // The sample starts 4 bytes after the start of the packet number.
-  quiche::QuicheStringPiece pn;
+  absl::string_view pn;
   if (!sample_reader.ReadStringPiece(&pn, 4)) {
     QUIC_DVLOG(1) << "Not enough data to sample";
     return false;
@@ -4506,7 +4499,7 @@
   }
 
   // Get the associated data, and apply the same unmasking operations to it.
-  quiche::QuicheStringPiece ad = GetAssociatedDataFromEncryptedPacket(
+  absl::string_view ad = GetAssociatedDataFromEncryptedPacket(
       version_.transport_version, packet,
       GetIncludedDestinationConnectionIdLength(*header),
       GetIncludedSourceConnectionIdLength(*header), header->version_flag,
@@ -4548,7 +4541,7 @@
     return 0;
   }
 
-  quiche::QuicheStringPiece associated_data =
+  absl::string_view associated_data =
       packet.AssociatedData(version_.transport_version);
   // Copy in the header, because the encrypter only populates the encrypted
   // plaintext content.
@@ -4609,8 +4602,8 @@
   return min_plaintext_size;
 }
 
-bool QuicFramer::DecryptPayload(quiche::QuicheStringPiece encrypted,
-                                quiche::QuicheStringPiece associated_data,
+bool QuicFramer::DecryptPayload(absl::string_view encrypted,
+                                absl::string_view associated_data,
                                 const QuicPacketHeader& header,
                                 char* decrypted_buffer,
                                 size_t buffer_length,
@@ -5142,8 +5135,8 @@
     return false;
   }
 
-  // TODO(ianswett): Don't use quiche::QuicheStringPiece as an intermediary.
-  quiche::QuicheStringPiece data;
+  // TODO(ianswett): Don't use absl::string_view as an intermediary.
+  absl::string_view data;
   if (!reader->ReadStringPiece(&data, length)) {
     set_detailed_error("Unable to read new token data.");
     return false;
@@ -5813,7 +5806,7 @@
     return false;
   }
 
-  quiche::QuicheStringPiece phrase;
+  absl::string_view phrase;
   if (!reader->ReadStringPiece(&phrase, static_cast<size_t>(phrase_length))) {
     set_detailed_error("Unable to read connection close error details.");
     return false;
@@ -6284,7 +6277,7 @@
     QuicConnectionId* destination_connection_id,
     QuicConnectionId* source_connection_id,
     bool* retry_token_present,
-    quiche::QuicheStringPiece* retry_token,
+    absl::string_view* retry_token,
     std::string* detailed_error) {
   QuicDataReader reader(packet.data(), packet.length());
   if (reader.IsDoneReading()) {
@@ -6454,7 +6447,7 @@
     QuicConnectionId* source_connection_id,
     QuicLongHeaderType* long_packet_type,
     QuicVariableLengthIntegerLength* retry_token_length_length,
-    quiche::QuicheStringPiece* retry_token,
+    absl::string_view* retry_token,
     std::string* detailed_error) {
   *version_present = false;
   *has_length_prefix = false;
@@ -6463,7 +6456,7 @@
   *source_connection_id = EmptyQuicConnectionId();
   *long_packet_type = INVALID_PACKET_TYPE;
   *retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_0;
-  *retry_token = quiche::QuicheStringPiece();
+  *retry_token = absl::string_view();
   *detailed_error = "";
 
   if (!reader->ReadUInt8(first_byte)) {
@@ -6738,7 +6731,7 @@
 // the string is not found, or is not properly formed, it returns
 // ErrorCode::QUIC_IETF_GQUIC_ERROR_MISSING
 void MaybeExtractQuicErrorCode(QuicConnectionCloseFrame* frame) {
-  std::vector<quiche::QuicheStringPiece> ed =
+  std::vector<absl::string_view> ed =
       quiche::QuicheTextUtils::Split(frame->error_details, ':');
   uint64_t extracted_error_code;
   if (ed.size() < 2 || !quiche::QuicheTextUtils::IsAllDigits(ed[0]) ||
@@ -6756,7 +6749,7 @@
   // including, the split character, so the length of ed[0] is just the number
   // of digits in the error number. In removing the prefix, 1 is added to the
   // length to account for the :
-  quiche::QuicheStringPiece x = quiche::QuicheStringPiece(frame->error_details);
+  absl::string_view x = absl::string_view(frame->error_details);
   x.remove_prefix(ed[0].length() + 1);
   frame->error_details = std::string(x);
   frame->quic_error_code = static_cast<QuicErrorCode>(extracted_error_code);
diff --git a/quic/core/quic_framer.h b/quic/core/quic_framer.h
index c9820d4..e57e252 100644
--- a/quic/core/quic_framer.h
+++ b/quic/core/quic_framer.h
@@ -10,6 +10,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
@@ -17,7 +18,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -106,9 +106,9 @@
   // the entire RETRY packet except the Retry Integrity Tag field.
   virtual void OnRetryPacket(QuicConnectionId original_connection_id,
                              QuicConnectionId new_connection_id,
-                             quiche::QuicheStringPiece retry_token,
-                             quiche::QuicheStringPiece retry_integrity_tag,
-                             quiche::QuicheStringPiece retry_without_tag) = 0;
+                             absl::string_view retry_token,
+                             absl::string_view retry_integrity_tag,
+                             absl::string_view retry_without_tag) = 0;
 
   // Called when all fields except packet number has been parsed, but has not
   // been authenticated. If it returns false, framing for this packet will
@@ -385,7 +385,7 @@
 
   // Returns the associated data from the encrypted packet |encrypted| as a
   // stringpiece.
-  static quiche::QuicheStringPiece GetAssociatedDataFromEncryptedPacket(
+  static absl::string_view GetAssociatedDataFromEncryptedPacket(
       QuicTransportVersion version,
       const QuicEncryptedPacket& encrypted,
       QuicConnectionIdLength destination_connection_id_length,
@@ -414,7 +414,7 @@
       QuicConnectionId* source_connection_id,
       QuicLongHeaderType* long_packet_type,
       QuicVariableLengthIntegerLength* retry_token_length_length,
-      quiche::QuicheStringPiece* retry_token,
+      absl::string_view* retry_token,
       std::string* detailed_error);
 
   // Parses the unencrypted fields in |packet| and stores them in the other
@@ -432,7 +432,7 @@
       QuicConnectionId* destination_connection_id,
       QuicConnectionId* source_connection_id,
       bool* retry_token_present,
-      quiche::QuicheStringPiece* retry_token,
+      absl::string_view* retry_token,
       std::string* detailed_error);
 
   // Serializes a packet containing |frames| into |buffer|.
@@ -808,8 +808,8 @@
                            bool no_message_length,
                            QuicMessageFrame* frame);
 
-  bool DecryptPayload(quiche::QuicheStringPiece encrypted,
-                      quiche::QuicheStringPiece associated_data,
+  bool DecryptPayload(absl::string_view encrypted,
+                      absl::string_view associated_data,
                       const QuicPacketHeader& header,
                       char* decrypted_buffer,
                       size_t buffer_length,
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index 688aa02..f35613a 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -12,6 +12,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/null_decrypter.h"
 #include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
@@ -31,7 +32,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/simple_data_producer.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.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"
 #include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h"
 
@@ -92,17 +92,17 @@
 class TestEncrypter : public QuicEncrypter {
  public:
   ~TestEncrypter() override {}
-  bool SetKey(quiche::QuicheStringPiece /*key*/) override { return true; }
-  bool SetNoncePrefix(quiche::QuicheStringPiece /*nonce_prefix*/) override {
+  bool SetKey(absl::string_view /*key*/) override { return true; }
+  bool SetNoncePrefix(absl::string_view /*nonce_prefix*/) override {
     return true;
   }
-  bool SetIV(quiche::QuicheStringPiece /*iv*/) override { return true; }
-  bool SetHeaderProtectionKey(quiche::QuicheStringPiece /*key*/) override {
+  bool SetIV(absl::string_view /*iv*/) override { return true; }
+  bool SetHeaderProtectionKey(absl::string_view /*key*/) override {
     return true;
   }
   bool EncryptPacket(uint64_t packet_number,
-                     quiche::QuicheStringPiece associated_data,
-                     quiche::QuicheStringPiece plaintext,
+                     absl::string_view associated_data,
+                     absl::string_view plaintext,
                      char* output,
                      size_t* output_length,
                      size_t /*max_output_length*/) override {
@@ -114,7 +114,7 @@
     return true;
   }
   std::string GenerateHeaderProtectionMask(
-      quiche::QuicheStringPiece /*sample*/) override {
+      absl::string_view /*sample*/) override {
     return std::string(5, 0);
   }
   size_t GetKeySize() const override { return 0; }
@@ -126,11 +126,9 @@
   size_t GetCiphertextSize(size_t plaintext_size) const override {
     return plaintext_size;
   }
-  quiche::QuicheStringPiece GetKey() const override {
-    return quiche::QuicheStringPiece();
-  }
-  quiche::QuicheStringPiece GetNoncePrefix() const override {
-    return quiche::QuicheStringPiece();
+  absl::string_view GetKey() const override { return absl::string_view(); }
+  absl::string_view GetNoncePrefix() const override {
+    return absl::string_view();
   }
 
   QuicPacketNumber packet_number_;
@@ -141,15 +139,15 @@
 class TestDecrypter : public QuicDecrypter {
  public:
   ~TestDecrypter() override {}
-  bool SetKey(quiche::QuicheStringPiece /*key*/) override { return true; }
-  bool SetNoncePrefix(quiche::QuicheStringPiece /*nonce_prefix*/) override {
+  bool SetKey(absl::string_view /*key*/) override { return true; }
+  bool SetNoncePrefix(absl::string_view /*nonce_prefix*/) override {
     return true;
   }
-  bool SetIV(quiche::QuicheStringPiece /*iv*/) override { return true; }
-  bool SetHeaderProtectionKey(quiche::QuicheStringPiece /*key*/) override {
+  bool SetIV(absl::string_view /*iv*/) override { return true; }
+  bool SetHeaderProtectionKey(absl::string_view /*key*/) override {
     return true;
   }
-  bool SetPreliminaryKey(quiche::QuicheStringPiece /*key*/) override {
+  bool SetPreliminaryKey(absl::string_view /*key*/) override {
     QUIC_BUG << "should not be called";
     return false;
   }
@@ -157,8 +155,8 @@
     return true;
   }
   bool DecryptPacket(uint64_t packet_number,
-                     quiche::QuicheStringPiece associated_data,
-                     quiche::QuicheStringPiece ciphertext,
+                     absl::string_view associated_data,
+                     absl::string_view ciphertext,
                      char* output,
                      size_t* output_length,
                      size_t /*max_output_length*/) override {
@@ -176,11 +174,9 @@
   size_t GetKeySize() const override { return 0; }
   size_t GetNoncePrefixSize() const override { return 0; }
   size_t GetIVSize() const override { return 0; }
-  quiche::QuicheStringPiece GetKey() const override {
-    return quiche::QuicheStringPiece();
-  }
-  quiche::QuicheStringPiece GetNoncePrefix() const override {
-    return quiche::QuicheStringPiece();
+  absl::string_view GetKey() const override { return absl::string_view(); }
+  absl::string_view GetNoncePrefix() const override {
+    return absl::string_view();
   }
   // Use a distinct value starting with 0xFFFFFF, which is never used by TLS.
   uint32_t cipher_id() const override { return 0xFFFFFFF2; }
@@ -224,9 +220,9 @@
 
   void OnRetryPacket(QuicConnectionId original_connection_id,
                      QuicConnectionId new_connection_id,
-                     quiche::QuicheStringPiece retry_token,
-                     quiche::QuicheStringPiece retry_integrity_tag,
-                     quiche::QuicheStringPiece retry_without_tag) override {
+                     absl::string_view retry_token,
+                     absl::string_view retry_integrity_tag,
+                     absl::string_view retry_without_tag) override {
     on_retry_packet_called_ = true;
     retry_original_connection_id_ =
         std::make_unique<QuicConnectionId>(original_connection_id);
@@ -707,7 +703,7 @@
                       << " actual: " << decrypter_->packet_number_;
       return false;
     }
-    quiche::QuicheStringPiece associated_data =
+    absl::string_view associated_data =
         QuicFramer::GetAssociatedDataFromEncryptedPacket(
             framer_.transport_version(), encrypted,
             destination_connection_id_length, source_connection_id_length,
@@ -722,7 +718,7 @@
                              decrypter_->associated_data_);
       return false;
     }
-    quiche::QuicheStringPiece ciphertext(
+    absl::string_view ciphertext(
         encrypted.AsStringPiece().substr(GetStartOfEncryptedData(
             framer_.transport_version(), destination_connection_id_length,
             source_connection_id_length, includes_version,
@@ -1070,7 +1066,7 @@
   QuicVersionLabel version_label;
   std::string detailed_error;
   bool retry_token_present, use_length_prefix;
-  quiche::QuicheStringPiece retry_token;
+  absl::string_view retry_token;
   ParsedQuicVersion parsed_version = UnsupportedQuicVersion();
   const QuicErrorCode error_code = QuicFramer::ParsePublicHeaderDispatcher(
       *encrypted, kQuicDefaultConnectionIdLength, &format, &long_packet_type,
@@ -1135,7 +1131,7 @@
   QuicVersionLabel version_label;
   std::string detailed_error;
   bool retry_token_present, use_length_prefix;
-  quiche::QuicheStringPiece retry_token;
+  absl::string_view retry_token;
   ParsedQuicVersion parsed_version = UnsupportedQuicVersion();
   const QuicErrorCode error_code = QuicFramer::ParsePublicHeaderDispatcher(
       *encrypted, kQuicDefaultConnectionIdLength, &format, &long_packet_type,
@@ -1215,7 +1211,7 @@
   QuicVersionLabel version_label = 0;
   std::string detailed_error = "";
   bool retry_token_present, use_length_prefix;
-  quiche::QuicheStringPiece retry_token;
+  absl::string_view retry_token;
   ParsedQuicVersion parsed_version = UnsupportedQuicVersion();
   const QuicErrorCode error_code = QuicFramer::ParsePublicHeaderDispatcher(
       encrypted, kQuicDefaultConnectionIdLength, &format, &long_packet_type,
@@ -1305,7 +1301,7 @@
   QuicLongHeaderType long_packet_type = INVALID_PACKET_TYPE;
   QuicVariableLengthIntegerLength retry_token_length_length =
       VARIABLE_LENGTH_INTEGER_LENGTH_4;
-  quiche::QuicheStringPiece retry_token;
+  absl::string_view retry_token;
   std::string detailed_error = "foobar";
 
   QuicDataReader reader(AsChars(p), p_length);
@@ -1328,7 +1324,7 @@
   EXPECT_EQ(FramerTestConnectionId(), destination_connection_id);
   EXPECT_EQ(EmptyQuicConnectionId(), source_connection_id);
   EXPECT_EQ(VARIABLE_LENGTH_INTEGER_LENGTH_0, retry_token_length_length);
-  EXPECT_EQ(quiche::QuicheStringPiece(), retry_token);
+  EXPECT_EQ(absl::string_view(), retry_token);
   if (VersionHasIetfInvariantHeader(framer_.transport_version())) {
     EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
     EXPECT_EQ(HANDSHAKE, long_packet_type);
@@ -1375,7 +1371,7 @@
   QuicLongHeaderType long_packet_type = INVALID_PACKET_TYPE;
   QuicVariableLengthIntegerLength retry_token_length_length =
       VARIABLE_LENGTH_INTEGER_LENGTH_4;
-  quiche::QuicheStringPiece retry_token;
+  absl::string_view retry_token;
   std::string detailed_error = "foobar";
 
   QuicDataReader reader(AsChars(p), p_length);
@@ -1395,7 +1391,7 @@
   EXPECT_EQ(FramerTestConnectionId(), destination_connection_id);
   EXPECT_EQ(EmptyQuicConnectionId(), source_connection_id);
   EXPECT_EQ(VARIABLE_LENGTH_INTEGER_LENGTH_0, retry_token_length_length);
-  EXPECT_EQ(quiche::QuicheStringPiece(), retry_token);
+  EXPECT_EQ(absl::string_view(), retry_token);
   EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
 }
 
@@ -6167,7 +6163,7 @@
   header.version_flag = false;
   header.packet_number = kPacketNumber;
   QuicStreamFrame stream_frame(kStreamId, true, kStreamOffset,
-                               quiche::QuicheStringPiece("hello world!"));
+                               absl::string_view("hello world!"));
   QuicPaddingFrame padding_frame(2);
   QuicFrames frames = {QuicFrame(padding_frame), QuicFrame(stream_frame),
                        QuicFrame(padding_frame)};
@@ -6510,7 +6506,7 @@
   }
 
   QuicStreamFrame stream_frame(kStreamId, true, kStreamOffset,
-                               quiche::QuicheStringPiece("hello world!"));
+                               absl::string_view("hello world!"));
 
   QuicFrames frames = {QuicFrame(stream_frame)};
 
@@ -6609,7 +6605,7 @@
   }
 
   QuicStreamFrame stream_frame(kStreamId, true, kStreamOffset,
-                               quiche::QuicheStringPiece("hello world!"));
+                               absl::string_view("hello world!"));
   QuicFrames frames = {QuicFrame(stream_frame)};
 
   // clang-format off
@@ -6742,7 +6738,7 @@
   SimpleDataProducer data_producer;
   framer_.set_data_producer(&data_producer);
 
-  quiche::QuicheStringPiece crypto_frame_contents("hello world!");
+  absl::string_view crypto_frame_contents("hello world!");
   QuicCryptoFrame crypto_frame(ENCRYPTION_INITIAL, kStreamOffset,
                                crypto_frame_contents.length());
   data_producer.SaveCryptoData(ENCRYPTION_INITIAL, kStreamOffset,
@@ -14029,7 +14025,7 @@
   QuicConnectionId destination_connection_id = TestConnectionId(0x33);
   QuicConnectionId source_connection_id = TestConnectionId(0x34);
   bool retry_token_present = true;
-  quiche::QuicheStringPiece retry_token;
+  absl::string_view retry_token;
   std::string detailed_error = "foobar";
 
   QuicErrorCode parse_result = QuicFramer::ParsePublicHeaderDispatcher(
@@ -14046,7 +14042,7 @@
   EXPECT_EQ(probe_payload_connection_id, destination_connection_id);
   EXPECT_EQ(EmptyQuicConnectionId(), source_connection_id);
   EXPECT_FALSE(retry_token_present);
-  EXPECT_EQ(quiche::QuicheStringPiece(), retry_token);
+  EXPECT_EQ(absl::string_view(), retry_token);
   EXPECT_EQ("", detailed_error);
 }
 
@@ -14181,7 +14177,7 @@
   QuicConnectionId destination_connection_id = TestConnectionId(1);
   QuicConnectionId source_connection_id = TestConnectionId(2);
   bool retry_token_present = true;
-  quiche::QuicheStringPiece retry_token;
+  absl::string_view retry_token;
   std::string detailed_error = "foobar";
   QuicErrorCode header_parse_result = QuicFramer::ParsePublicHeaderDispatcher(
       encrypted, kQuicDefaultConnectionIdLength, &format, &long_packet_type,
@@ -14260,7 +14256,7 @@
   QuicConnectionId destination_connection_id = TestConnectionId(1);
   QuicConnectionId source_connection_id = TestConnectionId(2);
   bool retry_token_present = true;
-  quiche::QuicheStringPiece retry_token;
+  absl::string_view retry_token;
   std::string detailed_error = "foobar";
   QuicErrorCode header_parse_result = QuicFramer::ParsePublicHeaderDispatcher(
       encrypted, kQuicDefaultConnectionIdLength, &format, &long_packet_type,
diff --git a/quic/core/quic_legacy_version_encapsulator.cc b/quic/core/quic_legacy_version_encapsulator.cc
index 4afd342..8e93172 100644
--- a/quic/core/quic_legacy_version_encapsulator.cc
+++ b/quic/core/quic_legacy_version_encapsulator.cc
@@ -19,7 +19,7 @@
 
 // static
 QuicByteCount QuicLegacyVersionEncapsulator::GetMinimumOverhead(
-    quiche::QuicheStringPiece sni) {
+    absl::string_view sni) {
   // The number 52 is the sum of:
   // - Flags (1 byte)
   // - Server Connection ID (8 bytes)
@@ -85,8 +85,8 @@
 
 // static
 QuicPacketLength QuicLegacyVersionEncapsulator::Encapsulate(
-    quiche::QuicheStringPiece sni,
-    quiche::QuicheStringPiece inner_packet,
+    absl::string_view sni,
+    absl::string_view inner_packet,
     const QuicConnectionId& server_connection_id,
     QuicTime creation_time,
     QuicByteCount outer_max_packet_length,
diff --git a/quic/core/quic_legacy_version_encapsulator.h b/quic/core/quic_legacy_version_encapsulator.h
index 413829b..7a4ada6 100644
--- a/quic/core/quic_legacy_version_encapsulator.h
+++ b/quic/core/quic_legacy_version_encapsulator.h
@@ -5,11 +5,11 @@
 #ifndef QUICHE_QUIC_CORE_QUIC_LEGACY_VERSION_ENCAPSULATOR_H_
 #define QUICHE_QUIC_CORE_QUIC_LEGACY_VERSION_ENCAPSULATOR_H_
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_packet_creator.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -27,8 +27,8 @@
   // the contents of the encapsulated packet to |out|. |out| must point to a
   // valid memory buffer capable of holding kMaxOutgoingPacketSize bytes.
   static QuicPacketLength Encapsulate(
-      quiche::QuicheStringPiece sni,
-      quiche::QuicheStringPiece inner_packet,
+      absl::string_view sni,
+      absl::string_view inner_packet,
       const QuicConnectionId& server_connection_id,
       QuicTime creation_time,
       QuicByteCount outer_max_packet_length,
@@ -37,7 +37,7 @@
   // Returns the number of bytes of minimum overhead caused by Legacy Version
   // Encapsulation, based on the length of the provided server name |sni|.
   // The overhead may be higher due to extra padding added.
-  static QuicByteCount GetMinimumOverhead(quiche::QuicheStringPiece sni);
+  static QuicByteCount GetMinimumOverhead(absl::string_view sni);
 
   // Overrides for QuicPacketCreator::DelegateInterface.
   QuicPacketBuffer GetPacketBuffer() override;
diff --git a/quic/core/quic_legacy_version_encapsulator_test.cc b/quic/core/quic_legacy_version_encapsulator_test.cc
index a71b2f4..d765fff 100644
--- a/quic/core/quic_legacy_version_encapsulator_test.cc
+++ b/quic/core/quic_legacy_version_encapsulator_test.cc
@@ -4,11 +4,11 @@
 
 #include "net/third_party/quiche/src/quic/core/quic_legacy_version_encapsulator.h"
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.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 quic {
@@ -43,7 +43,7 @@
     ParsedQuicVersion parsed_version = ParsedQuicVersion::Unsupported();
     QuicConnectionId destination_connection_id, source_connection_id;
     bool retry_token_present;
-    quiche::QuicheStringPiece retry_token;
+    absl::string_view retry_token;
     std::string detailed_error;
     const QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
         QuicEncryptedPacket(outer_buffer_, encapsulated_length_),
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index af9d079..85960c4 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -11,6 +11,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
 #include "net/third_party/quiche/src/quic/core/frames/quic_frame.h"
 #include "net/third_party/quiche/src/quic/core/frames/quic_path_challenge_frame.h"
@@ -31,7 +32,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_server_stats.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.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 quic {
@@ -1291,16 +1291,16 @@
   return VARIABLE_LENGTH_INTEGER_LENGTH_0;
 }
 
-quiche::QuicheStringPiece QuicPacketCreator::GetRetryToken() const {
+absl::string_view QuicPacketCreator::GetRetryToken() const {
   if (QuicVersionHasLongHeaderLengths(framer_->transport_version()) &&
       HasIetfLongHeader() &&
       EncryptionlevelToLongHeaderType(packet_.encryption_level) == INITIAL) {
     return retry_token_;
   }
-  return quiche::QuicheStringPiece();
+  return absl::string_view();
 }
 
-void QuicPacketCreator::SetRetryToken(quiche::QuicheStringPiece retry_token) {
+void QuicPacketCreator::SetRetryToken(absl::string_view retry_token) {
   retry_token_ = std::string(retry_token);
 }
 
diff --git a/quic/core/quic_packet_creator.h b/quic/core/quic_packet_creator.h
index b65bd27..882b17d 100644
--- a/quic/core/quic_packet_creator.h
+++ b/quic/core/quic_packet_creator.h
@@ -20,6 +20,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/frames/quic_stream_frame.h"
 #include "net/third_party/quiche/src/quic/core/quic_circular_deque.h"
 #include "net/third_party/quiche/src/quic/core/quic_coalesced_packet.h"
@@ -28,7 +29,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_macros.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -322,7 +322,7 @@
   void AddPendingPadding(QuicByteCount size);
 
   // Sets the retry token to be sent over the wire in IETF Initial packets.
-  void SetRetryToken(quiche::QuicheStringPiece retry_token);
+  void SetRetryToken(absl::string_view retry_token);
 
   // Consumes retransmittable control |frame|. Returns true if the frame is
   // successfully consumed. Returns false otherwise.
@@ -573,7 +573,7 @@
 
   // Returns the retry token to send over the wire, only sent in
   // v99 IETF Initial packets.
-  quiche::QuicheStringPiece GetRetryToken() const;
+  absl::string_view GetRetryToken() const;
 
   // Returns length of the length variable length integer to send over the
   // wire. Is non-zero for v99 IETF Initial, 0-RTT or Handshake packets.
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index 4afbf06..c31d3c7 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -11,6 +11,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/null_decrypter.h"
 #include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
@@ -32,7 +33,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/simple_quic_framer.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.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/test_tools/quiche_test_utils.h"
 
 using testing::_;
@@ -227,8 +227,7 @@
       producer_.WriteStreamData(stream_id, frame.stream_frame.offset,
                                 frame.stream_frame.data_length, &writer);
     }
-    EXPECT_EQ(data,
-              quiche::QuicheStringPiece(buf, frame.stream_frame.data_length));
+    EXPECT_EQ(data, absl::string_view(buf, frame.stream_frame.data_length));
     EXPECT_EQ(offset, frame.stream_frame.offset);
     EXPECT_EQ(fin, frame.stream_frame.fin);
   }
@@ -306,7 +305,7 @@
         client_framer_.transport_version(), Perspective::IS_CLIENT);
     if (level != ENCRYPTION_INITIAL && level != ENCRYPTION_HANDSHAKE) {
       frames_.push_back(QuicFrame(
-          QuicStreamFrame(stream_id, false, 0u, quiche::QuicheStringPiece())));
+          QuicStreamFrame(stream_id, false, 0u, absl::string_view())));
     }
     SerializedPacket serialized = SerializeAllFrames(frames_);
     EXPECT_EQ(level, serialized.encryption_level);
@@ -1296,7 +1295,7 @@
   if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
     QuicStreamFrame stream_frame(
         QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
-        /*fin=*/false, 0u, quiche::QuicheStringPiece());
+        /*fin=*/false, 0u, absl::string_view());
     frames_.push_back(QuicFrame(stream_frame));
   } else {
     producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
@@ -1333,7 +1332,7 @@
   if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
     QuicStreamFrame stream_frame(
         QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
-        /*fin=*/false, 0u, quiche::QuicheStringPiece());
+        /*fin=*/false, 0u, absl::string_view());
     frames_.push_back(QuicFrame(stream_frame));
   } else {
     producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
@@ -1556,7 +1555,7 @@
   creator_.set_encryption_level(ENCRYPTION_INITIAL);
   EXPECT_CALL(delegate_, OnUnrecoverableError(_, _));
   QuicStreamFrame stream_frame(GetNthClientInitiatedStreamId(0),
-                               /*fin=*/false, 0u, quiche::QuicheStringPiece());
+                               /*fin=*/false, 0u, absl::string_view());
   EXPECT_QUIC_BUG(
       creator_.AddFrame(QuicFrame(stream_frame), NOT_RETRANSMISSION),
       "Cannot send stream data with level: ENCRYPTION_INITIAL");
@@ -1571,7 +1570,7 @@
   creator_.set_encryption_level(ENCRYPTION_HANDSHAKE);
   EXPECT_CALL(delegate_, OnUnrecoverableError(_, _));
   QuicStreamFrame stream_frame(GetNthClientInitiatedStreamId(0),
-                               /*fin=*/false, 0u, quiche::QuicheStringPiece());
+                               /*fin=*/false, 0u, absl::string_view());
   EXPECT_QUIC_BUG(
       creator_.AddFrame(QuicFrame(stream_frame), NOT_RETRANSMISSION),
       "Cannot send stream data with level: ENCRYPTION_HANDSHAKE");
@@ -1598,9 +1597,8 @@
   message_data = framer.ConstructHandshakeMessage(message);
 
   struct iovec iov;
-  MakeIOVector(
-      quiche::QuicheStringPiece(message_data->data(), message_data->length()),
-      &iov);
+  MakeIOVector(absl::string_view(message_data->data(), message_data->length()),
+               &iov);
   QuicFrame frame;
   EXPECT_CALL(delegate_, OnUnrecoverableError(QUIC_CRYPTO_CHLO_TOO_LARGE, _));
   EXPECT_QUIC_BUG(
@@ -1677,7 +1675,7 @@
       .WillRepeatedly(
           Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   // Send stream frame of size kStreamFramePayloadSize.
-  MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize), &iov_);
+  MakeIOVector(absl::string_view(buf, kStreamFramePayloadSize), &iov_);
   creator_.ConsumeDataToFillCurrentPacket(stream_id, &iov_, 1u, iov_.iov_len,
                                           0u, 0u, false, false,
                                           NOT_RETRANSMISSION, &frame);
@@ -1685,8 +1683,7 @@
   // 1 byte padding is sent.
   EXPECT_EQ(pending_padding_bytes - 1, creator_.pending_padding_bytes());
   // Send stream frame of size kStreamFramePayloadSize + 1.
-  MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize + 1),
-               &iov_);
+  MakeIOVector(absl::string_view(buf, kStreamFramePayloadSize + 1), &iov_);
   creator_.ConsumeDataToFillCurrentPacket(stream_id, &iov_, 1u, iov_.iov_len,
                                           0u, kStreamFramePayloadSize, false,
                                           false, NOT_RETRANSMISSION, &frame);
@@ -1798,7 +1795,7 @@
     creator_.SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
   }
   std::string message_data(kDefaultMaxPacketSize, 'a');
-  quiche::QuicheStringPiece message_buffer(message_data);
+  absl::string_view message_buffer(message_data);
   QuicMemSliceStorage storage(nullptr, 0, nullptr, 0);
   // Test all possible encryption levels of message frames.
   for (EncryptionLevel level :
@@ -1809,10 +1806,9 @@
          message_size <= creator_.GetCurrentLargestMessagePayload();
          ++message_size) {
       QuicMessageFrame* frame = new QuicMessageFrame(
-          0, MakeSpan(
-                 &allocator_,
-                 quiche::QuicheStringPiece(message_buffer.data(), message_size),
-                 &storage));
+          0, MakeSpan(&allocator_,
+                      absl::string_view(message_buffer.data(), message_size),
+                      &storage));
       EXPECT_TRUE(creator_.AddFrame(QuicFrame(frame), NOT_RETRANSMISSION));
       EXPECT_TRUE(creator_.HasPendingFrames());
 
@@ -1938,7 +1934,7 @@
       client_framer_.transport_version(), Perspective::IS_CLIENT);
   QuicFrame stream_frame(QuicStreamFrame(stream_id,
                                          /*fin=*/false, 0u,
-                                         quiche::QuicheStringPiece()));
+                                         absl::string_view()));
   ASSERT_TRUE(QuicUtils::IsRetransmittableFrame(stream_frame.type));
 
   QuicFrame padding_frame{QuicPaddingFrame()};
@@ -1979,7 +1975,7 @@
   if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
     QuicStreamFrame stream_frame(
         QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
-        /*fin=*/false, 0u, quiche::QuicheStringPiece());
+        /*fin=*/false, 0u, absl::string_view());
     frames_.push_back(QuicFrame(stream_frame));
   } else {
     producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
@@ -2146,8 +2142,8 @@
     QuicAckFrame ack_frame(InitAckFrame(1));
     frames_.push_back(QuicFrame(&ack_frame));
     if (level != ENCRYPTION_INITIAL && level != ENCRYPTION_HANDSHAKE) {
-      frames_.push_back(QuicFrame(
-          QuicStreamFrame(1, false, 0u, quiche::QuicheStringPiece())));
+      frames_.push_back(
+          QuicFrame(QuicStreamFrame(1, false, 0u, absl::string_view())));
     }
     SerializedPacket serialized = SerializeAllFrames(frames_);
     EXPECT_EQ(level, serialized.encryption_level);
@@ -2420,7 +2416,7 @@
   }
 
   size_t ConsumeCryptoData(EncryptionLevel level,
-                           quiche::QuicheStringPiece data,
+                           absl::string_view data,
                            QuicStreamOffset offset) {
     producer_->SaveCryptoData(level, offset, data);
     if (!has_ack() && delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
@@ -3576,7 +3572,7 @@
        ConnectionCloseFrameLargerThanPacketSize) {
   delegate_.SetCanWriteAnything();
   char buf[2000] = {};
-  quiche::QuicheStringPiece error_details(buf, 2000);
+  absl::string_view error_details(buf, 2000);
   const QuicErrorCode kQuicErrorCode = QUIC_PACKET_WRITE_ERROR;
 
   QuicConnectionCloseFrame* frame = new QuicConnectionCloseFrame(
@@ -3616,7 +3612,7 @@
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(
           Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
-  MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize), &iov_);
+  MakeIOVector(absl::string_view(buf, kStreamFramePayloadSize), &iov_);
   QuicConsumedData consumed = creator_.ConsumeData(
       kDataStreamId, &iov_, 1u, iov_.iov_len, 0, FIN_AND_PADDING);
   creator_.Flush();
@@ -3659,7 +3655,7 @@
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillRepeatedly(
           Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
-  MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize), &iov_);
+  MakeIOVector(absl::string_view(buf, kStreamFramePayloadSize), &iov_);
   QuicConsumedData consumed = creator_.ConsumeData(
       kDataStreamId, &iov_, 1u, iov_.iov_len, 0, FIN_AND_PADDING);
   creator_.Flush();
@@ -3714,11 +3710,11 @@
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillRepeatedly(
           Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
-  MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize), &iov_);
+  MakeIOVector(absl::string_view(buf, kStreamFramePayloadSize), &iov_);
   QuicConsumedData consumed = creator_.ConsumeData(
       kDataStreamId1, &iov_, 1u, iov_.iov_len, 0, FIN_AND_PADDING);
   EXPECT_EQ(kStreamFramePayloadSize, consumed.bytes_consumed);
-  MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize), &iov_);
+  MakeIOVector(absl::string_view(buf, kStreamFramePayloadSize), &iov_);
   consumed = creator_.ConsumeData(kDataStreamId2, &iov_, 1u, iov_.iov_len, 0,
                                   FIN_AND_PADDING);
   EXPECT_EQ(kStreamFramePayloadSize, consumed.bytes_consumed);
diff --git a/quic/core/quic_packets.cc b/quic/core/quic_packets.cc
index f54cf00..0325909 100644
--- a/quic/core/quic_packets.cc
+++ b/quic/core/quic_packets.cc
@@ -6,6 +6,7 @@
 
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
@@ -14,7 +15,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_string_utils.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 quic {
@@ -185,7 +185,7 @@
       long_packet_type(INITIAL),
       possible_stateless_reset_token(0),
       retry_token_length_length(VARIABLE_LENGTH_INTEGER_LENGTH_0),
-      retry_token(quiche::QuicheStringPiece()),
+      retry_token(absl::string_view()),
       length_length(VARIABLE_LENGTH_INTEGER_LENGTH_0),
       remaining_packet_length(0) {}
 
@@ -263,8 +263,8 @@
   }
   if (header.nonce != nullptr) {
     os << ", diversification_nonce: "
-       << quiche::QuicheTextUtils::HexEncode(quiche::QuicheStringPiece(
-              header.nonce->data(), header.nonce->size()));
+       << quiche::QuicheTextUtils::HexEncode(
+              absl::string_view(header.nonce->data(), header.nonce->size()));
   }
   os << ", packet_number: " << header.packet_number << " }\n";
   return os;
@@ -276,7 +276,7 @@
 QuicData::QuicData(const char* buffer, size_t length, bool owns_buffer)
     : buffer_(buffer), length_(length), owns_buffer_(owns_buffer) {}
 
-QuicData::QuicData(quiche::QuicheStringPiece packet_data)
+QuicData::QuicData(absl::string_view packet_data)
     : buffer_(packet_data.data()),
       length_(packet_data.length()),
       owns_buffer_(false) {}
@@ -335,7 +335,7 @@
                                          bool owns_buffer)
     : QuicData(buffer, length, owns_buffer) {}
 
-QuicEncryptedPacket::QuicEncryptedPacket(quiche::QuicheStringPiece data)
+QuicEncryptedPacket::QuicEncryptedPacket(absl::string_view data)
     : QuicData(data) {}
 
 std::unique_ptr<QuicEncryptedPacket> QuicEncryptedPacket::Clone() const {
@@ -426,9 +426,9 @@
   return os;
 }
 
-quiche::QuicheStringPiece QuicPacket::AssociatedData(
+absl::string_view QuicPacket::AssociatedData(
     QuicTransportVersion version) const {
-  return quiche::QuicheStringPiece(
+  return absl::string_view(
       data(),
       GetStartOfEncryptedData(version, destination_connection_id_length_,
                               source_connection_id_length_, includes_version_,
@@ -437,14 +437,13 @@
                               retry_token_length_, length_length_));
 }
 
-quiche::QuicheStringPiece QuicPacket::Plaintext(
-    QuicTransportVersion version) const {
+absl::string_view QuicPacket::Plaintext(QuicTransportVersion version) const {
   const size_t start_of_encrypted_data = GetStartOfEncryptedData(
       version, destination_connection_id_length_, source_connection_id_length_,
       includes_version_, includes_diversification_nonce_, packet_number_length_,
       retry_token_length_length_, retry_token_length_, length_length_);
-  return quiche::QuicheStringPiece(data() + start_of_encrypted_data,
-                                   length() - start_of_encrypted_data);
+  return absl::string_view(data() + start_of_encrypted_data,
+                           length() - start_of_encrypted_data);
 }
 
 SerializedPacket::SerializedPacket(QuicPacketNumber packet_number,
diff --git a/quic/core/quic_packets.h b/quic/core/quic_packets.h
index e9c811c..8cf7305 100644
--- a/quic/core/quic_packets.h
+++ b/quic/core/quic_packets.h
@@ -14,6 +14,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/frames/quic_frame.h"
 #include "net/third_party/quiche/src/quic/core/quic_ack_listener_interface.h"
 #include "net/third_party/quiche/src/quic/core/quic_bandwidth.h"
@@ -25,7 +26,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_uint128.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -160,7 +160,7 @@
   // carried only by v99 IETF Initial packets.
   QuicVariableLengthIntegerLength retry_token_length_length;
   // Retry token, carried only by v99 IETF Initial packets.
-  quiche::QuicheStringPiece retry_token;
+  absl::string_view retry_token;
   // Length of the length variable length integer field,
   // carried only by v99 IETF Initial, 0-RTT and Handshake packets.
   QuicVariableLengthIntegerLength length_length;
@@ -211,15 +211,15 @@
   // Creates a QuicData from a buffer and length,
   // optionally taking ownership of the buffer.
   QuicData(const char* buffer, size_t length, bool owns_buffer);
-  // Creates a QuicData from a quiche::QuicheStringPiece. Does not own the
+  // Creates a QuicData from a absl::string_view. Does not own the
   // buffer.
-  QuicData(quiche::QuicheStringPiece data);
+  QuicData(absl::string_view data);
   QuicData(const QuicData&) = delete;
   QuicData& operator=(const QuicData&) = delete;
   virtual ~QuicData();
 
-  quiche::QuicheStringPiece AsStringPiece() const {
-    return quiche::QuicheStringPiece(data(), length());
+  absl::string_view AsStringPiece() const {
+    return absl::string_view(data(), length());
   }
 
   const char* data() const { return buffer_; }
@@ -252,8 +252,8 @@
   QuicPacket(const QuicPacket&) = delete;
   QuicPacket& operator=(const QuicPacket&) = delete;
 
-  quiche::QuicheStringPiece AssociatedData(QuicTransportVersion version) const;
-  quiche::QuicheStringPiece Plaintext(QuicTransportVersion version) const;
+  absl::string_view AssociatedData(QuicTransportVersion version) const;
+  absl::string_view Plaintext(QuicTransportVersion version) const;
 
   char* mutable_data() { return buffer_; }
 
@@ -277,9 +277,9 @@
   // Creates a QuicEncryptedPacket from a buffer and length,
   // optionally taking ownership of the buffer.
   QuicEncryptedPacket(const char* buffer, size_t length, bool owns_buffer);
-  // Creates a QuicEncryptedPacket from a quiche::QuicheStringPiece.
+  // Creates a QuicEncryptedPacket from a absl::string_view.
   // Does not own the buffer.
-  QuicEncryptedPacket(quiche::QuicheStringPiece data);
+  QuicEncryptedPacket(absl::string_view data);
 
   QuicEncryptedPacket(const QuicEncryptedPacket&) = delete;
   QuicEncryptedPacket& operator=(const QuicEncryptedPacket&) = delete;
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index c186f65..ef651a7 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -7,6 +7,7 @@
 #include <memory>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/frames/quic_ack_frequency_frame.h"
 #include "net/third_party/quiche/src/quic/core/quic_time.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
@@ -16,7 +17,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_sent_packet_manager_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 using testing::_;
 using testing::AnyNumber;
@@ -68,7 +68,7 @@
                      kDefaultLength, HAS_RETRANSMITTABLE_DATA));
     SerializedPacket packet(CreatePacket(packet_number, false));
     packet.retransmittable_frames.push_back(
-        QuicFrame(QuicStreamFrame(1, false, 0, quiche::QuicheStringPiece())));
+        QuicFrame(QuicStreamFrame(1, false, 0, absl::string_view())));
     packet.has_crypto_handshake = IS_HANDSHAKE;
     manager_.OnPacketSent(&packet, clock_.Now(), HANDSHAKE_RETRANSMISSION,
                           HAS_RETRANSMITTABLE_DATA, true);
@@ -252,8 +252,8 @@
                             PACKET_4BYTE_PACKET_NUMBER, nullptr, kDefaultLength,
                             false, false);
     if (retransmittable) {
-      packet.retransmittable_frames.push_back(QuicFrame(
-          QuicStreamFrame(kStreamId, false, 0, quiche::QuicheStringPiece())));
+      packet.retransmittable_frames.push_back(
+          QuicFrame(QuicStreamFrame(kStreamId, false, 0, absl::string_view())));
     }
     return packet;
   }
@@ -299,7 +299,7 @@
                      kDefaultLength, HAS_RETRANSMITTABLE_DATA));
     SerializedPacket packet(CreatePacket(packet_number, false));
     packet.retransmittable_frames.push_back(
-        QuicFrame(QuicStreamFrame(1, false, 0, quiche::QuicheStringPiece())));
+        QuicFrame(QuicStreamFrame(1, false, 0, absl::string_view())));
     packet.has_crypto_handshake = IS_HANDSHAKE;
     manager_.OnPacketSent(&packet, clock_.Now(), NOT_RETRANSMISSION,
                           HAS_RETRANSMITTABLE_DATA, true);
@@ -3091,7 +3091,7 @@
   }
   QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
   // Send SHLO.
-  QuicStreamFrame crypto_frame(1, false, 0, quiche::QuicheStringPiece());
+  QuicStreamFrame crypto_frame(1, false, 0, absl::string_view());
   SendCryptoPacket(1);
   // Send data packet.
   SendDataPacket(2, ENCRYPTION_FORWARD_SECURE);
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 178ddf3..e28db59 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -8,6 +8,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection.h"
 #include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
 #include "net/third_party/quiche/src/quic/core/quic_flow_controller.h"
@@ -23,7 +24,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_server_stats.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_stack_trace.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"
 
 using spdy::SpdyPriority;
 
@@ -343,7 +343,7 @@
   transport_goaway_received_ = true;
 }
 
-void QuicSession::OnMessageReceived(quiche::QuicheStringPiece message) {
+void QuicSession::OnMessageReceived(absl::string_view message) {
   QUIC_DVLOG(1) << ENDPOINT << "Received message, length: " << message.length()
                 << ", " << message;
 }
@@ -2391,13 +2391,13 @@
   return stream_id_manager_.max_open_incoming_streams();
 }
 
-std::vector<quiche::QuicheStringPiece>::const_iterator QuicSession::SelectAlpn(
-    const std::vector<quiche::QuicheStringPiece>& alpns) const {
+std::vector<absl::string_view>::const_iterator QuicSession::SelectAlpn(
+    const std::vector<absl::string_view>& alpns) const {
   const std::string alpn = AlpnForVersion(connection()->version());
   return std::find(alpns.cbegin(), alpns.cend(), alpn);
 }
 
-void QuicSession::OnAlpnSelected(quiche::QuicheStringPiece alpn) {
+void QuicSession::OnAlpnSelected(absl::string_view alpn) {
   QUIC_DLOG(INFO) << (perspective() == Perspective::IS_SERVER ? "Server: "
                                                               : "Client: ")
                   << "ALPN selected: " << alpn;
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index e5a0f5c..a3a982b 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -14,6 +14,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/handshaker_delegate_interface.h"
 #include "net/third_party/quiche/src/quic/core/legacy_quic_stream_id_manager.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection.h"
@@ -34,7 +35,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.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"
 
 namespace quic {
 
@@ -98,7 +98,7 @@
   void OnCryptoFrame(const QuicCryptoFrame& frame) override;
   void OnRstStream(const QuicRstStreamFrame& frame) override;
   void OnGoAway(const QuicGoAwayFrame& frame) override;
-  void OnMessageReceived(quiche::QuicheStringPiece message) override;
+  void OnMessageReceived(absl::string_view message) override;
   void OnHandshakeDoneReceived() override;
   void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
   void OnBlockedFrame(const QuicBlockedFrame& frame) override;
@@ -449,12 +449,12 @@
 
   // Provided a list of ALPNs offered by the client, selects an ALPN from the
   // list, or alpns.end() if none of the ALPNs are acceptable.
-  virtual std::vector<quiche::QuicheStringPiece>::const_iterator SelectAlpn(
-      const std::vector<quiche::QuicheStringPiece>& alpns) const;
+  virtual std::vector<absl::string_view>::const_iterator SelectAlpn(
+      const std::vector<absl::string_view>& alpns) const;
 
   // Called when the ALPN of the connection is established for a connection that
   // uses TLS handshake.
-  virtual void OnAlpnSelected(quiche::QuicheStringPiece alpn);
+  virtual void OnAlpnSelected(absl::string_view alpn);
 
   // Called on clients by the crypto handshaker to provide application state
   // necessary for sending application data in 0-RTT. The state provided here is
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 4c611d1..b2c5b1f 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -9,6 +9,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
 #include "net/third_party/quiche/src/quic/core/crypto/null_decrypter.h"
 #include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
@@ -40,7 +41,6 @@
 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_optional.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"
 
 using spdy::kV3HighestPriority;
 using spdy::SpdyPriority;
@@ -1561,8 +1561,7 @@
                                    /*is_static*/ true, BIDIRECTIONAL);
   QuicSessionPeer::ActivateStream(&session_, std::move(fake_headers_stream));
   // Send two bytes of payload.
-  QuicStreamFrame data1(headers_stream_id, true, 0,
-                        quiche::QuicheStringPiece("HT"));
+  QuicStreamFrame data1(headers_stream_id, true, 0, absl::string_view("HT"));
   EXPECT_CALL(*connection_,
               CloseConnection(
                   QUIC_INVALID_STREAM_ID, "Attempt to close a static stream",
@@ -1574,7 +1573,7 @@
   // Send two bytes of payload.
   QuicStreamFrame data1(
       QuicUtils::GetInvalidStreamId(connection_->transport_version()), true, 0,
-      quiche::QuicheStringPiece("HT"));
+      absl::string_view("HT"));
   EXPECT_CALL(*connection_,
               CloseConnection(
                   QUIC_INVALID_STREAM_ID, "Received data for an invalid stream",
@@ -1763,7 +1762,7 @@
   const QuicStreamOffset kByteOffset = 5678;
   std::string body = "hello";
   QuicStreamFrame frame(stream->id(), true, kByteOffset,
-                        quiche::QuicheStringPiece(body));
+                        absl::string_view(body));
   session_.OnStreamFrame(frame);
 
   QuicStreamOffset total_stream_bytes_sent_by_peer =
@@ -1853,8 +1852,7 @@
   EXPECT_CALL(*connection_, SendControlFrame(_));
   EXPECT_CALL(*connection_, OnStreamReset(stream->id(), _));
   stream->Reset(QUIC_STREAM_CANCELLED);
-  QuicStreamFrame frame(stream->id(), true, kLargeOffset,
-                        quiche::QuicheStringPiece());
+  QuicStreamFrame frame(stream->id(), true, kLargeOffset, absl::string_view());
   session_.OnStreamFrame(frame);
 
   // Check that RST results in connection close.
@@ -1881,7 +1879,7 @@
   // FIN or a RST_STREAM from the client.
   for (QuicStreamId i = kFirstStreamId; i < kFinalStreamId;
        i += QuicUtils::StreamIdDelta(connection_->transport_version())) {
-    QuicStreamFrame data1(i, false, 0, quiche::QuicheStringPiece("HT"));
+    QuicStreamFrame data1(i, false, 0, absl::string_view("HT"));
     session_.OnStreamFrame(data1);
     CloseStream(i);
   }
@@ -1898,8 +1896,7 @@
         .Times(1);
   }
   // Create one more data streams to exceed limit of open stream.
-  QuicStreamFrame data1(kFinalStreamId, false, 0,
-                        quiche::QuicheStringPiece("HT"));
+  QuicStreamFrame data1(kFinalStreamId, false, 0, absl::string_view("HT"));
   session_.OnStreamFrame(data1);
 }
 
@@ -1909,7 +1906,7 @@
   // protocol point of view).
   TestStream* stream = session_.CreateOutgoingBidirectionalStream();
   QuicStreamId stream_id = stream->id();
-  QuicStreamFrame data1(stream_id, true, 0, quiche::QuicheStringPiece("HT"));
+  QuicStreamFrame data1(stream_id, true, 0, absl::string_view("HT"));
   session_.OnStreamFrame(data1);
   EXPECT_CALL(session_, OnCanCreateNewOutgoingStream(false)).Times(1);
   session_.StreamDraining(stream_id, /*unidirectional=*/false);
@@ -1920,11 +1917,11 @@
 
   QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
       transport_version(), Perspective::IS_CLIENT);
-  QuicStreamFrame data1(stream_id, true, 10, quiche::QuicheStringPiece("HT"));
+  QuicStreamFrame data1(stream_id, true, 10, absl::string_view("HT"));
   session_.OnStreamFrame(data1);
   EXPECT_EQ(1, session_.num_incoming_streams_created());
 
-  QuicStreamFrame data2(stream_id, false, 0, quiche::QuicheStringPiece("HT"));
+  QuicStreamFrame data2(stream_id, false, 0, absl::string_view("HT"));
   session_.OnStreamFrame(data2);
   EXPECT_EQ(1, session_.num_incoming_streams_created());
 }
@@ -1937,12 +1934,12 @@
 
   QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
       transport_version(), Perspective::IS_CLIENT);
-  QuicStreamFrame data1(stream_id, true, 10, quiche::QuicheStringPiece("HT"));
+  QuicStreamFrame data1(stream_id, true, 10, absl::string_view("HT"));
   session_.OnStreamFrame(data1);
   EXPECT_TRUE(QuicSessionPeer::GetPendingStream(&session_, stream_id));
   EXPECT_EQ(0, session_.num_incoming_streams_created());
 
-  QuicStreamFrame data2(stream_id, false, 0, quiche::QuicheStringPiece("HT"));
+  QuicStreamFrame data2(stream_id, false, 0, absl::string_view("HT"));
   session_.OnStreamFrame(data2);
   EXPECT_FALSE(QuicSessionPeer::GetPendingStream(&session_, stream_id));
   EXPECT_EQ(1, session_.num_incoming_streams_created());
@@ -1956,7 +1953,7 @@
 
   QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
       transport_version(), Perspective::IS_CLIENT);
-  QuicStreamFrame data1(stream_id, true, 10, quiche::QuicheStringPiece("HT"));
+  QuicStreamFrame data1(stream_id, true, 10, absl::string_view("HT"));
   session_.OnStreamFrame(data1);
   EXPECT_TRUE(QuicSessionPeer::GetPendingStream(&session_, stream_id));
   EXPECT_EQ(0, session_.num_incoming_streams_created());
@@ -1969,7 +1966,7 @@
   EXPECT_EQ(0, session_.num_incoming_streams_created());
   EXPECT_EQ(0u, QuicSessionPeer::GetNumOpenDynamicStreams(&session_));
 
-  QuicStreamFrame data2(stream_id, false, 0, quiche::QuicheStringPiece("HT"));
+  QuicStreamFrame data2(stream_id, false, 0, absl::string_view("HT"));
   session_.OnStreamFrame(data2);
   EXPECT_FALSE(QuicSessionPeer::GetPendingStream(&session_, stream_id));
   EXPECT_EQ(0, session_.num_incoming_streams_created());
@@ -2000,7 +1997,7 @@
   session_.set_uses_pending_streams(true);
   QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
       transport_version(), Perspective::IS_CLIENT);
-  QuicStreamFrame data1(stream_id, true, 10, quiche::QuicheStringPiece("HT"));
+  QuicStreamFrame data1(stream_id, true, 10, absl::string_view("HT"));
   session_.OnStreamFrame(data1);
   EXPECT_TRUE(QuicSessionPeer::GetPendingStream(&session_, stream_id));
   EXPECT_EQ(0, session_.num_incoming_streams_created());
@@ -2040,7 +2037,7 @@
       GetNthClientInitiatedBidirectionalId(2 * kMaxStreams + 1);
   for (QuicStreamId i = kFirstStreamId; i < kFinalStreamId;
        i += QuicUtils::StreamIdDelta(connection_->transport_version())) {
-    QuicStreamFrame data1(i, true, 0, quiche::QuicheStringPiece("HT"));
+    QuicStreamFrame data1(i, true, 0, absl::string_view("HT"));
     session_.OnStreamFrame(data1);
     EXPECT_EQ(1u, QuicSessionPeer::GetNumOpenDynamicStreams(&session_));
     session_.StreamDraining(i, /*unidirectional=*/false);
@@ -2184,7 +2181,7 @@
   QuicStreamPeer::CloseReadSide(stream);
 
   // Receive a stream data frame with FIN.
-  QuicStreamFrame frame(stream_id, true, 0, quiche::QuicheStringPiece());
+  QuicStreamFrame frame(stream_id, true, 0, absl::string_view());
   session_.OnStreamFrame(frame);
   EXPECT_TRUE(stream->fin_received());
 
@@ -2217,7 +2214,7 @@
 
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(1),
                         /* fin = */ false, /* offset = */ 0,
-                        quiche::QuicheStringPiece("foo"));
+                        absl::string_view("foo"));
   session_.OnStreamFrame(frame);
 }
 
@@ -2540,7 +2537,7 @@
   session_.GetMutableCryptoStream()->OnHandshakeMessage(handshake_message);
   EXPECT_TRUE(session_.OneRttKeysAvailable());
 
-  quiche::QuicheStringPiece message;
+  absl::string_view message;
   EXPECT_CALL(*connection_, SendMessage(1, _, false))
       .WillOnce(Return(MESSAGE_STATUS_SUCCESS));
   EXPECT_EQ(MessageResult(MESSAGE_STATUS_SUCCESS, 1),
@@ -3043,7 +3040,7 @@
 
   QuicStreamFrame frame(GetNthServerInitiatedBidirectionalId(1),
                         /* fin = */ false, /* offset = */ 0,
-                        quiche::QuicheStringPiece("foo"));
+                        absl::string_view("foo"));
   session_.OnStreamFrame(frame);
 }
 
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index 1ad8d37..b6d2cfd 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -7,6 +7,7 @@
 #include <limits>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
 #include "net/third_party/quiche/src/quic/core/quic_flow_controller.h"
 #include "net/third_party/quiche/src/quic/core/quic_session.h"
@@ -18,7 +19,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_optional.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"
 
 using quiche::QuicheOptional;
 using spdy::SpdyPriority;
@@ -623,7 +623,7 @@
 }
 
 void QuicStream::WriteOrBufferData(
-    quiche::QuicheStringPiece data,
+    absl::string_view data,
     bool fin,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   if (data.empty() && !fin) {
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index f0a5a71..70e6e98 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -22,6 +22,7 @@
 #include <list>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_flow_controller.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
 #include "net/third_party/quiche/src/quic/core/quic_stream_send_buffer.h"
@@ -33,7 +34,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_mem_slice_span.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_reference_counted.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/third_party/quiche/src/spdy/core/spdy_protocol.h"
 
 namespace quic {
@@ -279,7 +279,7 @@
   // If fin is true: if it is immediately passed on to the session,
   // write_side_closed() becomes true, otherwise fin_buffered_ becomes true.
   void WriteOrBufferData(
-      quiche::QuicheStringPiece data,
+      absl::string_view data,
       bool fin,
       QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
 
diff --git a/quic/core/quic_stream_send_buffer_test.cc b/quic/core/quic_stream_send_buffer_test.cc
index 6232887..0d5471e 100644
--- a/quic/core/quic_stream_send_buffer_test.cc
+++ b/quic/core/quic_stream_send_buffer_test.cc
@@ -6,6 +6,7 @@
 
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
 #include "net/third_party/quiche/src/quic/core/quic_simple_buffer_allocator.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
@@ -15,13 +16,12 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_test_mem_slice_vector.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_stream_send_buffer_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
 namespace {
 
-struct iovec MakeIovec(quiche::QuicheStringPiece data) {
+struct iovec MakeIovec(absl::string_view data) {
   struct iovec iov = {const_cast<char*>(data.data()),
                       static_cast<size_t>(data.size())};
   return iov;
@@ -36,8 +36,8 @@
     std::string data1(1536, 'a');
     std::string data2 = std::string(256, 'b') + std::string(256, 'c');
     struct iovec iov[2];
-    iov[0] = MakeIovec(quiche::QuicheStringPiece(data1));
-    iov[1] = MakeIovec(quiche::QuicheStringPiece(data2));
+    iov[0] = MakeIovec(absl::string_view(data1));
+    iov[1] = MakeIovec(absl::string_view(data2));
 
     QuicUniqueBufferPtr buffer1 = MakeUniqueBuffer(&allocator_, 1024);
     memset(buffer1.get(), 'c', 1024);
@@ -88,23 +88,23 @@
   std::string copy4(768, 'd');
 
   ASSERT_TRUE(send_buffer_.WriteStreamData(0, 1024, &writer));
-  EXPECT_EQ(copy1, quiche::QuicheStringPiece(buf, 1024));
+  EXPECT_EQ(copy1, absl::string_view(buf, 1024));
   ASSERT_TRUE(send_buffer_.WriteStreamData(1024, 1024, &writer));
-  EXPECT_EQ(copy2, quiche::QuicheStringPiece(buf + 1024, 1024));
+  EXPECT_EQ(copy2, absl::string_view(buf + 1024, 1024));
   ASSERT_TRUE(send_buffer_.WriteStreamData(2048, 1024, &writer));
-  EXPECT_EQ(copy3, quiche::QuicheStringPiece(buf + 2048, 1024));
+  EXPECT_EQ(copy3, absl::string_view(buf + 2048, 1024));
   ASSERT_TRUE(send_buffer_.WriteStreamData(3072, 768, &writer));
-  EXPECT_EQ(copy4, quiche::QuicheStringPiece(buf + 3072, 768));
+  EXPECT_EQ(copy4, absl::string_view(buf + 3072, 768));
 
   // Test data piece across boundries.
   QuicDataWriter writer2(4000, buf, quiche::HOST_BYTE_ORDER);
   std::string copy5 =
       std::string(536, 'a') + std::string(256, 'b') + std::string(232, 'c');
   ASSERT_TRUE(send_buffer_.WriteStreamData(1000, 1024, &writer2));
-  EXPECT_EQ(copy5, quiche::QuicheStringPiece(buf, 1024));
+  EXPECT_EQ(copy5, absl::string_view(buf, 1024));
   ASSERT_TRUE(send_buffer_.WriteStreamData(2500, 1024, &writer2));
   std::string copy6 = std::string(572, 'c') + std::string(452, 'd');
-  EXPECT_EQ(copy6, quiche::QuicheStringPiece(buf + 1024, 1024));
+  EXPECT_EQ(copy6, absl::string_view(buf + 1024, 1024));
 
   // Invalid data copy.
   QuicDataWriter writer3(4000, buf, quiche::HOST_BYTE_ORDER);
@@ -129,21 +129,20 @@
   // Write more than one slice.
   EXPECT_EQ(0, QuicStreamSendBufferPeer::write_index(&send_buffer_));
   ASSERT_TRUE(send_buffer_.WriteStreamData(0, 1024, &writer));
-  EXPECT_EQ(copy1, quiche::QuicheStringPiece(buf, 1024));
+  EXPECT_EQ(copy1, absl::string_view(buf, 1024));
   EXPECT_EQ(1, QuicStreamSendBufferPeer::write_index(&send_buffer_));
 
   // Retransmit the first frame and also send new data.
   ASSERT_TRUE(send_buffer_.WriteStreamData(0, 2048, &writer));
-  EXPECT_EQ(copy1 + copy2, quiche::QuicheStringPiece(buf + 1024, 2048));
+  EXPECT_EQ(copy1 + copy2, absl::string_view(buf + 1024, 2048));
 
   // Write new data.
   EXPECT_EQ(2048u, QuicStreamSendBufferPeer::EndOffset(&send_buffer_));
   ASSERT_TRUE(send_buffer_.WriteStreamData(2048, 50, &writer));
-  EXPECT_EQ(std::string(50, 'c'),
-            quiche::QuicheStringPiece(buf + 1024 + 2048, 50));
+  EXPECT_EQ(std::string(50, 'c'), absl::string_view(buf + 1024 + 2048, 50));
   EXPECT_EQ(3072u, QuicStreamSendBufferPeer::EndOffset(&send_buffer_));
   ASSERT_TRUE(send_buffer_.WriteStreamData(2048, 1124, &writer));
-  EXPECT_EQ(copy3, quiche::QuicheStringPiece(buf + 1024 + 2048 + 50, 1124));
+  EXPECT_EQ(copy3, absl::string_view(buf + 1024 + 2048 + 50, 1124));
   EXPECT_EQ(3840u, QuicStreamSendBufferPeer::EndOffset(&send_buffer_));
 }
 
diff --git a/quic/core/quic_stream_sequencer.cc b/quic/core/quic_stream_sequencer.cc
index 0dfc8f7..7d1c237 100644
--- a/quic/core/quic_stream_sequencer.cc
+++ b/quic/core/quic_stream_sequencer.cc
@@ -10,6 +10,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_clock.h"
 #include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
@@ -22,7 +23,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_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"
 
 namespace quic {
 
@@ -65,8 +65,8 @@
   size_t bytes_written;
   std::string error_details;
   QuicErrorCode result = buffered_frames_.OnStreamData(
-      byte_offset, quiche::QuicheStringPiece(data_buffer, data_len),
-      &bytes_written, &error_details);
+      byte_offset, absl::string_view(data_buffer, data_len), &bytes_written,
+      &error_details);
   if (result != QUIC_NO_ERROR) {
     std::string details = quiche::QuicheStrCat("Stream ", stream_->id(), ": ",
                                                QuicErrorCodeToString(result),
diff --git a/quic/core/quic_stream_sequencer_buffer.cc b/quic/core/quic_stream_sequencer_buffer.cc
index 8a26521..b4143ef 100644
--- a/quic/core/quic_stream_sequencer_buffer.cc
+++ b/quic/core/quic_stream_sequencer_buffer.cc
@@ -6,6 +6,7 @@
 
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_constants.h"
 #include "net/third_party/quiche/src/quic/core/quic_interval.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
@@ -13,7 +14,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_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"
 
 namespace quic {
 namespace {
@@ -68,7 +68,7 @@
 
 QuicErrorCode QuicStreamSequencerBuffer::OnStreamData(
     QuicStreamOffset starting_offset,
-    quiche::QuicheStringPiece data,
+    absl::string_view data,
     size_t* const bytes_buffered,
     std::string* error_details) {
   *bytes_buffered = 0;
@@ -135,7 +135,7 @@
 }
 
 bool QuicStreamSequencerBuffer::CopyStreamData(QuicStreamOffset offset,
-                                               quiche::QuicheStringPiece data,
+                                               absl::string_view data,
                                                size_t* bytes_copy,
                                                std::string* error_details) {
   *bytes_copy = 0;
diff --git a/quic/core/quic_stream_sequencer_buffer.h b/quic/core/quic_stream_sequencer_buffer.h
index 0ad9841..98ffa9c 100644
--- a/quic/core/quic_stream_sequencer_buffer.h
+++ b/quic/core/quic_stream_sequencer_buffer.h
@@ -28,11 +28,11 @@
 // Expected Use:
 //  QuicStreamSequencerBuffer buffer(2.5 * 8 * 1024);
 //  std::string source(1024, 'a');
-//  quiche::QuicheStringPiece string_piece(source.data(), source.size());
+//  absl::string_view string_piece(source.data(), source.size());
 //  size_t written = 0;
 //  buffer.OnStreamData(800, string_piece, GetEpollClockNow(), &written);
 //  source = std::string{800, 'b'};
-//  quiche::QuicheStringPiece string_piece1(source.data(), 800);
+//  absl::string_view string_piece1(source.data(), 800);
 //  // Try to write to [1, 801), but should fail due to overlapping,
 //  // res should be QUIC_INVALID_STREAM_DATA
 //  auto res = buffer.OnStreamData(1, string_piece1, &written));
@@ -64,12 +64,12 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_interval_set.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_iovec.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -107,7 +107,7 @@
   // successfully buffered, returns QUIC_NO_ERROR and stores the number of
   // bytes buffered in |bytes_buffered|. Returns an error otherwise.
   QuicErrorCode OnStreamData(QuicStreamOffset offset,
-                             quiche::QuicheStringPiece data,
+                             absl::string_view data,
                              size_t* bytes_buffered,
                              std::string* error_details);
 
@@ -168,7 +168,7 @@
   // Copies |data| to blocks_, sets |bytes_copy|. Returns true if the copy is
   // successful. Otherwise, sets |error_details| and returns false.
   bool CopyStreamData(QuicStreamOffset offset,
-                      quiche::QuicheStringPiece data,
+                      absl::string_view data,
                       size_t* bytes_copy,
                       std::string* error_details);
 
diff --git a/quic/core/quic_stream_sequencer_buffer_test.cc b/quic/core/quic_stream_sequencer_buffer_test.cc
index 7341983..f12810b 100644
--- a/quic/core/quic_stream_sequencer_buffer_test.cc
+++ b/quic/core/quic_stream_sequencer_buffer_test.cc
@@ -11,20 +11,20 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_stream_sequencer_buffer_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.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 quic {
 
 namespace test {
 
-quiche::QuicheStringPiece IovecToStringPiece(iovec iov) {
-  return quiche::QuicheStringPiece(reinterpret_cast<const char*>(iov.iov_base),
-                                   iov.iov_len);
+absl::string_view IovecToStringPiece(iovec iov) {
+  return absl::string_view(reinterpret_cast<const char*>(iov.iov_base),
+                           iov.iov_len);
 }
 
 char GetCharFromIOVecs(size_t offset, iovec iov[], size_t count) {
@@ -159,8 +159,8 @@
 
 TEST_F(QuicStreamSequencerBufferTest, OnStreamDataInvalidSource) {
   // Pass in an invalid source, expects to return error.
-  quiche::QuicheStringPiece source;
-  source = quiche::QuicheStringPiece(nullptr, 1024);
+  absl::string_view source;
+  source = absl::string_view(nullptr, 1024);
   EXPECT_THAT(buffer_->OnStreamData(800, source, &written_, &error_details_),
               IsError(QUIC_STREAM_SEQUENCER_INVALID_STATE));
   EXPECT_EQ(0u, error_details_.find(quiche::QuicheStrCat(
@@ -320,7 +320,7 @@
   QUIC_LOG(ERROR) << error_details_;
   EXPECT_EQ(100u, read);
   EXPECT_EQ(100u, buffer_->BytesConsumed());
-  EXPECT_EQ(source, quiche::QuicheStringPiece(dest, read));
+  EXPECT_EQ(source, absl::string_view(dest, read));
   // The first block should be released as its data has been read out.
   EXPECT_EQ(nullptr, helper_->GetBlock(0));
   EXPECT_TRUE(helper_->CheckBufferInvariants());
@@ -610,8 +610,7 @@
 
   // Peek at a different offset.
   EXPECT_TRUE(buffer_->PeekRegion(100, &iov));
-  EXPECT_EQ(quiche::QuicheStringPiece(source).substr(100),
-            IovecToStringPiece(iov));
+  EXPECT_EQ(absl::string_view(source).substr(100), IovecToStringPiece(iov));
 
   // Peeking at or after FirstMissingByte() returns false.
   EXPECT_FALSE(buffer_->PeekRegion(kBlockSizeBytes, &iov));
@@ -638,15 +637,15 @@
   // Peek with an offset inside the first write.
   const QuicStreamOffset offset1 = 500;
   EXPECT_TRUE(buffer_->PeekRegion(offset1, &iov));
-  EXPECT_EQ(quiche::QuicheStringPiece(source1).substr(offset1),
+  EXPECT_EQ(absl::string_view(source1).substr(offset1),
             IovecToStringPiece(iov).substr(0, length1 - offset1));
-  EXPECT_EQ(quiche::QuicheStringPiece(source2),
+  EXPECT_EQ(absl::string_view(source2),
             IovecToStringPiece(iov).substr(length1 - offset1));
 
   // Peek with an offset inside the second write.
   const QuicStreamOffset offset2 = 1500;
   EXPECT_TRUE(buffer_->PeekRegion(offset2, &iov));
-  EXPECT_EQ(quiche::QuicheStringPiece(source2).substr(offset2 - length1),
+  EXPECT_EQ(absl::string_view(source2).substr(offset2 - length1),
             IovecToStringPiece(iov));
 
   // Peeking at or after FirstMissingByte() returns false.
@@ -671,19 +670,16 @@
   EXPECT_TRUE(buffer_->PeekRegion(0, &iov));
   EXPECT_EQ(kBlockSizeBytes, iov.iov_len);
   EXPECT_EQ(source1, IovecToStringPiece(iov).substr(0, length1));
-  EXPECT_EQ(
-      quiche::QuicheStringPiece(source2).substr(0, kBlockSizeBytes - length1),
-      IovecToStringPiece(iov).substr(length1));
+  EXPECT_EQ(absl::string_view(source2).substr(0, kBlockSizeBytes - length1),
+            IovecToStringPiece(iov).substr(length1));
 
   EXPECT_TRUE(buffer_->PeekRegion(length1, &iov));
-  EXPECT_EQ(
-      quiche::QuicheStringPiece(source2).substr(0, kBlockSizeBytes - length1),
-      IovecToStringPiece(iov));
+  EXPECT_EQ(absl::string_view(source2).substr(0, kBlockSizeBytes - length1),
+            IovecToStringPiece(iov));
 
   EXPECT_TRUE(buffer_->PeekRegion(kBlockSizeBytes, &iov));
-  EXPECT_EQ(
-      quiche::QuicheStringPiece(source2).substr(kBlockSizeBytes - length1),
-      IovecToStringPiece(iov));
+  EXPECT_EQ(absl::string_view(source2).substr(kBlockSizeBytes - length1),
+            IovecToStringPiece(iov));
 
   // Peeking at or after FirstMissingByte() returns false.
   EXPECT_FALSE(buffer_->PeekRegion(length1 + length2, &iov));
@@ -706,12 +702,10 @@
   EXPECT_FALSE(buffer_->PeekRegion(512, &iov));
 
   EXPECT_TRUE(buffer_->PeekRegion(1024, &iov));
-  EXPECT_EQ(quiche::QuicheStringPiece(source1).substr(1024),
-            IovecToStringPiece(iov));
+  EXPECT_EQ(absl::string_view(source1).substr(1024), IovecToStringPiece(iov));
 
   EXPECT_TRUE(buffer_->PeekRegion(1500, &iov));
-  EXPECT_EQ(quiche::QuicheStringPiece(source1).substr(1500),
-            IovecToStringPiece(iov));
+  EXPECT_EQ(absl::string_view(source1).substr(1500), IovecToStringPiece(iov));
 
   // Consume rest of block.
   EXPECT_TRUE(buffer_->MarkConsumed(kBlockSizeBytes - 1024));
@@ -725,8 +719,7 @@
   EXPECT_EQ(source2, IovecToStringPiece(iov));
 
   EXPECT_TRUE(buffer_->PeekRegion(kBlockSizeBytes + 128, &iov));
-  EXPECT_EQ(quiche::QuicheStringPiece(source2).substr(128),
-            IovecToStringPiece(iov));
+  EXPECT_EQ(absl::string_view(source2).substr(128), IovecToStringPiece(iov));
 
   // Peeking into consumed data still fails.
   EXPECT_FALSE(buffer_->PeekRegion(0, &iov));
@@ -933,7 +926,7 @@
     for (size_t i = 0; i < num_to_write; ++i) {
       write_buf[i] = (offset + i) % 256;
     }
-    quiche::QuicheStringPiece string_piece_w(write_buf.get(), num_to_write);
+    absl::string_view string_piece_w(write_buf.get(), num_to_write);
     auto result = buffer_->OnStreamData(offset, string_piece_w, &written_,
                                         &error_details_);
     if (result == QUIC_NO_ERROR) {
diff --git a/quic/core/quic_stream_sequencer_test.cc b/quic/core/quic_stream_sequencer_test.cc
index bdf1412..cd39fcd 100644
--- a/quic/core/quic_stream_sequencer_test.cc
+++ b/quic/core/quic_stream_sequencer_test.cc
@@ -11,6 +11,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_stream.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
@@ -20,7 +21,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_stream_sequencer_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 using testing::_;
 using testing::AnyNumber;
@@ -116,7 +116,7 @@
     return true;
   }
 
-  bool VerifyIovec(const iovec& iovec, quiche::QuicheStringPiece expected) {
+  bool VerifyIovec(const iovec& iovec, absl::string_view expected) {
     if (iovec.iov_len != expected.length()) {
       QUIC_LOG(ERROR) << "Invalid length: " << iovec.iov_len << " vs "
                       << expected.length();
@@ -600,10 +600,10 @@
   // overlapping byte ranges - if they do, we close the connection.
   QuicStreamId id = 1;
 
-  QuicStreamFrame frame1(id, false, 1, quiche::QuicheStringPiece("hello"));
+  QuicStreamFrame frame1(id, false, 1, absl::string_view("hello"));
   sequencer_->OnStreamFrame(frame1);
 
-  QuicStreamFrame frame2(id, false, 2, quiche::QuicheStringPiece("hello"));
+  QuicStreamFrame frame2(id, false, 2, absl::string_view("hello"));
   EXPECT_CALL(stream_, OnUnrecoverableError(QUIC_OVERLAPPING_STREAM_DATA, _))
       .Times(0);
   sequencer_->OnStreamFrame(frame2);
@@ -635,7 +635,7 @@
   EXPECT_EQ(0u, sequencer_->NumBytesBuffered());
 
   // Received [1498, 1503).
-  QuicStreamFrame frame3(id, false, 1498, quiche::QuicheStringPiece("hello"));
+  QuicStreamFrame frame3(id, false, 1498, absl::string_view("hello"));
   EXPECT_CALL(stream_, OnDataAvailable());
   sequencer_->OnStreamFrame(frame3);
   EXPECT_CALL(stream_, AddBytesConsumed(3));
@@ -644,7 +644,7 @@
   EXPECT_EQ(0u, sequencer_->NumBytesBuffered());
 
   // Received [1000, 1005).
-  QuicStreamFrame frame4(id, false, 1000, quiche::QuicheStringPiece("hello"));
+  QuicStreamFrame frame4(id, false, 1000, absl::string_view("hello"));
   EXPECT_CALL(stream_, OnDataAvailable()).Times(0);
   sequencer_->OnStreamFrame(frame4);
   EXPECT_EQ(1503u, sequencer_->NumBytesConsumed());
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index f2b5563..77b548a 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -8,6 +8,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/frames/quic_rst_stream_frame.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection.h"
 #include "net/third_party/quiche/src/quic/core/quic_constants.h"
@@ -32,7 +33,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.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"
 
 using testing::_;
 using testing::AnyNumber;
@@ -295,8 +295,7 @@
   // Write no data and no fin.  If we consume nothing we should not be write
   // blocked.
   EXPECT_QUIC_BUG(
-      stream_->WriteOrBufferData(quiche::QuicheStringPiece(), false, nullptr),
-      "");
+      stream_->WriteOrBufferData(absl::string_view(), false, nullptr), "");
   EXPECT_FALSE(HasWriteBlockedStreams());
 }
 
@@ -310,8 +309,7 @@
         return session_->ConsumeData(stream_->id(), 1u, 0u, NO_FIN,
                                      NOT_RETRANSMISSION, QUICHE_NULLOPT);
       }));
-  stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 2), false,
-                             nullptr);
+  stream_->WriteOrBufferData(absl::string_view(kData1, 2), false, nullptr);
   EXPECT_TRUE(session_->HasUnackedStreamData());
   ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
   EXPECT_EQ(1u, stream_->BufferedDataBytes());
@@ -329,8 +327,7 @@
         return session_->ConsumeData(stream_->id(), 2u, 0u, NO_FIN,
                                      NOT_RETRANSMISSION, QUICHE_NULLOPT);
       }));
-  stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 2), true,
-                             nullptr);
+  stream_->WriteOrBufferData(absl::string_view(kData1, 2), true, nullptr);
   EXPECT_TRUE(session_->HasUnackedStreamData());
   ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
 }
@@ -342,7 +339,7 @@
   // as the fin was not consumed.
   EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
       .WillOnce(Return(QuicConsumedData(0, false)));
-  stream_->WriteOrBufferData(quiche::QuicheStringPiece(), true, nullptr);
+  stream_->WriteOrBufferData(absl::string_view(), true, nullptr);
   ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
 }
 
@@ -354,8 +351,7 @@
   // crash with an unknown stream.
   EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _, _))
       .WillOnce(Invoke(this, &QuicStreamTest::CloseStreamOnWriteError));
-  stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 2), false,
-                             nullptr);
+  stream_->WriteOrBufferData(absl::string_view(kData1, 2), false, nullptr);
   ASSERT_EQ(0u, write_blocked_list_->NumBlockedStreams());
 }
 
@@ -452,8 +448,7 @@
         return session_->ConsumeData(stream_->id(), 1u, 0u, NO_FIN,
                                      NOT_RETRANSMISSION, QUICHE_NULLOPT);
       }));
-  stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 1), false,
-                             nullptr);
+  stream_->WriteOrBufferData(absl::string_view(kData1, 1), false, nullptr);
   EXPECT_TRUE(session_->HasUnackedStreamData());
   EXPECT_FALSE(fin_sent());
   EXPECT_FALSE(rst_sent());
@@ -482,8 +477,7 @@
         return session_->ConsumeData(stream_->id(), 1u, 0u, FIN,
                                      NOT_RETRANSMISSION, QUICHE_NULLOPT);
       }));
-  stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 1), true,
-                             nullptr);
+  stream_->WriteOrBufferData(absl::string_view(kData1, 1), true, nullptr);
   EXPECT_TRUE(fin_sent());
   EXPECT_FALSE(rst_sent());
 
@@ -673,7 +667,7 @@
             current_connection_flow_control_offset);
   QuicStreamFrame zero_length_stream_frame_with_fin(
       stream_->id(), /*fin=*/true, kByteOffsetExceedingFlowControlWindow,
-      quiche::QuicheStringPiece());
+      absl::string_view());
   EXPECT_EQ(0, zero_length_stream_frame_with_fin.data_length);
 
   EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
@@ -746,8 +740,7 @@
         return session_->ConsumeData(stream_->id(), 2u, 0u, FIN,
                                      NOT_RETRANSMISSION, QUICHE_NULLOPT);
       }));
-  stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 2), true,
-                             nullptr);
+  stream_->WriteOrBufferData(absl::string_view(kData1, 2), true, nullptr);
   EXPECT_TRUE(stream_->write_side_closed());
 
   EXPECT_EQ(1u, QuicSessionPeer::GetNumDrainingStreams(session_.get()));
@@ -764,8 +757,7 @@
         return session_->ConsumeData(stream_->id(), 2u, 0u, FIN,
                                      NOT_RETRANSMISSION, QUICHE_NULLOPT);
       }));
-  stream_->WriteOrBufferData(quiche::QuicheStringPiece(kData1, 2), true,
-                             nullptr);
+  stream_->WriteOrBufferData(absl::string_view(kData1, 2), true, nullptr);
   EXPECT_TRUE(stream_->write_side_closed());
 
   EXPECT_EQ(1u, QuicSessionPeer::GetNumOpenDynamicStreams(session_.get()));
diff --git a/quic/core/quic_tag.cc b/quic/core/quic_tag.cc
index d6c2f6c..7cc25e0 100644
--- a/quic/core/quic_tag.cc
+++ b/quic/core/quic_tag.cc
@@ -74,7 +74,7 @@
          tag_vector.end();
 }
 
-QuicTag ParseQuicTag(quiche::QuicheStringPiece tag_string) {
+QuicTag ParseQuicTag(absl::string_view tag_string) {
   quiche::QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(&tag_string);
   std::string tag_bytes;
   if (tag_string.length() == 8) {
@@ -92,13 +92,13 @@
   return tag;
 }
 
-QuicTagVector ParseQuicTagVector(quiche::QuicheStringPiece tags_string) {
+QuicTagVector ParseQuicTagVector(absl::string_view tags_string) {
   QuicTagVector tag_vector;
   quiche::QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(&tags_string);
   if (!tags_string.empty()) {
-    std::vector<quiche::QuicheStringPiece> tag_strings =
+    std::vector<absl::string_view> tag_strings =
         quiche::QuicheTextUtils::Split(tags_string, ',');
-    for (quiche::QuicheStringPiece tag_string : tag_strings) {
+    for (absl::string_view tag_string : tag_strings) {
       tag_vector.push_back(ParseQuicTag(tag_string));
     }
   }
diff --git a/quic/core/quic_tag.h b/quic/core/quic_tag.h
index 7ba6cfc..8b68e33 100644
--- a/quic/core/quic_tag.h
+++ b/quic/core/quic_tag.h
@@ -9,8 +9,8 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -53,12 +53,12 @@
 // corresponding QuicTag. Note that tags that are less than four characters
 // long are right-padded with zeroes. Tags that contain non-ASCII characters
 // are represented as 8-character-long hexadecimal strings.
-QUIC_EXPORT_PRIVATE QuicTag ParseQuicTag(quiche::QuicheStringPiece tag_string);
+QUIC_EXPORT_PRIVATE QuicTag ParseQuicTag(absl::string_view tag_string);
 
 // Utility function that converts a string of the form "ABCD,EFGH" to a vector
 // of the form {kABCD,kEFGH}. Note the caveats on ParseQuicTag.
 QUIC_EXPORT_PRIVATE QuicTagVector
-ParseQuicTagVector(quiche::QuicheStringPiece tags_string);
+ParseQuicTagVector(absl::string_view tags_string);
 
 }  // namespace quic
 
diff --git a/quic/core/quic_time_wait_list_manager.cc b/quic/core/quic_time_wait_list_manager.cc
index a09caac..769a9c5 100644
--- a/quic/core/quic_time_wait_list_manager.cc
+++ b/quic/core/quic_time_wait_list_manager.cc
@@ -9,6 +9,7 @@
 #include <memory>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h"
@@ -22,7 +23,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.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 quic {
@@ -239,7 +239,7 @@
                 << (ietf_quic ? "" : "!") << "ietf_quic, "
                 << (use_length_prefix ? "" : "!")
                 << "use_length_prefix:" << std::endl
-                << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
+                << quiche::QuicheTextUtils::HexDump(absl::string_view(
                        version_packet->data(), version_packet->length()));
   SendOrQueuePacket(std::make_unique<QueuedPacket>(self_address, peer_address,
                                                    std::move(version_packet)),
@@ -263,9 +263,9 @@
         BuildIetfStatelessResetPacket(connection_id);
     QUIC_DVLOG(2) << "Dispatcher sending IETF reset packet for "
                   << connection_id << std::endl
-                  << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
-                         ietf_reset_packet->data(),
-                         ietf_reset_packet->length()));
+                  << quiche::QuicheTextUtils::HexDump(
+                         absl::string_view(ietf_reset_packet->data(),
+                                           ietf_reset_packet->length()));
     SendOrQueuePacket(
         std::make_unique<QueuedPacket>(self_address, peer_address,
                                        std::move(ietf_reset_packet)),
@@ -283,7 +283,7 @@
   std::unique_ptr<QuicEncryptedPacket> reset_packet = BuildPublicReset(packet);
   QUIC_DVLOG(2) << "Dispatcher sending reset packet for " << connection_id
                 << std::endl
-                << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
+                << quiche::QuicheTextUtils::HexDump(absl::string_view(
                        reset_packet->data(), reset_packet->length()));
   SendOrQueuePacket(std::make_unique<QueuedPacket>(self_address, peer_address,
                                                    std::move(reset_packet)),
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index b6619d4..2e1562f 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -9,6 +9,7 @@
 #include <cstring>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
 #include "net/third_party/quiche/src/quic/core/quic_constants.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
@@ -21,7 +22,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_uint128.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_string_piece.h"
 
 namespace quic {
 namespace {
@@ -36,8 +36,7 @@
 #endif
 
 #ifdef QUIC_UTIL_HAS_UINT128
-QuicUint128 IncrementalHashFast(QuicUint128 uhash,
-                                quiche::QuicheStringPiece data) {
+QuicUint128 IncrementalHashFast(QuicUint128 uhash, absl::string_view data) {
   // This code ends up faster than the naive implementation for 2 reasons:
   // 1. QuicUint128 is sufficiently complicated that the compiler
   //    cannot transform the multiplication by kPrime into a shift-multiply-add;
@@ -60,8 +59,7 @@
 
 #ifndef QUIC_UTIL_HAS_UINT128
 // Slow implementation of IncrementalHash. In practice, only used by Chromium.
-QuicUint128 IncrementalHashSlow(QuicUint128 hash,
-                                quiche::QuicheStringPiece data) {
+QuicUint128 IncrementalHashSlow(QuicUint128 hash, absl::string_view data) {
   // kPrime = 309485009821345068724781371
   static const QuicUint128 kPrime = MakeQuicUint128(16777216, 315);
   const uint8_t* octets = reinterpret_cast<const uint8_t*>(data.data());
@@ -73,7 +71,7 @@
 }
 #endif
 
-QuicUint128 IncrementalHash(QuicUint128 hash, quiche::QuicheStringPiece data) {
+QuicUint128 IncrementalHash(QuicUint128 hash, absl::string_view data) {
 #ifdef QUIC_UTIL_HAS_UINT128
   return IncrementalHashFast(hash, data);
 #else
@@ -84,7 +82,7 @@
 }  // namespace
 
 // static
-uint64_t QuicUtils::FNV1a_64_Hash(quiche::QuicheStringPiece data) {
+uint64_t QuicUtils::FNV1a_64_Hash(absl::string_view data) {
   static const uint64_t kOffset = UINT64_C(14695981039346656037);
   static const uint64_t kPrime = UINT64_C(1099511628211);
 
@@ -101,21 +99,20 @@
 }
 
 // static
-QuicUint128 QuicUtils::FNV1a_128_Hash(quiche::QuicheStringPiece data) {
-  return FNV1a_128_Hash_Three(data, quiche::QuicheStringPiece(),
-                              quiche::QuicheStringPiece());
+QuicUint128 QuicUtils::FNV1a_128_Hash(absl::string_view data) {
+  return FNV1a_128_Hash_Three(data, absl::string_view(), absl::string_view());
 }
 
 // static
-QuicUint128 QuicUtils::FNV1a_128_Hash_Two(quiche::QuicheStringPiece data1,
-                                          quiche::QuicheStringPiece data2) {
-  return FNV1a_128_Hash_Three(data1, data2, quiche::QuicheStringPiece());
+QuicUint128 QuicUtils::FNV1a_128_Hash_Two(absl::string_view data1,
+                                          absl::string_view data2) {
+  return FNV1a_128_Hash_Three(data1, data2, absl::string_view());
 }
 
 // static
-QuicUint128 QuicUtils::FNV1a_128_Hash_Three(quiche::QuicheStringPiece data1,
-                                            quiche::QuicheStringPiece data2,
-                                            quiche::QuicheStringPiece data3) {
+QuicUint128 QuicUtils::FNV1a_128_Hash_Three(absl::string_view data1,
+                                            absl::string_view data2,
+                                            absl::string_view data3) {
   // The two constants are defined as part of the hash algorithm.
   // see http://www.isthe.com/chongo/tech/comp/fnv/
   // kOffset = 144066263297769815596495629667062367629
@@ -287,7 +284,7 @@
 }
 
 // static
-struct iovec QuicUtils::MakeIovec(quiche::QuicheStringPiece data) {
+struct iovec QuicUtils::MakeIovec(absl::string_view data) {
   struct iovec iov = {const_cast<char*>(data.data()),
                       static_cast<size_t>(data.size())};
   return iov;
@@ -511,7 +508,7 @@
     return EmptyQuicConnectionId();
   }
   const uint64_t connection_id_hash64 = FNV1a_64_Hash(
-      quiche::QuicheStringPiece(connection_id.data(), connection_id.length()));
+      absl::string_view(connection_id.data(), connection_id.length()));
   if (expected_connection_id_length <= sizeof(uint64_t)) {
     return QuicConnectionId(
         reinterpret_cast<const char*>(&connection_id_hash64),
@@ -519,7 +516,7 @@
   }
   char new_connection_id_data[255] = {};
   const QuicUint128 connection_id_hash128 = FNV1a_128_Hash(
-      quiche::QuicheStringPiece(connection_id.data(), connection_id.length()));
+      absl::string_view(connection_id.data(), connection_id.length()));
   static_assert(sizeof(connection_id_hash64) + sizeof(connection_id_hash128) <=
                     sizeof(new_connection_id_data),
                 "bad size");
@@ -615,7 +612,7 @@
 QuicUint128 QuicUtils::GenerateStatelessResetToken(
     QuicConnectionId connection_id) {
   return FNV1a_128_Hash(
-      quiche::QuicheStringPiece(connection_id.data(), connection_id.length()));
+      absl::string_view(connection_id.data(), connection_id.length()));
 }
 
 // static
diff --git a/quic/core/quic_utils.h b/quic/core/quic_utils.h
index 05c7124..c6f5ca0 100644
--- a/quic/core/quic_utils.h
+++ b/quic/core/quic_utils.h
@@ -11,6 +11,7 @@
 #include <string>
 #include <type_traits>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
 #include "net/third_party/quiche/src/quic/core/frames/quic_frame.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
@@ -21,7 +22,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_iovec.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_uint128.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -31,22 +31,22 @@
 
   // Returns the 64 bit FNV1a hash of the data.  See
   // http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param
-  static uint64_t FNV1a_64_Hash(quiche::QuicheStringPiece data);
+  static uint64_t FNV1a_64_Hash(absl::string_view data);
 
   // Returns the 128 bit FNV1a hash of the data.  See
   // http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param
-  static QuicUint128 FNV1a_128_Hash(quiche::QuicheStringPiece data);
+  static QuicUint128 FNV1a_128_Hash(absl::string_view data);
 
   // Returns the 128 bit FNV1a hash of the two sequences of data.  See
   // http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param
-  static QuicUint128 FNV1a_128_Hash_Two(quiche::QuicheStringPiece data1,
-                                        quiche::QuicheStringPiece data2);
+  static QuicUint128 FNV1a_128_Hash_Two(absl::string_view data1,
+                                        absl::string_view data2);
 
   // Returns the 128 bit FNV1a hash of the three sequences of data.  See
   // http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param
-  static QuicUint128 FNV1a_128_Hash_Three(quiche::QuicheStringPiece data1,
-                                          quiche::QuicheStringPiece data2,
-                                          quiche::QuicheStringPiece data3);
+  static QuicUint128 FNV1a_128_Hash_Three(absl::string_view data1,
+                                          absl::string_view data2,
+                                          absl::string_view data3);
 
   // SerializeUint128 writes the first 96 bits of |v| in little-endian form
   // to |out|.
@@ -80,7 +80,7 @@
                            char* buffer);
 
   // Creates an iovec pointing to the same data as |data|.
-  static struct iovec MakeIovec(quiche::QuicheStringPiece data);
+  static struct iovec MakeIovec(absl::string_view data);
 
   // Returns the opposite Perspective of the |perspective| passed in.
   static constexpr Perspective InvertPerspective(Perspective perspective) {
diff --git a/quic/core/quic_utils_test.cc b/quic/core/quic_utils_test.cc
index 041cd98..b3b8457 100644
--- a/quic/core/quic_utils_test.cc
+++ b/quic/core/quic_utils_test.cc
@@ -6,12 +6,12 @@
 
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -100,7 +100,7 @@
     data[i] = i % 255;
   }
   EXPECT_EQ(IncrementalHashReference(data.data(), data.size()),
-            QuicUtils::FNV1a_128_Hash(quiche::QuicheStringPiece(
+            QuicUtils::FNV1a_128_Hash(absl::string_view(
                 reinterpret_cast<const char*>(data.data()), data.size())));
 }
 
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index d3f707b..745957f 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -328,8 +328,7 @@
   return UnsupportedQuicVersion();
 }
 
-ParsedQuicVersion ParseQuicVersionString(
-    quiche::QuicheStringPiece version_string) {
+ParsedQuicVersion ParseQuicVersionString(absl::string_view version_string) {
   if (version_string.empty()) {
     return UnsupportedQuicVersion();
   }
@@ -374,11 +373,11 @@
 }
 
 ParsedQuicVersionVector ParseQuicVersionVectorString(
-    quiche::QuicheStringPiece versions_string) {
+    absl::string_view versions_string) {
   ParsedQuicVersionVector versions;
-  std::vector<quiche::QuicheStringPiece> version_strings =
+  std::vector<absl::string_view> version_strings =
       quiche::QuicheTextUtils::Split(versions_string, ',');
-  for (quiche::QuicheStringPiece version_string : version_strings) {
+  for (absl::string_view version_string : version_strings) {
     quiche::QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(
         &version_string);
     ParsedQuicVersion version = ParseQuicVersionString(version_string);
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index e983272..c29b715 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -26,10 +26,10 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_tag.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -497,13 +497,13 @@
 // ALPN such as "h3-29" or "h3-Q050". For PROTOCOL_QUIC_CRYPTO versions, also
 // supports parsing numbers such as "46".
 QUIC_EXPORT_PRIVATE ParsedQuicVersion
-ParseQuicVersionString(quiche::QuicheStringPiece version_string);
+ParseQuicVersionString(absl::string_view version_string);
 
 // Parses a comma-separated list of QUIC version strings. Supports parsing by
 // label, ALPN and numbers for PROTOCOL_QUIC_CRYPTO. Skips unknown versions.
 // For example: "h3-29,Q050,46".
 QUIC_EXPORT_PRIVATE ParsedQuicVersionVector
-ParseQuicVersionVectorString(quiche::QuicheStringPiece versions_string);
+ParseQuicVersionVectorString(absl::string_view versions_string);
 
 // Constructs a QuicVersionLabel from the provided ParsedQuicVersion.
 QUIC_EXPORT_PRIVATE QuicVersionLabel
diff --git a/quic/core/tls_chlo_extractor.cc b/quic/core/tls_chlo_extractor.cc
index 7c10d2c..06ed1c8 100644
--- a/quic/core/tls_chlo_extractor.cc
+++ b/quic/core/tls_chlo_extractor.cc
@@ -6,6 +6,7 @@
 #include <cstring>
 #include <memory>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 #include "net/third_party/quiche/src/quic/core/frames/quic_crypto_frame.h"
 #include "net/third_party/quiche/src/quic/core/quic_data_reader.h"
@@ -16,7 +17,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.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 quic {
@@ -280,14 +280,14 @@
   if (rv == 1) {
     QuicDataReader alpns_reader(reinterpret_cast<const char*>(alpn_data),
                                 alpn_len);
-    quiche::QuicheStringPiece alpns_payload;
+    absl::string_view alpns_payload;
     if (!alpns_reader.ReadStringPiece16(&alpns_payload)) {
       HandleUnrecoverableError("Failed to read alpns_payload");
       return;
     }
     QuicDataReader alpns_payload_reader(alpns_payload);
     while (!alpns_payload_reader.IsDoneReading()) {
-      quiche::QuicheStringPiece alpn_payload;
+      absl::string_view alpn_payload;
       if (!alpns_payload_reader.ReadStringPiece8(&alpn_payload)) {
         HandleUnrecoverableError("Failed to read alpn_payload");
         return;
diff --git a/quic/core/tls_chlo_extractor.h b/quic/core/tls_chlo_extractor.h
index b50d2e2..53e06b4 100644
--- a/quic/core/tls_chlo_extractor.h
+++ b/quic/core/tls_chlo_extractor.h
@@ -67,10 +67,9 @@
       const QuicVersionNegotiationPacket& /*packet*/) override {}
   void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
                      QuicConnectionId /*new_connection_id*/,
-                     quiche::QuicheStringPiece /*retry_token*/,
-                     quiche::QuicheStringPiece /*retry_integrity_tag*/,
-                     quiche::QuicheStringPiece /*retry_without_tag*/) override {
-  }
+                     absl::string_view /*retry_token*/,
+                     absl::string_view /*retry_integrity_tag*/,
+                     absl::string_view /*retry_without_tag*/) override {}
   bool OnUnauthenticatedPublicHeader(const QuicPacketHeader& header) override;
   bool OnUnauthenticatedHeader(const QuicPacketHeader& /*header*/) override {
     return true;
diff --git a/quic/core/tls_chlo_extractor_test.cc b/quic/core/tls_chlo_extractor_test.cc
index 955e58c..db926b4 100644
--- a/quic/core/tls_chlo_extractor_test.cc
+++ b/quic/core/tls_chlo_extractor_test.cc
@@ -31,7 +31,7 @@
           QuicSocketAddress(TestPeerIPAddress(), kTestPort), *packet);
       std::string detailed_error;
       bool retry_token_present;
-      quiche::QuicheStringPiece retry_token;
+      absl::string_view retry_token;
       const QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
           *packet, /*expected_destination_connection_id_length=*/0,
           &packet_info.form, &packet_info.long_packet_type,
@@ -128,7 +128,7 @@
       QuicSocketAddress(TestPeerIPAddress(), kTestPort), *packets_[0]);
   std::string detailed_error;
   bool retry_token_present;
-  quiche::QuicheStringPiece retry_token;
+  absl::string_view retry_token;
   const QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
       *packets_[0], /*expected_destination_connection_id_length=*/0,
       &packet_info.form, &packet_info.long_packet_type,
diff --git a/quic/core/tls_client_handshaker.cc b/quic/core/tls_client_handshaker.cc
index ba3f9d4..c6e601e 100644
--- a/quic/core/tls_client_handshaker.cc
+++ b/quic/core/tls_client_handshaker.cc
@@ -7,6 +7,7 @@
 #include <cstring>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_crypto_client_config.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h"
@@ -15,7 +16,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_hostname_utils.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 quic {
@@ -189,7 +189,7 @@
       success && (SSL_set_alpn_protos(ssl(), alpn, alpn_writer.length()) == 0);
   if (!success) {
     QUIC_BUG << "Failed to set ALPN: "
-             << quiche::QuicheTextUtils::HexDump(quiche::QuicheStringPiece(
+             << quiche::QuicheTextUtils::HexDump(absl::string_view(
                     alpn_writer.data(), alpn_writer.length()));
     return false;
   }
@@ -616,7 +616,7 @@
 }
 
 void TlsClientHandshaker::WriteMessage(EncryptionLevel level,
-                                       quiche::QuicheStringPiece data) {
+                                       absl::string_view data) {
   if (level == ENCRYPTION_HANDSHAKE &&
       state_ < STATE_ENCRYPTION_HANDSHAKE_DATA_SENT) {
     state_ = STATE_ENCRYPTION_HANDSHAKE_DATA_SENT;
diff --git a/quic/core/tls_client_handshaker.h b/quic/core/tls_client_handshaker.h
index 2a09fb8..89388cc 100644
--- a/quic/core/tls_client_handshaker.h
+++ b/quic/core/tls_client_handshaker.h
@@ -9,6 +9,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 #include "net/third_party/quiche/src/quic/core/crypto/proof_verifier.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_crypto_client_config.h"
@@ -18,7 +19,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_crypto_stream.h"
 #include "net/third_party/quiche/src/quic/core/tls_handshaker.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -69,8 +69,7 @@
                       const std::vector<uint8_t>& write_secret) override;
 
   // Override to drop initial keys if trying to write ENCRYPTION_HANDSHAKE data.
-  void WriteMessage(EncryptionLevel level,
-                    quiche::QuicheStringPiece data) override;
+  void WriteMessage(EncryptionLevel level, absl::string_view data) override;
 
   void SetServerApplicationStateForResumption(
       std::unique_ptr<ApplicationState> application_state) override;
diff --git a/quic/core/tls_client_handshaker_test.cc b/quic/core/tls_client_handshaker_test.cc
index bfd937f..6a05159 100644
--- a/quic/core/tls_client_handshaker_test.cc
+++ b/quic/core/tls_client_handshaker_test.cc
@@ -52,7 +52,7 @@
       const uint16_t port,
       const std::string& server_config,
       QuicTransportVersion quic_version,
-      quiche::QuicheStringPiece chlo_hash,
+      absl::string_view chlo_hash,
       const std::vector<std::string>& certs,
       const std::string& cert_sct,
       const std::string& signature,
@@ -233,10 +233,9 @@
     server_session_.reset(server_session);
     std::string alpn = AlpnForVersion(connection_->version());
     EXPECT_CALL(*server_session_, SelectAlpn(_))
-        .WillRepeatedly(
-            [alpn](const std::vector<quiche::QuicheStringPiece>& alpns) {
-              return std::find(alpns.cbegin(), alpns.cend(), alpn);
-            });
+        .WillRepeatedly([alpn](const std::vector<absl::string_view>& alpns) {
+          return std::find(alpns.cbegin(), alpns.cend(), alpn);
+        });
   }
 
   MockQuicConnectionHelper server_helper_;
@@ -286,8 +285,8 @@
       0, 0, 0,  // uint24 length
   };
   stream()->crypto_message_parser()->ProcessInput(
-      quiche::QuicheStringPiece(bogus_handshake_message,
-                                QUICHE_ARRAYSIZE(bogus_handshake_message)),
+      absl::string_view(bogus_handshake_message,
+                        QUICHE_ARRAYSIZE(bogus_handshake_message)),
       ENCRYPTION_INITIAL);
 
   EXPECT_FALSE(stream()->one_rtt_keys_available());
@@ -556,10 +555,9 @@
   InitializeFakeServer();
   const std::string kTestAlpn = "An ALPN That Client Did Not Offer";
   EXPECT_CALL(*server_session_, SelectAlpn(_))
-      .WillOnce(
-          [kTestAlpn](const std::vector<quiche::QuicheStringPiece>& alpns) {
-            return std::find(alpns.cbegin(), alpns.cend(), kTestAlpn);
-          });
+      .WillOnce([kTestAlpn](const std::vector<absl::string_view>& alpns) {
+        return std::find(alpns.cbegin(), alpns.cend(), kTestAlpn);
+      });
   EXPECT_CALL(*server_connection_,
               CloseConnection(QUIC_HANDSHAKE_FAILED,
                               "TLS handshake failure (ENCRYPTION_INITIAL) 120: "
diff --git a/quic/core/tls_handshaker.cc b/quic/core/tls_handshaker.cc
index 04fab15..7e66302 100644
--- a/quic/core/tls_handshaker.cc
+++ b/quic/core/tls_handshaker.cc
@@ -4,6 +4,7 @@
 
 #include "net/third_party/quiche/src/quic/core/tls_handshaker.h"
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/crypto.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 #include "net/third_party/quiche/src/quic/core/quic_crypto_stream.h"
@@ -11,7 +12,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.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 quic {
 
@@ -20,7 +20,7 @@
 
 TlsHandshaker::~TlsHandshaker() {}
 
-bool TlsHandshaker::ProcessInput(quiche::QuicheStringPiece input,
+bool TlsHandshaker::ProcessInput(absl::string_view input,
                                  EncryptionLevel level) {
   if (parser_error_ != QUIC_NO_ERROR) {
     return false;
@@ -88,7 +88,7 @@
 }
 
 void TlsHandshaker::WriteMessage(EncryptionLevel level,
-                                 quiche::QuicheStringPiece data) {
+                                 absl::string_view data) {
   stream_->WriteCryptoData(level, data);
 }
 
diff --git a/quic/core/tls_handshaker.h b/quic/core/tls_handshaker.h
index 2b3c9fc..ef3ade1 100644
--- a/quic/core/tls_handshaker.h
+++ b/quic/core/tls_handshaker.h
@@ -5,6 +5,7 @@
 #ifndef QUICHE_QUIC_CORE_TLS_HANDSHAKER_H_
 #define QUICHE_QUIC_CORE_TLS_HANDSHAKER_H_
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/base.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
@@ -14,7 +15,6 @@
 #include "net/third_party/quiche/src/quic/core/crypto/tls_connection.h"
 #include "net/third_party/quiche/src/quic/core/quic_session.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -36,8 +36,7 @@
   ~TlsHandshaker() override;
 
   // From CryptoMessageParser
-  bool ProcessInput(quiche::QuicheStringPiece input,
-                    EncryptionLevel level) override;
+  bool ProcessInput(absl::string_view input, EncryptionLevel level) override;
   size_t InputBytesRemaining() const override { return 0; }
   QuicErrorCode error() const override { return parser_error_; }
   const std::string& error_detail() const override {
@@ -88,8 +87,7 @@
   // WriteMessage is called when there is |data| from the TLS stack ready for
   // the QUIC stack to write in a crypto frame. The data must be transmitted at
   // encryption level |level|.
-  void WriteMessage(EncryptionLevel level,
-                    quiche::QuicheStringPiece data) override;
+  void WriteMessage(EncryptionLevel level, absl::string_view data) override;
 
   // FlushFlight is called to signal that the current flight of
   // messages have all been written (via calls to WriteMessage) and can be
diff --git a/quic/core/tls_server_handshaker.cc b/quic/core/tls_server_handshaker.cc
index a8f926e..f108a32 100644
--- a/quic/core/tls_server_handshaker.cc
+++ b/quic/core/tls_server_handshaker.cc
@@ -7,6 +7,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/pool.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_crypto_server_config.h"
@@ -14,7 +15,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_hostname_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.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 quic {
@@ -423,7 +423,7 @@
     size_t* out_len,
     size_t max_out,
     uint16_t sig_alg,
-    quiche::QuicheStringPiece in) {
+    absl::string_view in) {
   signature_callback_ = new SignatureCallback(this);
   proof_source_->ComputeTlsSignature(
       session()->connection()->self_address(),
@@ -461,7 +461,7 @@
 int TlsServerHandshaker::SessionTicketSeal(uint8_t* out,
                                            size_t* out_len,
                                            size_t max_out_len,
-                                           quiche::QuicheStringPiece in) {
+                                           absl::string_view in) {
   DCHECK(proof_source_->GetTicketCrypter());
   std::vector<uint8_t> ticket = proof_source_->GetTicketCrypter()->Encrypt(in);
   if (max_out_len < ticket.size()) {
@@ -480,7 +480,7 @@
     uint8_t* out,
     size_t* out_len,
     size_t max_out_len,
-    quiche::QuicheStringPiece in) {
+    absl::string_view in) {
   DCHECK(proof_source_->GetTicketCrypter());
 
   if (!ticket_decryption_callback_) {
@@ -586,7 +586,7 @@
   CBS all_alpns;
   CBS_init(&all_alpns, in, in_len);
 
-  std::vector<quiche::QuicheStringPiece> alpns;
+  std::vector<absl::string_view> alpns;
   while (CBS_len(&all_alpns) > 0) {
     CBS alpn;
     if (!CBS_get_u8_length_prefixed(&all_alpns, &alpn)) {
diff --git a/quic/core/tls_server_handshaker.h b/quic/core/tls_server_handshaker.h
index 063e5ca..79d19cb 100644
--- a/quic/core/tls_server_handshaker.h
+++ b/quic/core/tls_server_handshaker.h
@@ -7,6 +7,7 @@
 
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/pool.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_crypto_server_config.h"
@@ -16,7 +17,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_crypto_stream.h"
 #include "net/third_party/quiche/src/quic/core/tls_handshaker.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -94,12 +94,11 @@
                  uint8_t* out_len,
                  const uint8_t* in,
                  unsigned in_len) override;
-  ssl_private_key_result_t PrivateKeySign(
-      uint8_t* out,
-      size_t* out_len,
-      size_t max_out,
-      uint16_t sig_alg,
-      quiche::QuicheStringPiece in) override;
+  ssl_private_key_result_t PrivateKeySign(uint8_t* out,
+                                          size_t* out_len,
+                                          size_t max_out,
+                                          uint16_t sig_alg,
+                                          absl::string_view in) override;
   ssl_private_key_result_t PrivateKeyComplete(uint8_t* out,
                                               size_t* out_len,
                                               size_t max_out) override;
@@ -107,12 +106,11 @@
   int SessionTicketSeal(uint8_t* out,
                         size_t* out_len,
                         size_t max_out_len,
-                        quiche::QuicheStringPiece in) override;
-  ssl_ticket_aead_result_t SessionTicketOpen(
-      uint8_t* out,
-      size_t* out_len,
-      size_t max_out_len,
-      quiche::QuicheStringPiece in) override;
+                        absl::string_view in) override;
+  ssl_ticket_aead_result_t SessionTicketOpen(uint8_t* out,
+                                             size_t* out_len,
+                                             size_t max_out_len,
+                                             absl::string_view in) override;
   TlsConnection::Delegate* ConnectionDelegate() override { return this; }
 
  private:
diff --git a/quic/core/tls_server_handshaker_test.cc b/quic/core/tls_server_handshaker_test.cc
index 295af9d..b95b281 100644
--- a/quic/core/tls_server_handshaker_test.cc
+++ b/quic/core/tls_server_handshaker_test.cc
@@ -6,6 +6,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/proof_source.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
 #include "net/third_party/quiche/src/quic/core/quic_crypto_client_stream.h"
@@ -23,7 +24,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/simple_session_cache.h"
 #include "net/third_party/quiche/src/quic/test_tools/test_ticket_crypter.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 class QuicConnection;
@@ -101,7 +101,7 @@
         .Times(testing::AnyNumber());
     EXPECT_CALL(*server_session_, SelectAlpn(_))
         .WillRepeatedly(
-            [this](const std::vector<quiche::QuicheStringPiece>& alpns) {
+            [this](const std::vector<absl::string_view>& alpns) {
               return std::find(
                   alpns.cbegin(), alpns.cend(),
                   AlpnForVersion(server_session_->connection()->version()));
@@ -295,8 +295,8 @@
       0, 0, 0,  // uint24 length
   };
   server_stream()->crypto_message_parser()->ProcessInput(
-      quiche::QuicheStringPiece(bogus_handshake_message,
-                                QUICHE_ARRAYSIZE(bogus_handshake_message)),
+      absl::string_view(bogus_handshake_message,
+                        QUICHE_ARRAYSIZE(bogus_handshake_message)),
       ENCRYPTION_INITIAL);
 
   EXPECT_FALSE(server_stream()->one_rtt_keys_available());
@@ -330,15 +330,13 @@
   EXPECT_CALL(*client_session_, GetAlpnsToOffer())
       .WillRepeatedly(Return(kTestAlpns));
   EXPECT_CALL(*server_session_, SelectAlpn(_))
-      .WillOnce([kTestAlpn, kTestAlpns](
-                    const std::vector<quiche::QuicheStringPiece>& alpns) {
-        EXPECT_THAT(alpns, testing::ElementsAreArray(kTestAlpns));
-        return std::find(alpns.cbegin(), alpns.cend(), kTestAlpn);
-      });
-  EXPECT_CALL(*client_session_,
-              OnAlpnSelected(quiche::QuicheStringPiece(kTestAlpn)));
-  EXPECT_CALL(*server_session_,
-              OnAlpnSelected(quiche::QuicheStringPiece(kTestAlpn)));
+      .WillOnce(
+          [kTestAlpn, kTestAlpns](const std::vector<absl::string_view>& alpns) {
+            EXPECT_THAT(alpns, testing::ElementsAreArray(kTestAlpns));
+            return std::find(alpns.cbegin(), alpns.cend(), kTestAlpn);
+          });
+  EXPECT_CALL(*client_session_, OnAlpnSelected(absl::string_view(kTestAlpn)));
+  EXPECT_CALL(*server_session_, OnAlpnSelected(absl::string_view(kTestAlpn)));
 
   CompleteCryptoHandshake();
   ExpectHandshakeSuccessful();