diff --git a/quic/test_tools/crypto_test_utils.cc b/quic/test_tools/crypto_test_utils.cc
index eacbca5..e8535d8 100644
--- a/quic/test_tools/crypto_test_utils.cc
+++ b/quic/test_tools/crypto_test_utils.cc
@@ -9,6 +9,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/bn.h"
 #include "third_party/boringssl/src/include/openssl/ec.h"
 #include "third_party/boringssl/src/include/openssl/ecdsa.h"
@@ -38,7 +39,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_stream_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/simple_quic_framer.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"
 
@@ -182,15 +182,15 @@
     EXPECT_THAT(rej->tag(), testing::Eq(kREJ));
 
     QUIC_VLOG(1) << "Extract valid STK and SCID from\n" << rej->DebugString();
-    quiche::QuicheStringPiece srct;
+    absl::string_view srct;
     ASSERT_TRUE(rej->GetStringPiece(kSourceAddressTokenTag, &srct));
 
-    quiche::QuicheStringPiece scfg;
+    absl::string_view scfg;
     ASSERT_TRUE(rej->GetStringPiece(kSCFG, &scfg));
     std::unique_ptr<CryptoHandshakeMessage> server_config(
         CryptoFramer::ParseMessage(scfg));
 
-    quiche::QuicheStringPiece scid;
+    absl::string_view scid;
     ASSERT_TRUE(server_config->GetStringPiece(kSCID, &scid));
 
     *out_ = result_->client_hello;
@@ -257,10 +257,9 @@
   EXPECT_CALL(*server_conn, SendCryptoData(_, _, _))
       .Times(testing::AnyNumber());
   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);
+      });
 
   // The client's handshake must have been started already.
   CHECK_NE(0u, client_conn->encrypted_packets_.size());
@@ -464,26 +463,23 @@
 
 class MockCommonCertSets : public CommonCertSets {
  public:
-  MockCommonCertSets(quiche::QuicheStringPiece cert,
-                     uint64_t hash,
-                     uint32_t index)
+  MockCommonCertSets(absl::string_view cert, uint64_t hash, uint32_t index)
       : cert_(cert), hash_(hash), index_(index) {}
 
-  quiche::QuicheStringPiece GetCommonHashes() const override {
+  absl::string_view GetCommonHashes() const override {
     QUIC_BUG << "not implemented";
-    return quiche::QuicheStringPiece();
+    return absl::string_view();
   }
 
-  quiche::QuicheStringPiece GetCert(uint64_t hash,
-                                    uint32_t index) const override {
+  absl::string_view GetCert(uint64_t hash, uint32_t index) const override {
     if (hash == hash_ && index == index_) {
       return cert_;
     }
-    return quiche::QuicheStringPiece();
+    return absl::string_view();
   }
 
-  bool MatchCert(quiche::QuicheStringPiece cert,
-                 quiche::QuicheStringPiece common_set_hashes,
+  bool MatchCert(absl::string_view cert,
+                 absl::string_view common_set_hashes,
                  uint64_t* out_hash,
                  uint32_t* out_index) const override {
     if (cert != cert_) {
@@ -518,7 +514,7 @@
   const uint32_t index_;
 };
 
-CommonCertSets* MockCommonCertSets(quiche::QuicheStringPiece cert,
+CommonCertSets* MockCommonCertSets(absl::string_view cert,
                                    uint64_t hash,
                                    uint32_t index) {
   return new class MockCommonCertSets(cert, hash, index);
@@ -579,10 +575,10 @@
                   << decrypter << " for " << label;
     return;
   }
-  quiche::QuicheStringPiece encrypter_key = encrypter->GetKey();
-  quiche::QuicheStringPiece encrypter_iv = encrypter->GetNoncePrefix();
-  quiche::QuicheStringPiece decrypter_key = decrypter->GetKey();
-  quiche::QuicheStringPiece decrypter_iv = decrypter->GetNoncePrefix();
+  absl::string_view encrypter_key = encrypter->GetKey();
+  absl::string_view encrypter_iv = encrypter->GetNoncePrefix();
+  absl::string_view decrypter_key = decrypter->GetKey();
+  absl::string_view decrypter_iv = decrypter->GetNoncePrefix();
   quiche::test::CompareCharArraysWithHexError(
       label + " key", encrypter_key.data(), encrypter_key.length(),
       decrypter_key.data(), decrypter_key.length());
@@ -626,9 +622,9 @@
     }
   }
 
-  quiche::QuicheStringPiece client_subkey_secret =
+  absl::string_view client_subkey_secret =
       client->crypto_negotiated_params().subkey_secret;
-  quiche::QuicheStringPiece server_subkey_secret =
+  absl::string_view server_subkey_secret =
       server->crypto_negotiated_params().subkey_secret;
   quiche::test::CompareCharArraysWithHexError(
       "subkey secret", client_subkey_secret.data(),
@@ -708,8 +704,8 @@
     size_t value_len = value.length();
     if (value_len > 0 && value[0] == '#') {
       // This is ascii encoded hex.
-      std::string hex_value = quiche::QuicheTextUtils::HexDecode(
-          quiche::QuicheStringPiece(&value[1]));
+      std::string hex_value =
+          quiche::QuicheTextUtils::HexDecode(absl::string_view(&value[1]));
       msg.SetStringPiece(quic_tag, hex_value);
       continue;
     }
@@ -798,7 +794,7 @@
   *inout_packet_index = index;
 
   QuicConnectionPeer::SetCurrentPacket(dest_conn,
-                                       quiche::QuicheStringPiece(nullptr, 0));
+                                       absl::string_view(nullptr, 0));
 }
 
 CryptoHandshakeMessage GenerateDefaultInchoateCHLO(
@@ -830,7 +826,7 @@
   primary_config.set_primary_time(clock->WallNow().ToUNIXSeconds());
   std::unique_ptr<CryptoHandshakeMessage> msg =
       crypto_config->AddConfig(primary_config, clock->WallNow());
-  quiche::QuicheStringPiece orbit;
+  absl::string_view orbit;
   CHECK(msg->GetStringPiece(kORBT, &orbit));
   std::string nonce;
   CryptoUtils::GenerateNonce(clock->WallNow(), QuicRandom::GetInstance(), orbit,
diff --git a/quic/test_tools/crypto_test_utils.h b/quic/test_tools/crypto_test_utils.h
index 3d58837..32d761f 100644
--- a/quic/test_tools/crypto_test_utils.h
+++ b/quic/test_tools/crypto_test_utils.h
@@ -11,12 +11,12 @@
 #include <utility>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/evp.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
 #include "net/third_party/quiche/src/quic/core/quic_framer.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.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 {
 
@@ -136,7 +136,7 @@
 
 // MockCommonCertSets returns a CommonCertSets that contains a single set with
 // hash |hash|, consisting of the certificate |cert| at index |index|.
-CommonCertSets* MockCommonCertSets(quiche::QuicheStringPiece cert,
+CommonCertSets* MockCommonCertSets(absl::string_view cert,
                                    uint64_t hash,
                                    uint32_t index);
 
diff --git a/quic/test_tools/crypto_test_utils_test.cc b/quic/test_tools/crypto_test_utils_test.cc
index a21b43a..45bcec4 100644
--- a/quic/test_tools/crypto_test_utils_test.cc
+++ b/quic/test_tools/crypto_test_utils_test.cc
@@ -6,11 +6,11 @@
 
 #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/core/quic_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/mock_clock.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 {
@@ -134,7 +134,7 @@
   primary_config.set_primary_time(clock.WallNow().ToUNIXSeconds());
   std::unique_ptr<CryptoHandshakeMessage> msg =
       crypto_config.AddConfig(primary_config, clock.WallNow());
-  quiche::QuicheStringPiece orbit;
+  absl::string_view orbit;
   ASSERT_TRUE(msg->GetStringPiece(kORBT, &orbit));
   std::string nonce;
   CryptoUtils::GenerateNonce(clock.WallNow(), QuicRandom::GetInstance(), orbit,
diff --git a/quic/test_tools/failing_proof_source.cc b/quic/test_tools/failing_proof_source.cc
index 98e18fc..576791c 100644
--- a/quic/test_tools/failing_proof_source.cc
+++ b/quic/test_tools/failing_proof_source.cc
@@ -4,7 +4,7 @@
 
 #include "net/third_party/quiche/src/quic/test_tools/failing_proof_source.h"
 
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "absl/strings/string_view.h"
 
 namespace quic {
 namespace test {
@@ -14,7 +14,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) {
   callback->Run(false, nullptr, QuicCryptoProof(), nullptr);
 }
@@ -31,7 +31,7 @@
     const QuicSocketAddress& /*client_address*/,
     const std::string& /*hostname*/,
     uint16_t /*signature_algorithm*/,
-    quiche::QuicheStringPiece /*in*/,
+    absl::string_view /*in*/,
     std::unique_ptr<SignatureCallback> callback) {
   callback->Run(false, "", nullptr);
 }
diff --git a/quic/test_tools/failing_proof_source.h b/quic/test_tools/failing_proof_source.h
index 6ea303d..b63a952 100644
--- a/quic/test_tools/failing_proof_source.h
+++ b/quic/test_tools/failing_proof_source.h
@@ -5,8 +5,8 @@
 #ifndef QUICHE_QUIC_TEST_TOOLS_FAILING_PROOF_SOURCE_H_
 #define QUICHE_QUIC_TEST_TOOLS_FAILING_PROOF_SOURCE_H_
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/proof_source.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -18,7 +18,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<Chain> GetCertChain(
@@ -31,7 +31,7 @@
       const QuicSocketAddress& client_address,
       const std::string& hostname,
       uint16_t signature_algorithm,
-      quiche::QuicheStringPiece in,
+      absl::string_view in,
       std::unique_ptr<SignatureCallback> callback) override;
 
   TicketCrypter* GetTicketCrypter() override { return nullptr; }
diff --git a/quic/test_tools/fake_proof_source.cc b/quic/test_tools/fake_proof_source.cc
index 9619fad..00af20e 100644
--- a/quic/test_tools/fake_proof_source.cc
+++ b/quic/test_tools/fake_proof_source.cc
@@ -6,9 +6,9 @@
 
 #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/test_tools/crypto_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -52,7 +52,7 @@
     const QuicSocketAddress& client_address,
     std::string hostname,
     uint16_t sig_alg,
-    quiche::QuicheStringPiece in,
+    absl::string_view in,
     std::unique_ptr<ProofSource::SignatureCallback> callback,
     ProofSource* delegate)
     : server_address_(server_address),
@@ -80,7 +80,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<ProofSource::Callback> callback) {
   if (!active_) {
     delegate_->GetProof(server_address, client_address, hostname, server_config,
@@ -106,7 +106,7 @@
     const QuicSocketAddress& client_address,
     const std::string& hostname,
     uint16_t signature_algorithm,
-    quiche::QuicheStringPiece in,
+    absl::string_view in,
     std::unique_ptr<ProofSource::SignatureCallback> callback) {
   QUIC_LOG(INFO) << "FakeProofSource::ComputeTlsSignature";
   if (!active_) {
diff --git a/quic/test_tools/fake_proof_source.h b/quic/test_tools/fake_proof_source.h
index 94dede6..fc99974 100644
--- a/quic/test_tools/fake_proof_source.h
+++ b/quic/test_tools/fake_proof_source.h
@@ -9,8 +9,8 @@
 #include <string>
 #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/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -39,7 +39,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<ProofSource::Callback> callback) override;
   QuicReferenceCountedPointer<Chain> GetCertChain(
       const QuicSocketAddress& server_address,
@@ -50,7 +50,7 @@
       const QuicSocketAddress& client_address,
       const std::string& hostname,
       uint16_t signature_algorithm,
-      quiche::QuicheStringPiece in,
+      absl::string_view in,
       std::unique_ptr<ProofSource::SignatureCallback> callback) override;
   TicketCrypter* GetTicketCrypter() override;
 
@@ -107,7 +107,7 @@
                        const QuicSocketAddress& client_address,
                        std::string hostname,
                        uint16_t sig_alg,
-                       quiche::QuicheStringPiece in,
+                       absl::string_view in,
                        std::unique_ptr<ProofSource::SignatureCallback> callback,
                        ProofSource* delegate);
     ~ComputeSignatureOp() override;
diff --git a/quic/test_tools/quic_connection_peer.cc b/quic/test_tools/quic_connection_peer.cc
index 1949df1..01da28c 100644
--- a/quic/test_tools/quic_connection_peer.cc
+++ b/quic/test_tools/quic_connection_peer.cc
@@ -4,13 +4,13 @@
 
 #include "net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h"
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/congestion_control/send_algorithm_interface.h"
 #include "net/third_party/quiche/src/quic/core/quic_packet_writer.h"
 #include "net/third_party/quiche/src/quic/core/quic_received_packet_manager.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_framer_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_sent_packet_manager_peer.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -94,9 +94,8 @@
 }
 
 // static
-void QuicConnectionPeer::SetCurrentPacket(
-    QuicConnection* connection,
-    quiche::QuicheStringPiece current_packet) {
+void QuicConnectionPeer::SetCurrentPacket(QuicConnection* connection,
+                                          absl::string_view current_packet) {
   connection->current_packet_data_ = current_packet.data();
   connection->last_size_ = current_packet.size();
 }
diff --git a/quic/test_tools/quic_connection_peer.h b/quic/test_tools/quic_connection_peer.h
index b470653..1375cbe 100644
--- a/quic/test_tools/quic_connection_peer.h
+++ b/quic/test_tools/quic_connection_peer.h
@@ -5,11 +5,11 @@
 #ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_CONNECTION_PEER_H_
 #define QUICHE_QUIC_TEST_TOOLS_QUIC_CONNECTION_PEER_H_
 
+#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_connection_stats.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.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 {
 
@@ -67,7 +67,7 @@
   static void SwapCrypters(QuicConnection* connection, QuicFramer* framer);
 
   static void SetCurrentPacket(QuicConnection* connection,
-                               quiche::QuicheStringPiece current_packet);
+                               absl::string_view current_packet);
 
   static QuicConnectionHelperInterface* GetHelper(QuicConnection* connection);
 
diff --git a/quic/test_tools/quic_crypto_server_config_peer.cc b/quic/test_tools/quic_crypto_server_config_peer.cc
index 3893448..64fd271 100644
--- a/quic/test_tools/quic_crypto_server_config_peer.cc
+++ b/quic/test_tools/quic_crypto_server_config_peer.cc
@@ -4,10 +4,10 @@
 
 #include "net/third_party/quiche/src/quic/test_tools/quic_crypto_server_config_peer.h"
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/test_tools/mock_clock.h"
 #include "net/third_party/quiche/src/quic/test_tools/mock_random.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 {
@@ -53,7 +53,7 @@
 
 HandshakeFailureReason QuicCryptoServerConfigPeer::ValidateSourceAddressTokens(
     std::string config_id,
-    quiche::QuicheStringPiece srct,
+    absl::string_view srct,
     const QuicIpAddress& ip,
     QuicWallTime now,
     CachedNetworkParameters* cached_network_params) {
@@ -70,7 +70,7 @@
 
 HandshakeFailureReason
 QuicCryptoServerConfigPeer::ValidateSingleSourceAddressToken(
-    quiche::QuicheStringPiece token,
+    absl::string_view token,
     const QuicIpAddress& ip,
     QuicWallTime now) {
   SourceAddressTokens tokens;
diff --git a/quic/test_tools/quic_crypto_server_config_peer.h b/quic/test_tools/quic_crypto_server_config_peer.h
index 270321f..9366eae 100644
--- a/quic/test_tools/quic_crypto_server_config_peer.h
+++ b/quic/test_tools/quic_crypto_server_config_peer.h
@@ -5,8 +5,8 @@
 #ifndef QUICHE_QUIC_TEST_TOOLS_QUIC_CRYPTO_SERVER_CONFIG_PEER_H_
 #define QUICHE_QUIC_TEST_TOOLS_QUIC_CRYPTO_SERVER_CONFIG_PEER_H_
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_crypto_server_config.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -43,14 +43,14 @@
   // Attempts to validate the tokens in |tokens|.
   HandshakeFailureReason ValidateSourceAddressTokens(
       std::string config_id,
-      quiche::QuicheStringPiece tokens,
+      absl::string_view tokens,
       const QuicIpAddress& ip,
       QuicWallTime now,
       CachedNetworkParameters* cached_network_params);
 
   // Attempts to validate the single source address token in |token|.
   HandshakeFailureReason ValidateSingleSourceAddressToken(
-      quiche::QuicheStringPiece token,
+      absl::string_view token,
       const QuicIpAddress& ip,
       QuicWallTime now);
 
diff --git a/quic/test_tools/quic_test_client.cc b/quic/test_tools/quic_test_client.cc
index 56dc1ec..ee99d9d 100644
--- a/quic/test_tools/quic_test_client.cc
+++ b/quic/test_tools/quic_test_client.cc
@@ -8,6 +8,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/x509.h"
 #include "net/third_party/quiche/src/quic/core/crypto/proof_verifier.h"
 #include "net/third_party/quiche/src/quic/core/http/quic_spdy_client_stream.h"
@@ -27,7 +28,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_spdy_stream_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 #include "net/third_party/quiche/src/quic/tools/quic_url.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 {
@@ -49,7 +49,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,
@@ -438,7 +438,7 @@
 
 ssize_t QuicTestClient::GetOrCreateStreamAndSendRequest(
     const spdy::SpdyHeaderBlock* headers,
-    quiche::QuicheStringPiece body,
+    absl::string_view body,
     bool fin,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   if (headers) {
@@ -482,18 +482,18 @@
 }
 
 ssize_t QuicTestClient::SendMessage(const spdy::SpdyHeaderBlock& headers,
-                                    quiche::QuicheStringPiece body) {
+                                    absl::string_view body) {
   return SendMessage(headers, body, /*fin=*/true);
 }
 
 ssize_t QuicTestClient::SendMessage(const spdy::SpdyHeaderBlock& headers,
-                                    quiche::QuicheStringPiece body,
+                                    absl::string_view body,
                                     bool fin) {
   return SendMessage(headers, body, fin, /*flush=*/true);
 }
 
 ssize_t QuicTestClient::SendMessage(const spdy::SpdyHeaderBlock& headers,
-                                    quiche::QuicheStringPiece body,
+                                    absl::string_view body,
                                     bool fin,
                                     bool flush) {
   // Always force creation of a stream for SendMessage.
@@ -515,8 +515,7 @@
     const std::string& data,
     bool last_data,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
-  return GetOrCreateStreamAndSendRequest(nullptr,
-                                         quiche::QuicheStringPiece(data),
+  return GetOrCreateStreamAndSendRequest(nullptr, absl::string_view(data),
                                          last_data, std::move(ack_listener));
 }
 
@@ -709,7 +708,7 @@
   return true;
 }
 
-ssize_t QuicTestClient::Send(quiche::QuicheStringPiece data) {
+ssize_t QuicTestClient::Send(absl::string_view data) {
   return SendData(std::string(data), false);
 }
 
@@ -884,7 +883,7 @@
 
 QuicTestClient::TestClientDataToResend::TestClientDataToResend(
     std::unique_ptr<spdy::SpdyHeaderBlock> headers,
-    quiche::QuicheStringPiece body,
+    absl::string_view body,
     bool fin,
     QuicTestClient* test_client,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener)
diff --git a/quic/test_tools/quic_test_client.h b/quic/test_tools/quic_test_client.h
index 1bd0247..b4d8f46 100644
--- a/quic/test_tools/quic_test_client.h
+++ b/quic/test_tools/quic_test_client.h
@@ -9,6 +9,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/proto/cached_network_parameters_proto.h"
 #include "net/third_party/quiche/src/quic/core/quic_framer.h"
 #include "net/third_party/quiche/src/quic/core/quic_packet_creator.h"
@@ -18,7 +19,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/tools/quic_client.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -141,19 +141,19 @@
   // Sends a request containing |headers| and |body| and returns the number of
   // bytes sent (the size of the serialized request headers and body).
   ssize_t SendMessage(const spdy::SpdyHeaderBlock& headers,
-                      quiche::QuicheStringPiece body);
+                      absl::string_view body);
   // Sends a request containing |headers| and |body| with the fin bit set to
   // |fin| and returns the number of bytes sent (the size of the serialized
   // request headers and body).
   ssize_t SendMessage(const spdy::SpdyHeaderBlock& headers,
-                      quiche::QuicheStringPiece body,
+                      absl::string_view body,
                       bool fin);
   // Sends a request containing |headers| and |body| with the fin bit set to
   // |fin| and returns the number of bytes sent (the size of the serialized
   // request headers and body). If |flush| is true, will wait for the message to
   // be flushed before returning.
   ssize_t SendMessage(const spdy::SpdyHeaderBlock& headers,
-                      quiche::QuicheStringPiece body,
+                      absl::string_view body,
                       bool fin,
                       bool flush);
   // Sends a request containing |headers| and |body|, waits for the response,
@@ -170,7 +170,7 @@
   QuicSocketAddress local_address() const;
   void ClearPerRequestState();
   bool WaitUntil(int timeout_ms, std::function<bool()> trigger);
-  ssize_t Send(quiche::QuicheStringPiece data);
+  ssize_t Send(absl::string_view data);
   bool connected() const;
   bool buffer_body() const;
   void set_buffer_body(bool buffer_body);
@@ -264,7 +264,7 @@
   // null, only the body will be sent on the stream.
   ssize_t GetOrCreateStreamAndSendRequest(
       const spdy::SpdyHeaderBlock* headers,
-      quiche::QuicheStringPiece body,
+      absl::string_view body,
       bool fin,
       QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
 
@@ -342,7 +342,7 @@
    public:
     TestClientDataToResend(
         std::unique_ptr<spdy::SpdyHeaderBlock> headers,
-        quiche::QuicheStringPiece body,
+        absl::string_view body,
         bool fin,
         QuicTestClient* test_client,
         QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
diff --git a/quic/test_tools/quic_test_server.cc b/quic/test_tools/quic_test_server.cc
index 9d705d3..c69ec29 100644
--- a/quic/test_tools/quic_test_server.cc
+++ b/quic/test_tools/quic_test_server.cc
@@ -6,13 +6,13 @@
 
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_epoll_alarm_factory.h"
 #include "net/third_party/quiche/src/quic/core/quic_epoll_connection_helper.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
 #include "net/third_party/quiche/src/quic/tools/quic_simple_crypto_server_stream_helper.h"
 #include "net/third_party/quiche/src/quic/tools/quic_simple_dispatcher.h"
 #include "net/third_party/quiche/src/quic/tools/quic_simple_server_session.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -97,7 +97,7 @@
       QuicConnectionId id,
       const QuicSocketAddress& self_address,
       const QuicSocketAddress& peer_address,
-      quiche::QuicheStringPiece alpn,
+      absl::string_view alpn,
       const ParsedQuicVersion& version) override {
     QuicReaderMutexLock lock(&factory_lock_);
     if (session_factory_ == nullptr && stream_factory_ == nullptr &&
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index e904c03..02a0f0f 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -9,6 +9,7 @@
 #include <memory>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/chacha.h"
 #include "third_party/boringssl/src/include/openssl/sha.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
@@ -36,7 +37,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_connection_peer.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"
 #include "net/third_party/quiche/src/spdy/core/spdy_frame_builder.h"
 
 using testing::_;
@@ -202,7 +202,7 @@
       header.length_length);
 }
 
-std::string Sha1Hash(quiche::QuicheStringPiece data) {
+std::string Sha1Hash(absl::string_view data) {
   char buffer[SHA_DIGEST_LENGTH];
   SHA1(reinterpret_cast<const uint8_t*>(data.data()), data.size(),
        reinterpret_cast<uint8_t*>(buffer));
@@ -991,7 +991,7 @@
   if (!QuicVersionUsesCryptoFrames(version.transport_version)) {
     QuicFrame frame(
         QuicStreamFrame(QuicUtils::GetCryptoStreamId(version.transport_version),
-                        false, 0, quiche::QuicheStringPiece(data)));
+                        false, 0, absl::string_view(data)));
     frames.push_back(frame);
   } else {
     QuicFrame frame(new QuicCryptoFrame(level, 0, data));
@@ -1102,8 +1102,7 @@
     header.retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_1;
     header.length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
   }
-  QuicFrame frame(
-      QuicStreamFrame(1, false, 0, quiche::QuicheStringPiece(data)));
+  QuicFrame frame(QuicStreamFrame(1, false, 0, absl::string_view(data)));
   QuicFrames frames;
   frames.push_back(frame);
   QuicFramer framer({version}, QuicTime::Zero(), perspective,
@@ -1297,7 +1296,7 @@
 }
 
 QuicMemSliceSpan MakeSpan(QuicBufferAllocator* allocator,
-                          quiche::QuicheStringPiece message_data,
+                          absl::string_view message_data,
                           QuicMemSliceStorage* storage) {
   if (message_data.length() == 0) {
     *storage =
@@ -1310,20 +1309,19 @@
   return storage->ToSpan();
 }
 
-QuicMemSlice MemSliceFromString(quiche::QuicheStringPiece data) {
+QuicMemSlice MemSliceFromString(absl::string_view data) {
   static SimpleBufferAllocator* allocator = new SimpleBufferAllocator();
   QuicUniqueBufferPtr buffer = MakeUniqueBuffer(allocator, data.size());
   memcpy(buffer.get(), data.data(), data.size());
   return QuicMemSlice(std::move(buffer), data.size());
 }
 
-bool TaggingEncrypter::EncryptPacket(
-    uint64_t /*packet_number*/,
-    quiche::QuicheStringPiece /*associated_data*/,
-    quiche::QuicheStringPiece plaintext,
-    char* output,
-    size_t* output_length,
-    size_t max_output_length) {
+bool TaggingEncrypter::EncryptPacket(uint64_t /*packet_number*/,
+                                     absl::string_view /*associated_data*/,
+                                     absl::string_view plaintext,
+                                     char* output,
+                                     size_t* output_length,
+                                     size_t max_output_length) {
   const size_t len = plaintext.size() + kTagSize;
   if (max_output_length < len) {
     return false;
@@ -1336,13 +1334,12 @@
   return true;
 }
 
-bool TaggingDecrypter::DecryptPacket(
-    uint64_t /*packet_number*/,
-    quiche::QuicheStringPiece /*associated_data*/,
-    quiche::QuicheStringPiece ciphertext,
-    char* output,
-    size_t* output_length,
-    size_t /*max_output_length*/) {
+bool TaggingDecrypter::DecryptPacket(uint64_t /*packet_number*/,
+                                     absl::string_view /*associated_data*/,
+                                     absl::string_view ciphertext,
+                                     char* output,
+                                     size_t* output_length,
+                                     size_t /*max_output_length*/) {
   if (ciphertext.size() < kTagSize) {
     return false;
   }
@@ -1354,8 +1351,7 @@
   return true;
 }
 
-bool TaggingDecrypter::CheckTag(quiche::QuicheStringPiece ciphertext,
-                                uint8_t tag) {
+bool TaggingDecrypter::CheckTag(absl::string_view ciphertext, uint8_t tag) {
   for (size_t i = ciphertext.size() - kTagSize; i < ciphertext.size(); i++) {
     if (ciphertext.data()[i] != tag) {
       return false;
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 85d10cb..efb60c5 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -13,6 +13,7 @@
 #include <utility>
 #include <vector>
 
+#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/transport_parameters.h"
@@ -36,7 +37,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_framer_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/simple_quic_framer.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 {
 
@@ -249,7 +249,7 @@
     size_t packet_size);
 
 // Compute SHA-1 hash of the supplied std::string.
-std::string Sha1Hash(quiche::QuicheStringPiece data);
+std::string Sha1Hash(absl::string_view data);
 
 // Delete |frame| and return true.
 bool ClearControlFrame(const QuicFrame& frame);
@@ -304,9 +304,9 @@
               OnRetryPacket,
               (QuicConnectionId original_connection_id,
                QuicConnectionId new_connection_id,
-               quiche::QuicheStringPiece retry_token,
-               quiche::QuicheStringPiece retry_integrity_tag,
-               quiche::QuicheStringPiece retry_without_tag),
+               absl::string_view retry_token,
+               absl::string_view retry_integrity_tag,
+               absl::string_view retry_without_tag),
               (override));
   // The constructor sets this up to return true by default.
   MOCK_METHOD(bool,
@@ -439,10 +439,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 OnProtocolVersionMismatch(ParsedQuicVersion version) override;
   bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override;
   bool OnUnauthenticatedPublicHeader(const QuicPacketHeader& header) override;
@@ -506,10 +505,7 @@
               (override));
   MOCK_METHOD(void, OnRstStream, (const QuicRstStreamFrame& frame), (override));
   MOCK_METHOD(void, OnGoAway, (const QuicGoAwayFrame& frame), (override));
-  MOCK_METHOD(void,
-              OnMessageReceived,
-              (quiche::QuicheStringPiece message),
-              (override));
+  MOCK_METHOD(void, OnMessageReceived, (absl::string_view message), (override));
   MOCK_METHOD(void, OnHandshakeDoneReceived, (), (override));
   MOCK_METHOD(void,
               OnConnectionClosed,
@@ -820,11 +816,11 @@
               (QuicRstStreamErrorCode code, QuicStreamId stream_id),
               (override));
   MOCK_METHOD(std::vector<std::string>, GetAlpnsToOffer, (), (const, override));
-  MOCK_METHOD(std::vector<quiche::QuicheStringPiece>::const_iterator,
+  MOCK_METHOD(std::vector<absl::string_view>::const_iterator,
               SelectAlpn,
-              (const std::vector<quiche::QuicheStringPiece>&),
+              (const std::vector<absl::string_view>&),
               (const, override));
-  MOCK_METHOD(void, OnAlpnSelected, (quiche::QuicheStringPiece), (override));
+  MOCK_METHOD(void, OnAlpnSelected, (absl::string_view), (override));
 
   using QuicSession::ActivateStream;
 
@@ -1087,11 +1083,11 @@
               CreateOutgoingUnidirectionalStream,
               (),
               (override));
-  MOCK_METHOD(std::vector<quiche::QuicheStringPiece>::const_iterator,
+  MOCK_METHOD(std::vector<absl::string_view>::const_iterator,
               SelectAlpn,
-              (const std::vector<quiche::QuicheStringPiece>&),
+              (const std::vector<absl::string_view>&),
               (const, override));
-  MOCK_METHOD(void, OnAlpnSelected, (quiche::QuicheStringPiece), (override));
+  MOCK_METHOD(void, OnAlpnSelected, (absl::string_view), (override));
   std::unique_ptr<QuicCryptoServerStreamBase> CreateQuicCryptoServerStream(
       const QuicCryptoServerConfig* crypto_config,
       QuicCompressedCertsCache* compressed_certs_cache) override;
@@ -1174,7 +1170,7 @@
   MOCK_METHOD(bool, ShouldCreateOutgoingBidirectionalStream, (), (override));
   MOCK_METHOD(bool, ShouldCreateOutgoingUnidirectionalStream, (), (override));
   MOCK_METHOD(std::vector<std::string>, GetAlpnsToOffer, (), (const, override));
-  MOCK_METHOD(void, OnAlpnSelected, (quiche::QuicheStringPiece), (override));
+  MOCK_METHOD(void, OnAlpnSelected, (absl::string_view), (override));
   MOCK_METHOD(void, OnConfigNegotiated, (), (override));
 
   QuicCryptoClientStream* GetMutableCryptoStream() override;
@@ -1655,7 +1651,7 @@
 }
 
 // Utility function that stores |str|'s data in |iov|.
-inline void MakeIOVector(quiche::QuicheStringPiece str, struct iovec* iov) {
+inline void MakeIOVector(absl::string_view str, struct iovec* iov) {
   iov->iov_base = const_cast<char*>(str.data());
   iov->iov_len = static_cast<size_t>(str.size());
 }
@@ -1685,12 +1681,12 @@
 // Utility function that stores message_data in |storage| and returns a
 // QuicMemSliceSpan.
 QuicMemSliceSpan MakeSpan(QuicBufferAllocator* allocator,
-                          quiche::QuicheStringPiece message_data,
+                          absl::string_view message_data,
                           QuicMemSliceStorage* storage);
 
 // Creates a MemSlice using a singleton trivial buffer allocator.  Performs a
 // copy.
-QuicMemSlice MemSliceFromString(quiche::QuicheStringPiece data);
+QuicMemSlice MemSliceFromString(absl::string_view data);
 
 // Used to compare ReceivedPacketInfo.
 MATCHER_P(ReceivedPacketInfoEquals, info, "") {
@@ -1756,27 +1752,27 @@
   ~TaggingEncrypter() override {}
 
   // QuicEncrypter interface.
-  bool SetKey(quiche::QuicheStringPiece /*key*/) override { return true; }
+  bool SetKey(absl::string_view /*key*/) override { return true; }
 
-  bool SetNoncePrefix(quiche::QuicheStringPiece /*nonce_prefix*/) override {
+  bool SetNoncePrefix(absl::string_view /*nonce_prefix*/) override {
     return true;
   }
 
-  bool SetIV(quiche::QuicheStringPiece /*iv*/) override { return true; }
+  bool SetIV(absl::string_view /*iv*/) override { return true; }
 
-  bool SetHeaderProtectionKey(quiche::QuicheStringPiece /*key*/) override {
+  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;
 
   std::string GenerateHeaderProtectionMask(
-      quiche::QuicheStringPiece /*sample*/) override {
+      absl::string_view /*sample*/) override {
     return std::string(5, 0);
   }
 
@@ -1792,12 +1788,10 @@
     return plaintext_size + kTagSize;
   }
 
-  quiche::QuicheStringPiece GetKey() const override {
-    return quiche::QuicheStringPiece();
-  }
+  absl::string_view GetKey() const override { return absl::string_view(); }
 
-  quiche::QuicheStringPiece GetNoncePrefix() const override {
-    return quiche::QuicheStringPiece();
+  absl::string_view GetNoncePrefix() const override {
+    return absl::string_view();
   }
 
  private:
@@ -1815,19 +1809,19 @@
   ~TaggingDecrypter() override {}
 
   // QuicDecrypter interface
-  bool SetKey(quiche::QuicheStringPiece /*key*/) override { return true; }
+  bool SetKey(absl::string_view /*key*/) override { return true; }
 
-  bool SetNoncePrefix(quiche::QuicheStringPiece /*nonce_prefix*/) override {
+  bool SetNoncePrefix(absl::string_view /*nonce_prefix*/) override {
     return true;
   }
 
-  bool SetIV(quiche::QuicheStringPiece /*iv*/) override { return true; }
+  bool SetIV(absl::string_view /*iv*/) override { return true; }
 
-  bool SetHeaderProtectionKey(quiche::QuicheStringPiece /*key*/) override {
+  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;
   }
@@ -1837,8 +1831,8 @@
   }
 
   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;
@@ -1851,17 +1845,15 @@
   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 0xFFFFFFF0; }
 
  protected:
-  virtual uint8_t GetTag(quiche::QuicheStringPiece ciphertext) {
+  virtual uint8_t GetTag(absl::string_view ciphertext) {
     return ciphertext.data()[ciphertext.size() - 1];
   }
 
@@ -1870,7 +1862,7 @@
     kTagSize = 12,
   };
 
-  bool CheckTag(quiche::QuicheStringPiece ciphertext, uint8_t tag);
+  bool CheckTag(absl::string_view ciphertext, uint8_t tag);
 };
 
 class TestPacketWriter : public QuicPacketWriter {
diff --git a/quic/test_tools/quic_transport_test_tools.h b/quic/test_tools/quic_transport_test_tools.h
index 50db80a..ba0cc39 100644
--- a/quic/test_tools/quic_transport_test_tools.h
+++ b/quic/test_tools/quic_transport_test_tools.h
@@ -17,10 +17,7 @@
   MOCK_METHOD(void, OnSessionReady, (), (override));
   MOCK_METHOD(void, OnIncomingBidirectionalStreamAvailable, (), (override));
   MOCK_METHOD(void, OnIncomingUnidirectionalStreamAvailable, (), (override));
-  MOCK_METHOD(void,
-              OnDatagramReceived,
-              (quiche::QuicheStringPiece),
-              (override));
+  MOCK_METHOD(void, OnDatagramReceived, (absl::string_view), (override));
   MOCK_METHOD(void, OnCanCreateNewOutgoingBidirectionalStream, (), (override));
   MOCK_METHOD(void, OnCanCreateNewOutgoingUnidirectionalStream, (), (override));
 };
diff --git a/quic/test_tools/simple_data_producer.cc b/quic/test_tools/simple_data_producer.cc
index 0d5fa5b..619051d 100644
--- a/quic/test_tools/simple_data_producer.cc
+++ b/quic/test_tools/simple_data_producer.cc
@@ -6,11 +6,11 @@
 
 #include <utility>
 
+#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/platform/api/quic_bug_tracker.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -36,7 +36,7 @@
 
 void SimpleDataProducer::SaveCryptoData(EncryptionLevel level,
                                         QuicStreamOffset offset,
-                                        quiche::QuicheStringPiece data) {
+                                        absl::string_view data) {
   auto key = std::make_pair(level, offset);
   crypto_buffer_map_[key] = data;
 }
@@ -65,7 +65,7 @@
     return false;
   }
   return writer->WriteStringPiece(
-      quiche::QuicheStringPiece(it->second.data(), data_length));
+      absl::string_view(it->second.data(), data_length));
 }
 
 }  // namespace test
diff --git a/quic/test_tools/simple_data_producer.h b/quic/test_tools/simple_data_producer.h
index 626d1e9..4904dd3 100644
--- a/quic/test_tools/simple_data_producer.h
+++ b/quic/test_tools/simple_data_producer.h
@@ -5,11 +5,11 @@
 #ifndef QUICHE_QUIC_TEST_TOOLS_SIMPLE_DATA_PRODUCER_H_
 #define QUICHE_QUIC_TEST_TOOLS_SIMPLE_DATA_PRODUCER_H_
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_simple_buffer_allocator.h"
 #include "net/third_party/quiche/src/quic/core/quic_stream_frame_data_producer.h"
 #include "net/third_party/quiche/src/quic/core/quic_stream_send_buffer.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -36,7 +36,7 @@
 
   void SaveCryptoData(EncryptionLevel level,
                       QuicStreamOffset offset,
-                      quiche::QuicheStringPiece data);
+                      absl::string_view data);
 
   // QuicStreamFrameDataProducer
   WriteStreamDataResult WriteStreamData(QuicStreamId id,
@@ -63,7 +63,7 @@
 
   using CryptoBufferMap =
       QuicHashMap<std::pair<EncryptionLevel, QuicStreamOffset>,
-                  quiche::QuicheStringPiece,
+                  absl::string_view,
                   PairHash>;
 
   SimpleBufferAllocator allocator_;
diff --git a/quic/test_tools/simple_quic_framer.cc b/quic/test_tools/simple_quic_framer.cc
index 8ec56dc..2b974ee 100644
--- a/quic/test_tools/simple_quic_framer.cc
+++ b/quic/test_tools/simple_quic_framer.cc
@@ -7,10 +7,10 @@
 #include <memory>
 #include <utility>
 
+#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/platform/api/quic_ptr_util.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -41,10 +41,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 {}
 
   bool OnUnauthenticatedPublicHeader(
       const QuicPacketHeader& /*header*/) override {
@@ -78,7 +77,7 @@
     // TODO(ianswett): A pointer isn't necessary with emplace_back.
     stream_frames_.push_back(std::make_unique<QuicStreamFrame>(
         frame.stream_id, frame.fin, frame.offset,
-        quiche::QuicheStringPiece(*string_data)));
+        absl::string_view(*string_data)));
     return true;
   }
 
@@ -88,7 +87,7 @@
         new std::string(frame.data_buffer, frame.data_length);
     crypto_data_.push_back(QuicWrapUnique(string_data));
     crypto_frames_.push_back(std::make_unique<QuicCryptoFrame>(
-        frame.level, frame.offset, quiche::QuicheStringPiece(*string_data)));
+        frame.level, frame.offset, absl::string_view(*string_data)));
     return true;
   }
 
diff --git a/quic/test_tools/test_certificates.cc b/quic/test_tools/test_certificates.cc
index 025a816..038bda7 100644
--- a/quic/test_tools/test_certificates.cc
+++ b/quic/test_tools/test_certificates.cc
@@ -116,7 +116,7 @@
     '\xd3', '\xfb', '\xba', '\xaf', '\xd9', '\x61', '\x14', '\x3c', '\xe0',
     '\xa1', '\xa9', '\x51', '\x51', '\x0f', '\xad', '\x60'};
 
-QUIC_CONST_INIT const quiche::QuicheStringPiece kTestCertificate(
+QUIC_CONST_INIT const absl::string_view kTestCertificate(
     kTestCertificateRaw,
     sizeof(kTestCertificateRaw));
 
@@ -415,7 +415,7 @@
     '\x3e', '\x6b', '\x2e', '\xfa', '\x4f', '\x4d', '\xe6', '\xbe', '\xd3',
     '\x59'};
 
-QUIC_CONST_INIT const quiche::QuicheStringPiece kTestCertificatePrivateKey(
+QUIC_CONST_INIT const absl::string_view kTestCertificatePrivateKey(
     kTestCertificatePrivateKeyRaw,
     sizeof(kTestCertificatePrivateKeyRaw));
 
@@ -574,7 +574,7 @@
     '\xf0', '\xb7', '\xbb', '\x58', '\x4c', '\x8f', '\x6a', '\x5d', '\x8e',
     '\x93', '\x5f', '\x35'};
 
-QUIC_CONST_INIT const quiche::QuicheStringPiece kWildcardCertificate(
+QUIC_CONST_INIT const absl::string_view kWildcardCertificate(
     kWildcardCertificateRaw,
     sizeof(kWildcardCertificateRaw));
 
@@ -716,7 +716,7 @@
     '\x47', '\xca', '\x21', '\x30', '\x65', '\xa4', '\xe5', '\xaa', '\x4e',
     '\x9c', '\xbc', '\xa5'};
 
-QUIC_CONST_INIT const quiche::QuicheStringPiece kWildcardCertificatePrivateKey(
+QUIC_CONST_INIT const absl::string_view kWildcardCertificatePrivateKey(
     kWildcardCertificatePrivateKeyRaw,
     sizeof(kWildcardCertificatePrivateKeyRaw));
 
diff --git a/quic/test_tools/test_certificates.h b/quic/test_tools/test_certificates.h
index f617941..759e73e 100644
--- a/quic/test_tools/test_certificates.h
+++ b/quic/test_tools/test_certificates.h
@@ -5,14 +5,14 @@
 #ifndef QUICHE_QUIC_TEST_TOOLS_TEST_CERTIFICATES_H_
 #define QUICHE_QUIC_TEST_TOOLS_TEST_CERTIFICATES_H_
 
+#include "absl/strings/string_view.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 {
 
 // A test certificate generated by //net/tools/quic/certs/generate-certs.sh.
-QUIC_CONST_INIT extern const quiche::QuicheStringPiece kTestCertificate;
+QUIC_CONST_INIT extern const absl::string_view kTestCertificate;
 
 // PEM-encoded version of |kTestCertificate|.
 QUIC_CONST_INIT extern const char kTestCertificatePem[];
@@ -25,8 +25,7 @@
 QUIC_CONST_INIT extern const char kTestCertWithUnknownSanTypePem[];
 
 // DER-encoded private key for |kTestCertificate|.
-QUIC_CONST_INIT extern const quiche::QuicheStringPiece
-    kTestCertificatePrivateKey;
+QUIC_CONST_INIT extern const absl::string_view kTestCertificatePrivateKey;
 
 // PEM-encoded version of |kTestCertificatePrivateKey|.
 QUIC_CONST_INIT extern const char kTestCertificatePrivateKeyPem[];
@@ -37,11 +36,10 @@
 
 // Another DER-encoded test certificate, valid for foo.test, www.foo.test and
 // *.wildcard.test.
-QUIC_CONST_INIT extern const quiche::QuicheStringPiece kWildcardCertificate;
+QUIC_CONST_INIT extern const absl::string_view kWildcardCertificate;
 
 // DER-encoded private key for |kWildcardCertificate|.
-QUIC_CONST_INIT extern const quiche::QuicheStringPiece
-    kWildcardCertificatePrivateKey;
+QUIC_CONST_INIT extern const absl::string_view kWildcardCertificatePrivateKey;
 
 // PEM-encoded P-256 private key using legacy OpenSSL encoding.
 QUIC_CONST_INIT extern const char kTestEcPrivateKeyLegacyPem[];
diff --git a/quic/test_tools/test_ticket_crypter.cc b/quic/test_tools/test_ticket_crypter.cc
index 4d0d93e..afd2db4 100644
--- a/quic/test_tools/test_ticket_crypter.cc
+++ b/quic/test_tools/test_ticket_crypter.cc
@@ -29,7 +29,7 @@
   return QUICHE_ARRAYSIZE(kTicketPrefix);
 }
 
-std::vector<uint8_t> TestTicketCrypter::Encrypt(quiche::QuicheStringPiece in) {
+std::vector<uint8_t> TestTicketCrypter::Encrypt(absl::string_view in) {
   size_t prefix_len = QUICHE_ARRAYSIZE(kTicketPrefix);
   std::vector<uint8_t> out(prefix_len + in.size());
   memcpy(out.data(), kTicketPrefix, prefix_len);
@@ -37,7 +37,7 @@
   return out;
 }
 
-std::vector<uint8_t> TestTicketCrypter::Decrypt(quiche::QuicheStringPiece in) {
+std::vector<uint8_t> TestTicketCrypter::Decrypt(absl::string_view in) {
   size_t prefix_len = QUICHE_ARRAYSIZE(kTicketPrefix);
   if (fail_decrypt_ || in.size() < prefix_len ||
       memcmp(kTicketPrefix, in.data(), prefix_len) != 0) {
@@ -47,7 +47,7 @@
 }
 
 void TestTicketCrypter::Decrypt(
-    quiche::QuicheStringPiece in,
+    absl::string_view in,
     std::unique_ptr<ProofSource::DecryptCallback> callback) {
   auto decrypted_ticket = Decrypt(in);
   if (run_async_) {
diff --git a/quic/test_tools/test_ticket_crypter.h b/quic/test_tools/test_ticket_crypter.h
index b596348..5fdfdb9 100644
--- a/quic/test_tools/test_ticket_crypter.h
+++ b/quic/test_tools/test_ticket_crypter.h
@@ -18,8 +18,8 @@
 
   // TicketCrypter interface
   size_t MaxOverhead() override;
-  std::vector<uint8_t> Encrypt(quiche::QuicheStringPiece in) override;
-  void Decrypt(quiche::QuicheStringPiece in,
+  std::vector<uint8_t> Encrypt(absl::string_view in) override;
+  void Decrypt(absl::string_view in,
                std::unique_ptr<ProofSource::DecryptCallback> callback) override;
 
   void SetRunCallbacksAsync(bool run_async);
@@ -31,7 +31,7 @@
 
  private:
   // Performs the Decrypt operation synchronously.
-  std::vector<uint8_t> Decrypt(quiche::QuicheStringPiece in);
+  std::vector<uint8_t> Decrypt(absl::string_view in);
 
   struct PendingCallback {
     std::unique_ptr<ProofSource::DecryptCallback> callback;