diff --git a/quic/core/crypto/aead_base_decrypter.cc b/quic/core/crypto/aead_base_decrypter.cc
index f3be16e..3753635 100644
--- a/quic/core/crypto/aead_base_decrypter.cc
+++ b/quic/core/crypto/aead_base_decrypter.cc
@@ -7,6 +7,7 @@
 #include <cstdint>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/crypto.h"
 #include "third_party/boringssl/src/include/openssl/err.h"
 #include "third_party/boringssl/src/include/openssl/evp.h"
@@ -14,7 +15,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.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"
 
 namespace quic {
 
@@ -69,7 +69,7 @@
 
 AeadBaseDecrypter::~AeadBaseDecrypter() {}
 
-bool AeadBaseDecrypter::SetKey(quiche::QuicheStringPiece key) {
+bool AeadBaseDecrypter::SetKey(absl::string_view key) {
   DCHECK_EQ(key.size(), key_size_);
   if (key.size() != key_size_) {
     return false;
@@ -86,7 +86,7 @@
   return true;
 }
 
-bool AeadBaseDecrypter::SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) {
+bool AeadBaseDecrypter::SetNoncePrefix(absl::string_view nonce_prefix) {
   if (use_ietf_nonce_construction_) {
     QUIC_BUG << "Attempted to set nonce prefix on IETF QUIC crypter";
     return false;
@@ -99,7 +99,7 @@
   return true;
 }
 
-bool AeadBaseDecrypter::SetIV(quiche::QuicheStringPiece iv) {
+bool AeadBaseDecrypter::SetIV(absl::string_view iv) {
   if (!use_ietf_nonce_construction_) {
     QUIC_BUG << "Attempted to set IV on Google QUIC crypter";
     return false;
@@ -112,7 +112,7 @@
   return true;
 }
 
-bool AeadBaseDecrypter::SetPreliminaryKey(quiche::QuicheStringPiece key) {
+bool AeadBaseDecrypter::SetPreliminaryKey(absl::string_view key) {
   DCHECK(!have_preliminary_key_);
   SetKey(key);
   have_preliminary_key_ = true;
@@ -132,10 +132,9 @@
     prefix_size -= sizeof(QuicPacketNumber);
   }
   DiversifyPreliminaryKey(
-      quiche::QuicheStringPiece(reinterpret_cast<const char*>(key_), key_size_),
-      quiche::QuicheStringPiece(reinterpret_cast<const char*>(iv_),
-                                prefix_size),
-      nonce, key_size_, prefix_size, &key, &nonce_prefix);
+      absl::string_view(reinterpret_cast<const char*>(key_), key_size_),
+      absl::string_view(reinterpret_cast<const char*>(iv_), prefix_size), nonce,
+      key_size_, prefix_size, &key, &nonce_prefix);
 
   if (!SetKey(key) ||
       (!use_ietf_nonce_construction_ && !SetNoncePrefix(nonce_prefix)) ||
@@ -149,8 +148,8 @@
 }
 
 bool AeadBaseDecrypter::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) {
@@ -201,14 +200,13 @@
   return nonce_size_;
 }
 
-quiche::QuicheStringPiece AeadBaseDecrypter::GetKey() const {
-  return quiche::QuicheStringPiece(reinterpret_cast<const char*>(key_),
-                                   key_size_);
+absl::string_view AeadBaseDecrypter::GetKey() const {
+  return absl::string_view(reinterpret_cast<const char*>(key_), key_size_);
 }
 
-quiche::QuicheStringPiece AeadBaseDecrypter::GetNoncePrefix() const {
-  return quiche::QuicheStringPiece(reinterpret_cast<const char*>(iv_),
-                                   nonce_size_ - sizeof(QuicPacketNumber));
+absl::string_view AeadBaseDecrypter::GetNoncePrefix() const {
+  return absl::string_view(reinterpret_cast<const char*>(iv_),
+                           nonce_size_ - sizeof(QuicPacketNumber));
 }
 
 }  // namespace quic
diff --git a/quic/core/crypto/aead_base_decrypter.h b/quic/core/crypto/aead_base_decrypter.h
index e69b0ed..c4c04fe 100644
--- a/quic/core/crypto/aead_base_decrypter.h
+++ b/quic/core/crypto/aead_base_decrypter.h
@@ -7,10 +7,10 @@
 
 #include <cstddef>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/aead.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.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 {
 
@@ -29,22 +29,22 @@
   ~AeadBaseDecrypter() override;
 
   // QuicDecrypter implementation
-  bool SetKey(quiche::QuicheStringPiece key) override;
-  bool SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) override;
-  bool SetIV(quiche::QuicheStringPiece iv) override;
-  bool SetPreliminaryKey(quiche::QuicheStringPiece key) override;
+  bool SetKey(absl::string_view key) override;
+  bool SetNoncePrefix(absl::string_view nonce_prefix) override;
+  bool SetIV(absl::string_view iv) override;
+  bool SetPreliminaryKey(absl::string_view key) override;
   bool SetDiversificationNonce(const DiversificationNonce& nonce) override;
   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;
   size_t GetKeySize() const override;
   size_t GetNoncePrefixSize() const override;
   size_t GetIVSize() const override;
-  quiche::QuicheStringPiece GetKey() const override;
-  quiche::QuicheStringPiece GetNoncePrefix() const override;
+  absl::string_view GetKey() const override;
+  absl::string_view GetNoncePrefix() const override;
 
  protected:
   // Make these constants available to the subclasses so that the subclasses
diff --git a/quic/core/crypto/aead_base_encrypter.cc b/quic/core/crypto/aead_base_encrypter.cc
index 14aca26..d6360f4 100644
--- a/quic/core/crypto/aead_base_encrypter.cc
+++ b/quic/core/crypto/aead_base_encrypter.cc
@@ -4,6 +4,7 @@
 
 #include "net/third_party/quiche/src/quic/core/crypto/aead_base_encrypter.h"
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/crypto.h"
 #include "third_party/boringssl/src/include/openssl/err.h"
 #include "third_party/boringssl/src/include/openssl/evp.h"
@@ -12,7 +13,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.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"
 
 namespace quic {
 
@@ -59,7 +59,7 @@
 
 AeadBaseEncrypter::~AeadBaseEncrypter() {}
 
-bool AeadBaseEncrypter::SetKey(quiche::QuicheStringPiece key) {
+bool AeadBaseEncrypter::SetKey(absl::string_view key) {
   DCHECK_EQ(key.size(), key_size_);
   if (key.size() != key_size_) {
     return false;
@@ -77,7 +77,7 @@
   return true;
 }
 
-bool AeadBaseEncrypter::SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) {
+bool AeadBaseEncrypter::SetNoncePrefix(absl::string_view nonce_prefix) {
   if (use_ietf_nonce_construction_) {
     QUIC_BUG << "Attempted to set nonce prefix on IETF QUIC crypter";
     return false;
@@ -90,7 +90,7 @@
   return true;
 }
 
-bool AeadBaseEncrypter::SetIV(quiche::QuicheStringPiece iv) {
+bool AeadBaseEncrypter::SetIV(absl::string_view iv) {
   if (!use_ietf_nonce_construction_) {
     QUIC_BUG << "Attempted to set IV on Google QUIC crypter";
     return false;
@@ -103,9 +103,9 @@
   return true;
 }
 
-bool AeadBaseEncrypter::Encrypt(quiche::QuicheStringPiece nonce,
-                                quiche::QuicheStringPiece associated_data,
-                                quiche::QuicheStringPiece plaintext,
+bool AeadBaseEncrypter::Encrypt(absl::string_view nonce,
+                                absl::string_view associated_data,
+                                absl::string_view plaintext,
                                 unsigned char* output) {
   DCHECK_EQ(nonce.size(), nonce_size_);
 
@@ -125,8 +125,8 @@
 }
 
 bool AeadBaseEncrypter::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) {
@@ -148,9 +148,8 @@
     memcpy(nonce_buffer + prefix_len, &packet_number, sizeof(packet_number));
   }
 
-  if (!Encrypt(quiche::QuicheStringPiece(nonce_buffer, nonce_size_),
-               associated_data, plaintext,
-               reinterpret_cast<unsigned char*>(output))) {
+  if (!Encrypt(absl::string_view(nonce_buffer, nonce_size_), associated_data,
+               plaintext, reinterpret_cast<unsigned char*>(output))) {
     return false;
   }
   *output_length = ciphertext_size;
@@ -177,14 +176,13 @@
   return plaintext_size + auth_tag_size_;
 }
 
-quiche::QuicheStringPiece AeadBaseEncrypter::GetKey() const {
-  return quiche::QuicheStringPiece(reinterpret_cast<const char*>(key_),
-                                   key_size_);
+absl::string_view AeadBaseEncrypter::GetKey() const {
+  return absl::string_view(reinterpret_cast<const char*>(key_), key_size_);
 }
 
-quiche::QuicheStringPiece AeadBaseEncrypter::GetNoncePrefix() const {
-  return quiche::QuicheStringPiece(reinterpret_cast<const char*>(iv_),
-                                   GetNoncePrefixSize());
+absl::string_view AeadBaseEncrypter::GetNoncePrefix() const {
+  return absl::string_view(reinterpret_cast<const char*>(iv_),
+                           GetNoncePrefixSize());
 }
 
 }  // namespace quic
diff --git a/quic/core/crypto/aead_base_encrypter.h b/quic/core/crypto/aead_base_encrypter.h
index 5209a02..5ef8b96 100644
--- a/quic/core/crypto/aead_base_encrypter.h
+++ b/quic/core/crypto/aead_base_encrypter.h
@@ -7,10 +7,10 @@
 
 #include <cstddef>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/aead.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.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 {
 
@@ -29,12 +29,12 @@
   ~AeadBaseEncrypter() override;
 
   // QuicEncrypter implementation
-  bool SetKey(quiche::QuicheStringPiece key) override;
-  bool SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) override;
-  bool SetIV(quiche::QuicheStringPiece iv) override;
+  bool SetKey(absl::string_view key) override;
+  bool SetNoncePrefix(absl::string_view nonce_prefix) override;
+  bool SetIV(absl::string_view iv) override;
   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;
@@ -43,14 +43,14 @@
   size_t GetIVSize() const override;
   size_t GetMaxPlaintextSize(size_t ciphertext_size) const override;
   size_t GetCiphertextSize(size_t plaintext_size) const override;
-  quiche::QuicheStringPiece GetKey() const override;
-  quiche::QuicheStringPiece GetNoncePrefix() const override;
+  absl::string_view GetKey() const override;
+  absl::string_view GetNoncePrefix() const override;
 
   // Necessary so unit tests can explicitly specify a nonce, instead of an IV
   // (or nonce prefix) and packet number.
-  bool Encrypt(quiche::QuicheStringPiece nonce,
-               quiche::QuicheStringPiece associated_data,
-               quiche::QuicheStringPiece plaintext,
+  bool Encrypt(absl::string_view nonce,
+               absl::string_view associated_data,
+               absl::string_view plaintext,
                unsigned char* output);
 
  protected:
diff --git a/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc b/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc
index 0319d42..52a099e 100644
--- a/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc
+++ b/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc
@@ -7,11 +7,11 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.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/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"
 #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"
 
@@ -202,12 +202,12 @@
 // DecryptWithNonce wraps the |Decrypt| method of |decrypter| to allow passing
 // in an nonce and also to allocate the buffer needed for the plaintext.
 QuicData* DecryptWithNonce(Aes128Gcm12Decrypter* decrypter,
-                           quiche::QuicheStringPiece nonce,
-                           quiche::QuicheStringPiece associated_data,
-                           quiche::QuicheStringPiece ciphertext) {
+                           absl::string_view nonce,
+                           absl::string_view associated_data,
+                           absl::string_view ciphertext) {
   uint64_t packet_number;
-  quiche::QuicheStringPiece nonce_prefix(nonce.data(),
-                                         nonce.size() - sizeof(packet_number));
+  absl::string_view nonce_prefix(nonce.data(),
+                                 nonce.size() - sizeof(packet_number));
   decrypter->SetNoncePrefix(nonce_prefix);
   memcpy(&packet_number, nonce.data() + nonce_prefix.size(),
          sizeof(packet_number));
@@ -270,7 +270,7 @@
           // This deliberately tests that the decrypter can
           // handle an AAD that is set to nullptr, as opposed
           // to a zero-length, non-nullptr pointer.
-          aad.length() ? aad : quiche::QuicheStringPiece(), ciphertext));
+          aad.length() ? aad : absl::string_view(), ciphertext));
       if (!decrypted) {
         EXPECT_FALSE(has_pt);
         continue;
diff --git a/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc b/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc
index bc3f611..9e395cc 100644
--- a/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc
+++ b/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc
@@ -7,11 +7,11 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.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/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"
 #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"
 
@@ -160,9 +160,9 @@
 // EncryptWithNonce wraps the |Encrypt| method of |encrypter| to allow passing
 // in an nonce and also to allocate the buffer needed for the ciphertext.
 QuicData* EncryptWithNonce(Aes128Gcm12Encrypter* encrypter,
-                           quiche::QuicheStringPiece nonce,
-                           quiche::QuicheStringPiece associated_data,
-                           quiche::QuicheStringPiece plaintext) {
+                           absl::string_view nonce,
+                           absl::string_view associated_data,
+                           absl::string_view plaintext) {
   size_t ciphertext_size = encrypter->GetCiphertextSize(plaintext.length());
   std::unique_ptr<char[]> ciphertext(new char[ciphertext_size]);
 
@@ -201,12 +201,12 @@
 
       Aes128Gcm12Encrypter encrypter;
       ASSERT_TRUE(encrypter.SetKey(key));
-      std::unique_ptr<QuicData> encrypted(EncryptWithNonce(
-          &encrypter, iv,
-          // This deliberately tests that the encrypter can
-          // handle an AAD that is set to nullptr, as opposed
-          // to a zero-length, non-nullptr pointer.
-          aad.length() ? aad : quiche::QuicheStringPiece(), pt));
+      std::unique_ptr<QuicData> encrypted(
+          EncryptWithNonce(&encrypter, iv,
+                           // This deliberately tests that the encrypter can
+                           // handle an AAD that is set to nullptr, as opposed
+                           // to a zero-length, non-nullptr pointer.
+                           aad.length() ? aad : absl::string_view(), pt));
       ASSERT_TRUE(encrypted.get());
 
       // The test vectors have 16 byte authenticators but this code only uses
diff --git a/quic/core/crypto/aes_128_gcm_decrypter_test.cc b/quic/core/crypto/aes_128_gcm_decrypter_test.cc
index a444284..33c3781 100644
--- a/quic/core/crypto/aes_128_gcm_decrypter_test.cc
+++ b/quic/core/crypto/aes_128_gcm_decrypter_test.cc
@@ -201,9 +201,9 @@
 // DecryptWithNonce wraps the |Decrypt| method of |decrypter| to allow passing
 // in an nonce and also to allocate the buffer needed for the plaintext.
 QuicData* DecryptWithNonce(Aes128GcmDecrypter* decrypter,
-                           quiche::QuicheStringPiece nonce,
-                           quiche::QuicheStringPiece associated_data,
-                           quiche::QuicheStringPiece ciphertext) {
+                           absl::string_view nonce,
+                           absl::string_view associated_data,
+                           absl::string_view ciphertext) {
   decrypter->SetIV(nonce);
   std::unique_ptr<char[]> output(new char[ciphertext.length()]);
   size_t output_length = 0;
@@ -258,7 +258,7 @@
           // This deliberately tests that the decrypter can
           // handle an AAD that is set to nullptr, as opposed
           // to a zero-length, non-nullptr pointer.
-          aad.length() ? aad : quiche::QuicheStringPiece(), ciphertext));
+          aad.length() ? aad : absl::string_view(), ciphertext));
       if (!decrypted) {
         EXPECT_FALSE(has_pt);
         continue;
diff --git a/quic/core/crypto/aes_128_gcm_encrypter_test.cc b/quic/core/crypto/aes_128_gcm_encrypter_test.cc
index 69f8c4d..b163689 100644
--- a/quic/core/crypto/aes_128_gcm_encrypter_test.cc
+++ b/quic/core/crypto/aes_128_gcm_encrypter_test.cc
@@ -159,9 +159,9 @@
 // EncryptWithNonce wraps the |Encrypt| method of |encrypter| to allow passing
 // in an nonce and also to allocate the buffer needed for the ciphertext.
 QuicData* EncryptWithNonce(Aes128GcmEncrypter* encrypter,
-                           quiche::QuicheStringPiece nonce,
-                           quiche::QuicheStringPiece associated_data,
-                           quiche::QuicheStringPiece plaintext) {
+                           absl::string_view nonce,
+                           absl::string_view associated_data,
+                           absl::string_view plaintext) {
   size_t ciphertext_size = encrypter->GetCiphertextSize(plaintext.length());
   std::unique_ptr<char[]> ciphertext(new char[ciphertext_size]);
 
@@ -200,12 +200,12 @@
 
       Aes128GcmEncrypter encrypter;
       ASSERT_TRUE(encrypter.SetKey(key));
-      std::unique_ptr<QuicData> encrypted(EncryptWithNonce(
-          &encrypter, iv,
-          // This deliberately tests that the encrypter can
-          // handle an AAD that is set to nullptr, as opposed
-          // to a zero-length, non-nullptr pointer.
-          aad.length() ? aad : quiche::QuicheStringPiece(), pt));
+      std::unique_ptr<QuicData> encrypted(
+          EncryptWithNonce(&encrypter, iv,
+                           // This deliberately tests that the encrypter can
+                           // handle an AAD that is set to nullptr, as opposed
+                           // to a zero-length, non-nullptr pointer.
+                           aad.length() ? aad : absl::string_view(), pt));
       ASSERT_TRUE(encrypted.get());
 
       ASSERT_EQ(ct.length() + tag.length(), encrypted->length());
diff --git a/quic/core/crypto/aes_256_gcm_decrypter_test.cc b/quic/core/crypto/aes_256_gcm_decrypter_test.cc
index 7c69724..e244f4a 100644
--- a/quic/core/crypto/aes_256_gcm_decrypter_test.cc
+++ b/quic/core/crypto/aes_256_gcm_decrypter_test.cc
@@ -7,11 +7,11 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.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/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"
 #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"
 
@@ -206,9 +206,9 @@
 // DecryptWithNonce wraps the |Decrypt| method of |decrypter| to allow passing
 // in an nonce and also to allocate the buffer needed for the plaintext.
 QuicData* DecryptWithNonce(Aes256GcmDecrypter* decrypter,
-                           quiche::QuicheStringPiece nonce,
-                           quiche::QuicheStringPiece associated_data,
-                           quiche::QuicheStringPiece ciphertext) {
+                           absl::string_view nonce,
+                           absl::string_view associated_data,
+                           absl::string_view ciphertext) {
   decrypter->SetIV(nonce);
   std::unique_ptr<char[]> output(new char[ciphertext.length()]);
   size_t output_length = 0;
@@ -263,7 +263,7 @@
           // This deliberately tests that the decrypter can
           // handle an AAD that is set to nullptr, as opposed
           // to a zero-length, non-nullptr pointer.
-          aad.length() ? aad : quiche::QuicheStringPiece(), ciphertext));
+          aad.length() ? aad : absl::string_view(), ciphertext));
       if (!decrypted) {
         EXPECT_FALSE(has_pt);
         continue;
diff --git a/quic/core/crypto/aes_256_gcm_encrypter_test.cc b/quic/core/crypto/aes_256_gcm_encrypter_test.cc
index 0899262..bdebfca 100644
--- a/quic/core/crypto/aes_256_gcm_encrypter_test.cc
+++ b/quic/core/crypto/aes_256_gcm_encrypter_test.cc
@@ -7,11 +7,11 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.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/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"
 #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"
 
@@ -167,9 +167,9 @@
 // EncryptWithNonce wraps the |Encrypt| method of |encrypter| to allow passing
 // in an nonce and also to allocate the buffer needed for the ciphertext.
 QuicData* EncryptWithNonce(Aes256GcmEncrypter* encrypter,
-                           quiche::QuicheStringPiece nonce,
-                           quiche::QuicheStringPiece associated_data,
-                           quiche::QuicheStringPiece plaintext) {
+                           absl::string_view nonce,
+                           absl::string_view associated_data,
+                           absl::string_view plaintext) {
   size_t ciphertext_size = encrypter->GetCiphertextSize(plaintext.length());
   std::unique_ptr<char[]> ciphertext(new char[ciphertext_size]);
 
@@ -208,12 +208,12 @@
 
       Aes256GcmEncrypter encrypter;
       ASSERT_TRUE(encrypter.SetKey(key));
-      std::unique_ptr<QuicData> encrypted(EncryptWithNonce(
-          &encrypter, iv,
-          // This deliberately tests that the encrypter can
-          // handle an AAD that is set to nullptr, as opposed
-          // to a zero-length, non-nullptr pointer.
-          aad.length() ? aad : quiche::QuicheStringPiece(), pt));
+      std::unique_ptr<QuicData> encrypted(
+          EncryptWithNonce(&encrypter, iv,
+                           // This deliberately tests that the encrypter can
+                           // handle an AAD that is set to nullptr, as opposed
+                           // to a zero-length, non-nullptr pointer.
+                           aad.length() ? aad : absl::string_view(), pt));
       ASSERT_TRUE(encrypted.get());
 
       ASSERT_EQ(ct.length() + tag.length(), encrypted->length());
diff --git a/quic/core/crypto/aes_base_decrypter.cc b/quic/core/crypto/aes_base_decrypter.cc
index f8c83f3..5bd9c33 100644
--- a/quic/core/crypto/aes_base_decrypter.cc
+++ b/quic/core/crypto/aes_base_decrypter.cc
@@ -4,13 +4,13 @@
 
 #include "net/third_party/quiche/src/quic/core/crypto/aes_base_decrypter.h"
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/aes.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
-bool AesBaseDecrypter::SetHeaderProtectionKey(quiche::QuicheStringPiece key) {
+bool AesBaseDecrypter::SetHeaderProtectionKey(absl::string_view key) {
   if (key.size() != GetKeySize()) {
     QUIC_BUG << "Invalid key size for header protection";
     return false;
@@ -25,7 +25,7 @@
 
 std::string AesBaseDecrypter::GenerateHeaderProtectionMask(
     QuicDataReader* sample_reader) {
-  quiche::QuicheStringPiece sample;
+  absl::string_view sample;
   if (!sample_reader->ReadStringPiece(&sample, AES_BLOCK_SIZE)) {
     return std::string();
   }
diff --git a/quic/core/crypto/aes_base_decrypter.h b/quic/core/crypto/aes_base_decrypter.h
index 2ff63a7..e3613e4 100644
--- a/quic/core/crypto/aes_base_decrypter.h
+++ b/quic/core/crypto/aes_base_decrypter.h
@@ -7,10 +7,10 @@
 
 #include <cstddef>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/aes.h"
 #include "net/third_party/quiche/src/quic/core/crypto/aead_base_decrypter.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 {
 
@@ -18,7 +18,7 @@
  public:
   using AeadBaseDecrypter::AeadBaseDecrypter;
 
-  bool SetHeaderProtectionKey(quiche::QuicheStringPiece key) override;
+  bool SetHeaderProtectionKey(absl::string_view key) override;
   std::string GenerateHeaderProtectionMask(
       QuicDataReader* sample_reader) override;
 
diff --git a/quic/core/crypto/aes_base_encrypter.cc b/quic/core/crypto/aes_base_encrypter.cc
index c620329..436b7bd 100644
--- a/quic/core/crypto/aes_base_encrypter.cc
+++ b/quic/core/crypto/aes_base_encrypter.cc
@@ -4,13 +4,13 @@
 
 #include "net/third_party/quiche/src/quic/core/crypto/aes_base_encrypter.h"
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/aes.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
-bool AesBaseEncrypter::SetHeaderProtectionKey(quiche::QuicheStringPiece key) {
+bool AesBaseEncrypter::SetHeaderProtectionKey(absl::string_view key) {
   if (key.size() != GetKeySize()) {
     QUIC_BUG << "Invalid key size for header protection: " << key.size();
     return false;
@@ -24,7 +24,7 @@
 }
 
 std::string AesBaseEncrypter::GenerateHeaderProtectionMask(
-    quiche::QuicheStringPiece sample) {
+    absl::string_view sample) {
   if (sample.size() != AES_BLOCK_SIZE) {
     return std::string();
   }
diff --git a/quic/core/crypto/aes_base_encrypter.h b/quic/core/crypto/aes_base_encrypter.h
index ba518fe..7339640 100644
--- a/quic/core/crypto/aes_base_encrypter.h
+++ b/quic/core/crypto/aes_base_encrypter.h
@@ -7,10 +7,10 @@
 
 #include <cstddef>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/aes.h"
 #include "net/third_party/quiche/src/quic/core/crypto/aead_base_encrypter.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 {
 
@@ -18,9 +18,8 @@
  public:
   using AeadBaseEncrypter::AeadBaseEncrypter;
 
-  bool SetHeaderProtectionKey(quiche::QuicheStringPiece key) override;
-  std::string GenerateHeaderProtectionMask(
-      quiche::QuicheStringPiece sample) override;
+  bool SetHeaderProtectionKey(absl::string_view key) override;
+  std::string GenerateHeaderProtectionMask(absl::string_view sample) override;
 
  private:
   // The key used for packet number encryption.
diff --git a/quic/core/crypto/boring_utils.h b/quic/core/crypto/boring_utils.h
index 5af87ae..9de61f4 100644
--- a/quic/core/crypto/boring_utils.h
+++ b/quic/core/crypto/boring_utils.h
@@ -5,19 +5,18 @@
 #ifndef QUICHE_QUIC_CORE_CRYPTO_BORING_UTILS_H_
 #define QUICHE_QUIC_CORE_CRYPTO_BORING_UTILS_H_
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/bytestring.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 {
 
-inline QUIC_EXPORT_PRIVATE quiche::QuicheStringPiece CbsToStringPiece(CBS cbs) {
-  return quiche::QuicheStringPiece(
-      reinterpret_cast<const char*>(CBS_data(&cbs)), CBS_len(&cbs));
+inline QUIC_EXPORT_PRIVATE absl::string_view CbsToStringPiece(CBS cbs) {
+  return absl::string_view(reinterpret_cast<const char*>(CBS_data(&cbs)),
+                           CBS_len(&cbs));
 }
 
-inline QUIC_EXPORT_PRIVATE CBS
-StringPieceToCbs(quiche::QuicheStringPiece piece) {
+inline QUIC_EXPORT_PRIVATE CBS StringPieceToCbs(absl::string_view piece) {
   CBS result;
   CBS_init(&result, reinterpret_cast<const uint8_t*>(piece.data()),
            piece.size());
diff --git a/quic/core/crypto/cert_compressor.cc b/quic/core/crypto/cert_compressor.cc
index a1ba748..ec5ebac 100644
--- a/quic/core/crypto/cert_compressor.cc
+++ b/quic/core/crypto/cert_compressor.cc
@@ -9,8 +9,8 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.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 "third_party/zlib/zlib.h"
 
 namespace quic {
@@ -175,11 +175,10 @@
 // efficiently represent |certs| to a peer who has the common sets identified
 // by |client_common_set_hashes| and who has cached the certificates with the
 // 64-bit, FNV-1a hashes in |client_cached_cert_hashes|.
-std::vector<CertEntry> MatchCerts(
-    const std::vector<std::string>& certs,
-    quiche::QuicheStringPiece client_common_set_hashes,
-    quiche::QuicheStringPiece client_cached_cert_hashes,
-    const CommonCertSets* common_sets) {
+std::vector<CertEntry> MatchCerts(const std::vector<std::string>& certs,
+                                  absl::string_view client_common_set_hashes,
+                                  absl::string_view client_cached_cert_hashes,
+                                  const CommonCertSets* common_sets) {
   std::vector<CertEntry> entries;
   entries.reserve(certs.size());
 
@@ -330,12 +329,12 @@
 // |in_out| and writes them to |out_entries|. CACHED and COMMON entries are
 // resolved using |cached_certs| and |common_sets| and written to |out_certs|.
 // |in_out| is updated to contain the trailing data.
-bool ParseEntries(quiche::QuicheStringPiece* in_out,
+bool ParseEntries(absl::string_view* in_out,
                   const std::vector<std::string>& cached_certs,
                   const CommonCertSets* common_sets,
                   std::vector<CertEntry>* out_entries,
                   std::vector<std::string>* out_certs) {
-  quiche::QuicheStringPiece in = *in_out;
+  absl::string_view in = *in_out;
   std::vector<uint64_t> cached_hashes;
 
   out_entries->clear();
@@ -394,7 +393,7 @@
         memcpy(&entry.index, in.data(), sizeof(uint32_t));
         in.remove_prefix(sizeof(uint32_t));
 
-        quiche::QuicheStringPiece cert =
+        absl::string_view cert =
             common_sets->GetCert(entry.set_hash, entry.index);
         if (cert.empty()) {
           return false;
@@ -452,8 +451,8 @@
 // static
 std::string CertCompressor::CompressChain(
     const std::vector<std::string>& certs,
-    quiche::QuicheStringPiece client_common_set_hashes,
-    quiche::QuicheStringPiece client_cached_cert_hashes,
+    absl::string_view client_common_set_hashes,
+    absl::string_view client_cached_cert_hashes,
     const CommonCertSets* common_sets) {
   const std::vector<CertEntry> entries = MatchCerts(
       certs, client_common_set_hashes, client_cached_cert_hashes, common_sets);
@@ -553,7 +552,7 @@
 
 // static
 bool CertCompressor::DecompressChain(
-    quiche::QuicheStringPiece in,
+    absl::string_view in,
     const std::vector<std::string>& cached_certs,
     const CommonCertSets* common_sets,
     std::vector<std::string>* out_certs) {
@@ -564,7 +563,7 @@
   DCHECK_EQ(entries.size(), out_certs->size());
 
   std::unique_ptr<uint8_t[]> uncompressed_data;
-  quiche::QuicheStringPiece uncompressed;
+  absl::string_view uncompressed;
 
   if (!in.empty()) {
     if (in.size() < sizeof(uint32_t)) {
@@ -609,7 +608,7 @@
       return false;
     }
 
-    uncompressed = quiche::QuicheStringPiece(
+    uncompressed = absl::string_view(
         reinterpret_cast<char*>(uncompressed_data.get()), uncompressed_size);
   }
 
diff --git a/quic/core/crypto/cert_compressor.h b/quic/core/crypto/cert_compressor.h
index dfb4d21..a9e9ec9 100644
--- a/quic/core/crypto/cert_compressor.h
+++ b/quic/core/crypto/cert_compressor.h
@@ -8,10 +8,10 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/common_cert_set.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.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,17 +36,16 @@
   // sets known locally and |client_common_set_hashes| contains the hashes of
   // the common sets known to the peer. |client_cached_cert_hashes| contains
   // 64-bit, FNV-1a hashes of certificates that the peer already possesses.
-  static std::string CompressChain(
-      const std::vector<std::string>& certs,
-      quiche::QuicheStringPiece client_common_set_hashes,
-      quiche::QuicheStringPiece client_cached_cert_hashes,
-      const CommonCertSets* common_sets);
+  static std::string CompressChain(const std::vector<std::string>& certs,
+                                   absl::string_view client_common_set_hashes,
+                                   absl::string_view client_cached_cert_hashes,
+                                   const CommonCertSets* common_sets);
 
   // DecompressChain decompresses the result of |CompressChain|, given in |in|,
   // into a series of certificates that are written to |out_certs|.
   // |cached_certs| contains certificates that the peer may have omitted and
   // |common_sets| contains the common certificate sets known locally.
-  static bool DecompressChain(quiche::QuicheStringPiece in,
+  static bool DecompressChain(absl::string_view in,
                               const std::vector<std::string>& cached_certs,
                               const CommonCertSets* common_sets,
                               std::vector<std::string>* out_certs);
diff --git a/quic/core/crypto/cert_compressor_test.cc b/quic/core/crypto/cert_compressor_test.cc
index a7517f4..6a3c27c 100644
--- a/quic/core/crypto/cert_compressor_test.cc
+++ b/quic/core/crypto/cert_compressor_test.cc
@@ -7,10 +7,10 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.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/crypto_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 {
@@ -21,7 +21,7 @@
 TEST_F(CertCompressorTest, EmptyChain) {
   std::vector<std::string> chain;
   const std::string compressed = CertCompressor::CompressChain(
-      chain, quiche::QuicheStringPiece(), quiche::QuicheStringPiece(), nullptr);
+      chain, absl::string_view(), absl::string_view(), nullptr);
   EXPECT_EQ("00", quiche::QuicheTextUtils::HexEncode(compressed));
 
   std::vector<std::string> chain2, cached_certs;
@@ -34,7 +34,7 @@
   std::vector<std::string> chain;
   chain.push_back("testcert");
   const std::string compressed = CertCompressor::CompressChain(
-      chain, quiche::QuicheStringPiece(), quiche::QuicheStringPiece(), nullptr);
+      chain, absl::string_view(), absl::string_view(), nullptr);
   ASSERT_GE(compressed.size(), 2u);
   EXPECT_EQ("0100",
             quiche::QuicheTextUtils::HexEncode(compressed.substr(0, 2)));
@@ -54,9 +54,9 @@
       crypto_test_utils::MockCommonCertSets(chain[0], set_hash, 1));
   const std::string compressed = CertCompressor::CompressChain(
       chain,
-      quiche::QuicheStringPiece(reinterpret_cast<const char*>(&set_hash),
-                                sizeof(set_hash)),
-      quiche::QuicheStringPiece(), common_sets.get());
+      absl::string_view(reinterpret_cast<const char*>(&set_hash),
+                        sizeof(set_hash)),
+      absl::string_view(), common_sets.get());
   EXPECT_EQ(
       "03"               /* common */
       "2a00000000000000" /* set hash 42 */
@@ -75,10 +75,9 @@
   std::vector<std::string> chain;
   chain.push_back("testcert");
   uint64_t hash = QuicUtils::FNV1a_64_Hash(chain[0]);
-  quiche::QuicheStringPiece hash_bytes(reinterpret_cast<char*>(&hash),
-                                       sizeof(hash));
+  absl::string_view hash_bytes(reinterpret_cast<char*>(&hash), sizeof(hash));
   const std::string compressed = CertCompressor::CompressChain(
-      chain, quiche::QuicheStringPiece(), hash_bytes, nullptr);
+      chain, absl::string_view(), hash_bytes, nullptr);
 
   EXPECT_EQ("02" /* cached */ + quiche::QuicheTextUtils::HexEncode(hash_bytes) +
                 "00" /* end of list */,
diff --git a/quic/core/crypto/certificate_view.cc b/quic/core/crypto/certificate_view.cc
index 36b6d3f..1fe0052 100644
--- a/quic/core/crypto/certificate_view.cc
+++ b/quic/core/crypto/certificate_view.cc
@@ -9,6 +9,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/base.h"
 #include "third_party/boringssl/src/include/openssl/bytestring.h"
 #include "third_party/boringssl/src/include/openssl/digest.h"
@@ -26,7 +27,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"
 #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_time_utils.h"
 #include "net/third_party/quiche/src/common/quiche_data_reader.h"
@@ -34,7 +34,6 @@
 namespace {
 
 using ::quiche::QuicheOptional;
-using ::quiche::QuicheStringPiece;
 using ::quiche::QuicheTextUtils;
 
 // The literals below were encoded using `ascii2der | xxd -i`.  The comments
@@ -106,7 +105,7 @@
 namespace quic {
 
 QuicheOptional<quic::QuicWallTime> ParseDerTime(unsigned tag,
-                                                QuicheStringPiece payload) {
+                                                absl::string_view payload) {
   if (tag != CBS_ASN1_GENERALIZEDTIME && tag != CBS_ASN1_UTCTIME) {
     QUIC_BUG << "Invalid tag supplied for a DER timestamp";
     return QUICHE_NULLOPT;
@@ -139,15 +138,15 @@
 }
 
 PemReadResult ReadNextPemMessage(std::istream* input) {
-  constexpr QuicheStringPiece kPemBegin = "-----BEGIN ";
-  constexpr QuicheStringPiece kPemEnd = "-----END ";
-  constexpr QuicheStringPiece kPemDashes = "-----";
+  constexpr absl::string_view kPemBegin = "-----BEGIN ";
+  constexpr absl::string_view kPemEnd = "-----END ";
+  constexpr absl::string_view kPemDashes = "-----";
 
   std::string line_buffer, encoded_message_contents, expected_end;
   bool pending_message = false;
   PemReadResult result;
   while (std::getline(*input, line_buffer)) {
-    QuicheStringPiece line(line_buffer);
+    absl::string_view line(line_buffer);
     QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(&line);
 
     // Handle BEGIN lines.
@@ -184,7 +183,7 @@
 }
 
 std::unique_ptr<CertificateView> CertificateView::ParseSingleCertificate(
-    QuicheStringPiece certificate) {
+    absl::string_view certificate) {
   std::unique_ptr<CertificateView> result(new CertificateView());
   CBS top = StringPieceToCbs(certificate);
 
@@ -348,7 +347,7 @@
           return false;
         }
 
-        QuicheStringPiece alt_name = CbsToStringPiece(alt_name_cbs);
+        absl::string_view alt_name = CbsToStringPiece(alt_name_cbs);
         QuicIpAddress ip_address;
         // GeneralName ::= CHOICE {
         switch (alt_name_tag) {
@@ -417,8 +416,8 @@
   }
 }
 
-bool CertificateView::VerifySignature(QuicheStringPiece data,
-                                      QuicheStringPiece signature,
+bool CertificateView::VerifySignature(absl::string_view data,
+                                      absl::string_view signature,
                                       uint16_t signature_algorithm) const {
   if (PublicKeyTypeFromSignatureAlgorithm(signature_algorithm) !=
       PublicKeyTypeFromKey(public_key_.get())) {
@@ -448,7 +447,7 @@
 }
 
 std::unique_ptr<CertificatePrivateKey> CertificatePrivateKey::LoadFromDer(
-    QuicheStringPiece private_key) {
+    absl::string_view private_key) {
   std::unique_ptr<CertificatePrivateKey> result(new CertificatePrivateKey());
   CBS private_key_cbs = StringPieceToCbs(private_key);
   result->private_key_.reset(EVP_parse_private_key(&private_key_cbs));
@@ -506,7 +505,7 @@
   return nullptr;
 }
 
-std::string CertificatePrivateKey::Sign(QuicheStringPiece input,
+std::string CertificatePrivateKey::Sign(absl::string_view input,
                                         uint16_t signature_algorithm) {
   if (!ValidForSignatureAlgorithm(signature_algorithm)) {
     QUIC_BUG << "Mismatch between the requested signature algorithm and the "
diff --git a/quic/core/crypto/certificate_view.h b/quic/core/crypto/certificate_view.h
index d06ff78..18f62f0 100644
--- a/quic/core/crypto/certificate_view.h
+++ b/quic/core/crypto/certificate_view.h
@@ -9,6 +9,7 @@
 #include <memory>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/base.h"
 #include "third_party/boringssl/src/include/openssl/bytestring.h"
 #include "third_party/boringssl/src/include/openssl/evp.h"
@@ -18,7 +19,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_ip_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 {
 
@@ -43,7 +43,7 @@
   // Parses a single DER-encoded X.509 certificate.  Returns nullptr on parse
   // error.
   static std::unique_ptr<CertificateView> ParseSingleCertificate(
-      quiche::QuicheStringPiece certificate);
+      absl::string_view certificate);
 
   // Loads all PEM-encoded X.509 certificates found in the |input| stream
   // without parsing them.  Returns an empty vector if any parsing error occurs.
@@ -53,8 +53,7 @@
   QuicWallTime validity_end() const { return validity_end_; }
   const EVP_PKEY* public_key() const { return public_key_.get(); }
 
-  const std::vector<quiche::QuicheStringPiece>& subject_alt_name_domains()
-      const {
+  const std::vector<absl::string_view>& subject_alt_name_domains() const {
     return subject_alt_name_domains_;
   }
   const std::vector<QuicIpAddress>& subject_alt_name_ips() const {
@@ -62,8 +61,8 @@
   }
 
   // |signature_algorithm| is a TLS signature algorithm ID.
-  bool VerifySignature(quiche::QuicheStringPiece data,
-                       quiche::QuicheStringPiece signature,
+  bool VerifySignature(absl::string_view data,
+                       absl::string_view signature,
                        uint16_t signature_algorithm) const;
 
  private:
@@ -76,7 +75,7 @@
   bssl::UniquePtr<EVP_PKEY> public_key_;
 
   // SubjectAltName, https://tools.ietf.org/html/rfc5280#section-4.2.1.6
-  std::vector<quiche::QuicheStringPiece> subject_alt_name_domains_;
+  std::vector<absl::string_view> subject_alt_name_domains_;
   std::vector<QuicIpAddress> subject_alt_name_ips_;
 
   // Called from ParseSingleCertificate().
@@ -93,7 +92,7 @@
 
   // Loads a DER-encoded PrivateKeyInfo structure (RFC 5958) as a private key.
   static std::unique_ptr<CertificatePrivateKey> LoadFromDer(
-      quiche::QuicheStringPiece private_key);
+      absl::string_view private_key);
 
   // Loads a private key from a PEM file formatted according to RFC 7468.  Also
   // supports legacy OpenSSL RSA key format ("BEGIN RSA PRIVATE KEY").
@@ -101,8 +100,7 @@
       std::istream* input);
 
   // |signature_algorithm| is a TLS signature algorithm ID.
-  std::string Sign(quiche::QuicheStringPiece input,
-                   uint16_t signature_algorithm);
+  std::string Sign(absl::string_view input, uint16_t signature_algorithm);
 
   // Verifies that the private key in question matches the public key of the
   // certificate |view|.
@@ -124,7 +122,7 @@
 // testing.
 QUIC_EXPORT_PRIVATE quiche::QuicheOptional<quic::QuicWallTime> ParseDerTime(
     unsigned tag,
-    quiche::QuicheStringPiece payload);
+    absl::string_view payload);
 
 }  // namespace quic
 
diff --git a/quic/core/crypto/certificate_view_test.cc b/quic/core/crypto/certificate_view_test.cc
index e7ce0ce..c205360 100644
--- a/quic/core/crypto/certificate_view_test.cc
+++ b/quic/core/crypto/certificate_view_test.cc
@@ -7,6 +7,7 @@
 #include <memory>
 #include <sstream>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/base.h"
 #include "third_party/boringssl/src/include/openssl/bytestring.h"
 #include "third_party/boringssl/src/include/openssl/evp.h"
@@ -15,7 +16,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_ip_address.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/test_certificates.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_time_utils.h"
 
 namespace quic {
@@ -43,9 +43,9 @@
   ASSERT_TRUE(view != nullptr);
 
   EXPECT_THAT(view->subject_alt_name_domains(),
-              ElementsAre(quiche::QuicheStringPiece("www.example.org"),
-                          quiche::QuicheStringPiece("mail.example.org"),
-                          quiche::QuicheStringPiece("mail.example.com")));
+              ElementsAre(absl::string_view("www.example.org"),
+                          absl::string_view("mail.example.org"),
+                          absl::string_view("mail.example.com")));
   EXPECT_THAT(view->subject_alt_name_ips(),
               ElementsAre(QuicIpAddress::Loopback4()));
   EXPECT_EQ(EVP_PKEY_id(view->public_key()), EVP_PKEY_RSA);
diff --git a/quic/core/crypto/chacha20_poly1305_decrypter_test.cc b/quic/core/crypto/chacha20_poly1305_decrypter_test.cc
index 83e52b1..ab1baad 100644
--- a/quic/core/crypto/chacha20_poly1305_decrypter_test.cc
+++ b/quic/core/crypto/chacha20_poly1305_decrypter_test.cc
@@ -7,10 +7,10 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.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/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"
 #include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h"
 
@@ -115,12 +115,12 @@
 // DecryptWithNonce wraps the |Decrypt| method of |decrypter| to allow passing
 // in an nonce and also to allocate the buffer needed for the plaintext.
 QuicData* DecryptWithNonce(ChaCha20Poly1305Decrypter* decrypter,
-                           quiche::QuicheStringPiece nonce,
-                           quiche::QuicheStringPiece associated_data,
-                           quiche::QuicheStringPiece ciphertext) {
+                           absl::string_view nonce,
+                           absl::string_view associated_data,
+                           absl::string_view ciphertext) {
   uint64_t packet_number;
-  quiche::QuicheStringPiece nonce_prefix(nonce.data(),
-                                         nonce.size() - sizeof(packet_number));
+  absl::string_view nonce_prefix(nonce.data(),
+                                 nonce.size() - sizeof(packet_number));
   decrypter->SetNoncePrefix(nonce_prefix);
   memcpy(&packet_number, nonce.data() + nonce_prefix.size(),
          sizeof(packet_number));
@@ -160,8 +160,7 @@
         &decrypter, fixed + iv,
         // This deliberately tests that the decrypter can handle an AAD that
         // is set to nullptr, as opposed to a zero-length, non-nullptr pointer.
-        quiche::QuicheStringPiece(aad.length() ? aad.data() : nullptr,
-                                  aad.length()),
+        absl::string_view(aad.length() ? aad.data() : nullptr, aad.length()),
         ct));
     if (!decrypted) {
       EXPECT_FALSE(has_pt);
diff --git a/quic/core/crypto/chacha20_poly1305_encrypter_test.cc b/quic/core/crypto/chacha20_poly1305_encrypter_test.cc
index 47ee3d0..3672f75 100644
--- a/quic/core/crypto/chacha20_poly1305_encrypter_test.cc
+++ b/quic/core/crypto/chacha20_poly1305_encrypter_test.cc
@@ -7,12 +7,12 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/chacha20_poly1305_decrypter.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/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"
 #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"
 
@@ -72,9 +72,9 @@
 // EncryptWithNonce wraps the |Encrypt| method of |encrypter| to allow passing
 // in an nonce and also to allocate the buffer needed for the ciphertext.
 QuicData* EncryptWithNonce(ChaCha20Poly1305Encrypter* encrypter,
-                           quiche::QuicheStringPiece nonce,
-                           quiche::QuicheStringPiece associated_data,
-                           quiche::QuicheStringPiece plaintext) {
+                           absl::string_view nonce,
+                           absl::string_view associated_data,
+                           absl::string_view plaintext) {
   size_t ciphertext_size = encrypter->GetCiphertextSize(plaintext.length());
   std::unique_ptr<char[]> ciphertext(new char[ciphertext_size]);
 
@@ -106,7 +106,7 @@
   ASSERT_TRUE(encrypter.EncryptPacket(packet_number, associated_data, plaintext,
                                       encrypted, &len,
                                       QUICHE_ARRAYSIZE(encrypted)));
-  quiche::QuicheStringPiece ciphertext(encrypted, len);
+  absl::string_view ciphertext(encrypted, len);
   char decrypted[1024];
   ASSERT_TRUE(decrypter.DecryptPacket(packet_number, associated_data,
                                       ciphertext, decrypted, &len,
@@ -130,8 +130,7 @@
         &encrypter, fixed + iv,
         // This deliberately tests that the encrypter can handle an AAD that
         // is set to nullptr, as opposed to a zero-length, non-nullptr pointer.
-        quiche::QuicheStringPiece(aad.length() ? aad.data() : nullptr,
-                                  aad.length()),
+        absl::string_view(aad.length() ? aad.data() : nullptr, aad.length()),
         pt));
     ASSERT_TRUE(encrypted.get());
     EXPECT_EQ(12u, ct.size() - pt.size());
diff --git a/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc b/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc
index 9127cd4..2c7aba1 100644
--- a/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc
+++ b/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc
@@ -7,10 +7,10 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.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/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"
 #include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h"
 
@@ -115,9 +115,9 @@
 // DecryptWithNonce wraps the |Decrypt| method of |decrypter| to allow passing
 // in an nonce and also to allocate the buffer needed for the plaintext.
 QuicData* DecryptWithNonce(ChaCha20Poly1305TlsDecrypter* decrypter,
-                           quiche::QuicheStringPiece nonce,
-                           quiche::QuicheStringPiece associated_data,
-                           quiche::QuicheStringPiece ciphertext) {
+                           absl::string_view nonce,
+                           absl::string_view associated_data,
+                           absl::string_view ciphertext) {
   decrypter->SetIV(nonce);
   std::unique_ptr<char[]> output(new char[ciphertext.length()]);
   size_t output_length = 0;
@@ -155,8 +155,7 @@
         &decrypter, fixed + iv,
         // This deliberately tests that the decrypter can handle an AAD that
         // is set to nullptr, as opposed to a zero-length, non-nullptr pointer.
-        quiche::QuicheStringPiece(aad.length() ? aad.data() : nullptr,
-                                  aad.length()),
+        absl::string_view(aad.length() ? aad.data() : nullptr, aad.length()),
         ct));
     if (!decrypted) {
       EXPECT_FALSE(has_pt);
diff --git a/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc b/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc
index dd642a3..9191768 100644
--- a/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc
+++ b/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc
@@ -7,12 +7,12 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/chacha20_poly1305_tls_decrypter.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/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"
 #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"
 
@@ -72,9 +72,9 @@
 // EncryptWithNonce wraps the |Encrypt| method of |encrypter| to allow passing
 // in an nonce and also to allocate the buffer needed for the ciphertext.
 QuicData* EncryptWithNonce(ChaCha20Poly1305TlsEncrypter* encrypter,
-                           quiche::QuicheStringPiece nonce,
-                           quiche::QuicheStringPiece associated_data,
-                           quiche::QuicheStringPiece plaintext) {
+                           absl::string_view nonce,
+                           absl::string_view associated_data,
+                           absl::string_view plaintext) {
   size_t ciphertext_size = encrypter->GetCiphertextSize(plaintext.length());
   std::unique_ptr<char[]> ciphertext(new char[ciphertext_size]);
 
@@ -106,7 +106,7 @@
   ASSERT_TRUE(encrypter.EncryptPacket(packet_number, associated_data, plaintext,
                                       encrypted, &len,
                                       QUICHE_ARRAYSIZE(encrypted)));
-  quiche::QuicheStringPiece ciphertext(encrypted, len);
+  absl::string_view ciphertext(encrypted, len);
   char decrypted[1024];
   ASSERT_TRUE(decrypter.DecryptPacket(packet_number, associated_data,
                                       ciphertext, decrypted, &len,
@@ -130,8 +130,7 @@
         &encrypter, fixed + iv,
         // This deliberately tests that the encrypter can handle an AAD that
         // is set to nullptr, as opposed to a zero-length, non-nullptr pointer.
-        quiche::QuicheStringPiece(aad.length() ? aad.data() : nullptr,
-                                  aad.length()),
+        absl::string_view(aad.length() ? aad.data() : nullptr, aad.length()),
         pt));
     ASSERT_TRUE(encrypted.get());
     EXPECT_EQ(16u, ct.size() - pt.size());
diff --git a/quic/core/crypto/chacha_base_decrypter.cc b/quic/core/crypto/chacha_base_decrypter.cc
index bc09b66..d857e5a 100644
--- a/quic/core/crypto/chacha_base_decrypter.cc
+++ b/quic/core/crypto/chacha_base_decrypter.cc
@@ -6,17 +6,16 @@
 
 #include <cstdint>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/chacha.h"
 #include "net/third_party/quiche/src/quic/core/quic_data_reader.h"
 #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_endian.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
-bool ChaChaBaseDecrypter::SetHeaderProtectionKey(
-    quiche::QuicheStringPiece key) {
+bool ChaChaBaseDecrypter::SetHeaderProtectionKey(absl::string_view key) {
   if (key.size() != GetKeySize()) {
     QUIC_BUG << "Invalid key size for header protection";
     return false;
@@ -27,7 +26,7 @@
 
 std::string ChaChaBaseDecrypter::GenerateHeaderProtectionMask(
     QuicDataReader* sample_reader) {
-  quiche::QuicheStringPiece sample;
+  absl::string_view sample;
   if (!sample_reader->ReadStringPiece(&sample, 16)) {
     return std::string();
   }
diff --git a/quic/core/crypto/chacha_base_decrypter.h b/quic/core/crypto/chacha_base_decrypter.h
index 24ca820..610bc59 100644
--- a/quic/core/crypto/chacha_base_decrypter.h
+++ b/quic/core/crypto/chacha_base_decrypter.h
@@ -7,9 +7,9 @@
 
 #include <cstddef>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/aead_base_decrypter.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 {
 
@@ -17,7 +17,7 @@
  public:
   using AeadBaseDecrypter::AeadBaseDecrypter;
 
-  bool SetHeaderProtectionKey(quiche::QuicheStringPiece key) override;
+  bool SetHeaderProtectionKey(absl::string_view key) override;
   std::string GenerateHeaderProtectionMask(
       QuicDataReader* sample_reader) override;
 
diff --git a/quic/core/crypto/chacha_base_encrypter.cc b/quic/core/crypto/chacha_base_encrypter.cc
index 7fdc019..7d84358 100644
--- a/quic/core/crypto/chacha_base_encrypter.cc
+++ b/quic/core/crypto/chacha_base_encrypter.cc
@@ -4,17 +4,16 @@
 
 #include "net/third_party/quiche/src/quic/core/crypto/chacha_base_encrypter.h"
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/chacha.h"
 #include "net/third_party/quiche/src/quic/core/quic_data_reader.h"
 #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_endian.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
-bool ChaChaBaseEncrypter::SetHeaderProtectionKey(
-    quiche::QuicheStringPiece key) {
+bool ChaChaBaseEncrypter::SetHeaderProtectionKey(absl::string_view key) {
   if (key.size() != GetKeySize()) {
     QUIC_BUG << "Invalid key size for header protection";
     return false;
@@ -24,7 +23,7 @@
 }
 
 std::string ChaChaBaseEncrypter::GenerateHeaderProtectionMask(
-    quiche::QuicheStringPiece sample) {
+    absl::string_view sample) {
   if (sample.size() != 16) {
     return std::string();
   }
diff --git a/quic/core/crypto/chacha_base_encrypter.h b/quic/core/crypto/chacha_base_encrypter.h
index 16d1df1..97385c3 100644
--- a/quic/core/crypto/chacha_base_encrypter.h
+++ b/quic/core/crypto/chacha_base_encrypter.h
@@ -7,9 +7,9 @@
 
 #include <cstddef>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/aead_base_encrypter.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 {
 
@@ -17,9 +17,8 @@
  public:
   using AeadBaseEncrypter::AeadBaseEncrypter;
 
-  bool SetHeaderProtectionKey(quiche::QuicheStringPiece key) override;
-  std::string GenerateHeaderProtectionMask(
-      quiche::QuicheStringPiece sample) override;
+  bool SetHeaderProtectionKey(absl::string_view key) override;
+  std::string GenerateHeaderProtectionMask(absl::string_view sample) override;
 
  private:
   // The key used for packet number encryption.
diff --git a/quic/core/crypto/channel_id.cc b/quic/core/crypto/channel_id.cc
index facd552..2d30147 100644
--- a/quic/core/crypto/channel_id.cc
+++ b/quic/core/crypto/channel_id.cc
@@ -6,12 +6,12 @@
 
 #include <cstdint>
 
+#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"
 #include "third_party/boringssl/src/include/openssl/nid.h"
 #include "third_party/boringssl/src/include/openssl/sha.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -21,16 +21,16 @@
 const char ChannelIDVerifier::kClientToServerStr[] = "client -> server";
 
 // static
-bool ChannelIDVerifier::Verify(quiche::QuicheStringPiece key,
-                               quiche::QuicheStringPiece signed_data,
-                               quiche::QuicheStringPiece signature) {
+bool ChannelIDVerifier::Verify(absl::string_view key,
+                               absl::string_view signed_data,
+                               absl::string_view signature) {
   return VerifyRaw(key, signed_data, signature, true);
 }
 
 // static
-bool ChannelIDVerifier::VerifyRaw(quiche::QuicheStringPiece key,
-                                  quiche::QuicheStringPiece signed_data,
-                                  quiche::QuicheStringPiece signature,
+bool ChannelIDVerifier::VerifyRaw(absl::string_view key,
+                                  absl::string_view signed_data,
+                                  absl::string_view signature,
                                   bool is_channel_id_signature) {
   if (key.size() != 32 * 2 || signature.size() != 32 * 2) {
     return false;
diff --git a/quic/core/crypto/channel_id.h b/quic/core/crypto/channel_id.h
index c04aac3..e176cdb 100644
--- a/quic/core/crypto/channel_id.h
+++ b/quic/core/crypto/channel_id.h
@@ -8,9 +8,9 @@
 #include <memory>
 #include <string>
 
+#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_string_piece.h"
 
 namespace quic {
 
@@ -30,17 +30,17 @@
 
   // Verify returns true iff |signature| is a valid signature of |signed_data|
   // by |key|.
-  static bool Verify(quiche::QuicheStringPiece key,
-                     quiche::QuicheStringPiece signed_data,
-                     quiche::QuicheStringPiece signature);
+  static bool Verify(absl::string_view key,
+                     absl::string_view signed_data,
+                     absl::string_view signature);
 
   // FOR TESTING ONLY: VerifyRaw returns true iff |signature| is a valid
   // signature of |signed_data| by |key|. |is_channel_id_signature| indicates
   // whether |signature| is a ChannelID signature (with kContextStr prepended
   // to the data to be signed).
-  static bool VerifyRaw(quiche::QuicheStringPiece key,
-                        quiche::QuicheStringPiece signed_data,
-                        quiche::QuicheStringPiece signature,
+  static bool VerifyRaw(absl::string_view key,
+                        absl::string_view signed_data,
+                        absl::string_view signature,
                         bool is_channel_id_signature);
 };
 
diff --git a/quic/core/crypto/channel_id_test.cc b/quic/core/crypto/channel_id_test.cc
index d4a14cd..cd95539 100644
--- a/quic/core/crypto/channel_id_test.cc
+++ b/quic/core/crypto/channel_id_test.cc
@@ -7,9 +7,9 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.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 {
@@ -275,12 +275,11 @@
     EXPECT_EQ(sizeof(signature) / 2, r_len);
     EXPECT_EQ(sizeof(signature) / 2, s_len);
 
-    EXPECT_EQ(
-        test_vector[i].result,
-        ChannelIDVerifier::VerifyRaw(
-            quiche::QuicheStringPiece(key, sizeof(key)),
-            quiche::QuicheStringPiece(msg, msg_len),
-            quiche::QuicheStringPiece(signature, sizeof(signature)), false));
+    EXPECT_EQ(test_vector[i].result,
+              ChannelIDVerifier::VerifyRaw(
+                  absl::string_view(key, sizeof(key)),
+                  absl::string_view(msg, msg_len),
+                  absl::string_view(signature, sizeof(signature)), false));
   }
 }
 
diff --git a/quic/core/crypto/common_cert_set.cc b/quic/core/crypto/common_cert_set.cc
index 0ccbf2d..7894037 100644
--- a/quic/core/crypto/common_cert_set.cc
+++ b/quic/core/crypto/common_cert_set.cc
@@ -6,9 +6,9 @@
 
 #include <cstddef>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_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 {
 
@@ -56,7 +56,7 @@
 
 // Compare returns a value less than, equal to or greater than zero if |a| is
 // lexicographically less than, equal to or greater than |b|, respectively.
-int Compare(quiche::QuicheStringPiece a, const unsigned char* b, size_t b_len) {
+int Compare(absl::string_view a, const unsigned char* b, size_t b_len) {
   size_t len = a.size();
   if (len > b_len) {
     len = b_len;
@@ -79,18 +79,16 @@
 class CommonCertSetsQUIC : public CommonCertSets {
  public:
   // CommonCertSets interface.
-  quiche::QuicheStringPiece GetCommonHashes() const override {
-    return quiche::QuicheStringPiece(
-        reinterpret_cast<const char*>(kSetHashes),
-        sizeof(uint64_t) * QUICHE_ARRAYSIZE(kSetHashes));
+  absl::string_view GetCommonHashes() const override {
+    return absl::string_view(reinterpret_cast<const char*>(kSetHashes),
+                             sizeof(uint64_t) * QUICHE_ARRAYSIZE(kSetHashes));
   }
 
-  quiche::QuicheStringPiece GetCert(uint64_t hash,
-                                    uint32_t index) const override {
+  absl::string_view GetCert(uint64_t hash, uint32_t index) const override {
     for (size_t i = 0; i < QUICHE_ARRAYSIZE(kSets); i++) {
       if (kSets[i].hash == hash) {
         if (index < kSets[i].num_certs) {
-          return quiche::QuicheStringPiece(
+          return absl::string_view(
               reinterpret_cast<const char*>(kSets[i].certs[index]),
               kSets[i].lens[index]);
         }
@@ -98,11 +96,11 @@
       }
     }
 
-    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 (common_set_hashes.size() % sizeof(uint64_t) != 0) {
diff --git a/quic/core/crypto/common_cert_set.h b/quic/core/crypto/common_cert_set.h
index af211ad..ae83e1d 100644
--- a/quic/core/crypto/common_cert_set.h
+++ b/quic/core/crypto/common_cert_set.h
@@ -7,9 +7,9 @@
 
 #include <cstdint>
 
+#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/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -22,23 +22,22 @@
   // GetInstanceQUIC returns the standard QUIC common certificate sets.
   static const CommonCertSets* GetInstanceQUIC();
 
-  // GetCommonHashes returns a quiche::QuicheStringPiece containing the hashes
+  // GetCommonHashes returns a absl::string_view containing the hashes
   // of common sets supported by this object. The 64-bit hashes are concatenated
-  // in the quiche::QuicheStringPiece.
-  virtual quiche::QuicheStringPiece GetCommonHashes() const = 0;
+  // in the absl::string_view.
+  virtual absl::string_view GetCommonHashes() const = 0;
 
   // GetCert returns a specific certificate (at index |index|) in the common
   // set identified by |hash|. If no such certificate is known, an empty
-  // quiche::QuicheStringPiece is returned.
-  virtual quiche::QuicheStringPiece GetCert(uint64_t hash,
-                                            uint32_t index) const = 0;
+  // absl::string_view is returned.
+  virtual absl::string_view GetCert(uint64_t hash, uint32_t index) const = 0;
 
   // MatchCert tries to find |cert| in one of the common certificate sets
   // identified by |common_set_hashes|. On success it puts the hash of the
   // set in |out_hash|, the index of |cert| in the set in |out_index| and
   // returns true. Otherwise it returns false.
-  virtual bool MatchCert(quiche::QuicheStringPiece cert,
-                         quiche::QuicheStringPiece common_set_hashes,
+  virtual bool MatchCert(absl::string_view cert,
+                         absl::string_view common_set_hashes,
                          uint64_t* out_hash,
                          uint32_t* out_index) const = 0;
 };
diff --git a/quic/core/crypto/common_cert_set_empty.cc b/quic/core/crypto/common_cert_set_empty.cc
index 537bab9..603624d 100644
--- a/quic/core/crypto/common_cert_set_empty.cc
+++ b/quic/core/crypto/common_cert_set_empty.cc
@@ -6,9 +6,9 @@
 
 #include <cstddef>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_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 {
 
@@ -17,17 +17,17 @@
 class CommonCertSetsEmpty : public CommonCertSets {
  public:
   // CommonCertSets interface.
-  quiche::QuicheStringPiece GetCommonHashes() const override {
-    return quiche::QuicheStringPiece();
+  absl::string_view GetCommonHashes() const override {
+    return absl::string_view();
   }
 
-  quiche::QuicheStringPiece GetCert(uint64_t /* hash */,
-                                    uint32_t /* index */) const override {
-    return quiche::QuicheStringPiece();
+  absl::string_view GetCert(uint64_t /* hash */,
+                            uint32_t /* index */) const override {
+    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 {
     return false;
diff --git a/quic/core/crypto/common_cert_set_test.cc b/quic/core/crypto/common_cert_set_test.cc
index 148914d..01996c3 100644
--- a/quic/core/crypto/common_cert_set_test.cc
+++ b/quic/core/crypto/common_cert_set_test.cc
@@ -6,8 +6,8 @@
 
 #include <cstdint>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -193,44 +193,44 @@
 class CommonCertSetsTest : public QuicTest {};
 
 TEST_F(CommonCertSetsTest, FindGIA_2) {
-  quiche::QuicheStringPiece gia(reinterpret_cast<const char*>(kGIACertificate2),
-                                sizeof(kGIACertificate2));
+  absl::string_view gia(reinterpret_cast<const char*>(kGIACertificate2),
+                        sizeof(kGIACertificate2));
 
   const CommonCertSets* sets(CommonCertSets::GetInstanceQUIC());
   // Common Cert Set 2's hash.
   const uint64_t in_hash = UINT64_C(0xe81a92926081e801);
   uint64_t hash;
   uint32_t index;
-  ASSERT_TRUE(sets->MatchCert(
-      gia,
-      quiche::QuicheStringPiece(reinterpret_cast<const char*>(&in_hash),
-                                sizeof(in_hash)),
-      &hash, &index));
+  ASSERT_TRUE(
+      sets->MatchCert(gia,
+                      absl::string_view(reinterpret_cast<const char*>(&in_hash),
+                                        sizeof(in_hash)),
+                      &hash, &index));
   EXPECT_EQ(in_hash, hash);
 
-  quiche::QuicheStringPiece gia_copy = sets->GetCert(hash, index);
+  absl::string_view gia_copy = sets->GetCert(hash, index);
   EXPECT_FALSE(gia_copy.empty());
   ASSERT_EQ(gia.size(), gia_copy.size());
   EXPECT_EQ(0, memcmp(gia.data(), gia_copy.data(), gia.size()));
 }
 
 TEST_F(CommonCertSetsTest, FindGIA_3) {
-  quiche::QuicheStringPiece gia(reinterpret_cast<const char*>(kGIACertificate3),
-                                sizeof(kGIACertificate3));
+  absl::string_view gia(reinterpret_cast<const char*>(kGIACertificate3),
+                        sizeof(kGIACertificate3));
 
   const CommonCertSets* sets(CommonCertSets::GetInstanceQUIC());
   // Common Cert Set 3's hash.
   const uint64_t in_hash = UINT64_C(0x918215a28680ed7e);
   uint64_t hash;
   uint32_t index;
-  ASSERT_TRUE(sets->MatchCert(
-      gia,
-      quiche::QuicheStringPiece(reinterpret_cast<const char*>(&in_hash),
-                                sizeof(in_hash)),
-      &hash, &index));
+  ASSERT_TRUE(
+      sets->MatchCert(gia,
+                      absl::string_view(reinterpret_cast<const char*>(&in_hash),
+                                        sizeof(in_hash)),
+                      &hash, &index));
   EXPECT_EQ(in_hash, hash);
 
-  quiche::QuicheStringPiece gia_copy = sets->GetCert(hash, index);
+  absl::string_view gia_copy = sets->GetCert(hash, index);
   EXPECT_FALSE(gia_copy.empty());
   ASSERT_EQ(gia.size(), gia_copy.size());
   EXPECT_EQ(0, memcmp(gia.data(), gia_copy.data(), gia.size()));
@@ -238,15 +238,15 @@
 
 TEST_F(CommonCertSetsTest, NonMatch) {
   const CommonCertSets* sets(CommonCertSets::GetInstanceQUIC());
-  quiche::QuicheStringPiece not_a_cert("hello");
+  absl::string_view not_a_cert("hello");
   const uint64_t in_hash = UINT64_C(0xc9fef74053f99f39);
   uint64_t hash;
   uint32_t index;
-  EXPECT_FALSE(sets->MatchCert(
-      not_a_cert,
-      quiche::QuicheStringPiece(reinterpret_cast<const char*>(&in_hash),
-                                sizeof(in_hash)),
-      &hash, &index));
+  EXPECT_FALSE(
+      sets->MatchCert(not_a_cert,
+                      absl::string_view(reinterpret_cast<const char*>(&in_hash),
+                                        sizeof(in_hash)),
+                      &hash, &index));
 }
 
 }  // namespace test
diff --git a/quic/core/crypto/crypto_framer.cc b/quic/core/crypto/crypto_framer.cc
index 6a18884..adfa248 100644
--- a/quic/core/crypto/crypto_framer.cc
+++ b/quic/core/crypto/crypto_framer.cc
@@ -7,6 +7,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/quic_data_reader.h"
 #include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
@@ -15,7 +16,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.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 {
 
@@ -60,7 +60,7 @@
 
 // static
 std::unique_ptr<CryptoHandshakeMessage> CryptoFramer::ParseMessage(
-    quiche::QuicheStringPiece in) {
+    absl::string_view in) {
   OneShotVisitor visitor;
   CryptoFramer framer;
 
@@ -81,12 +81,12 @@
   return error_detail_;
 }
 
-bool CryptoFramer::ProcessInput(quiche::QuicheStringPiece input,
+bool CryptoFramer::ProcessInput(absl::string_view input,
                                 EncryptionLevel /*level*/) {
   return ProcessInput(input);
 }
 
-bool CryptoFramer::ProcessInput(quiche::QuicheStringPiece input) {
+bool CryptoFramer::ProcessInput(absl::string_view input) {
   DCHECK_EQ(QUIC_NO_ERROR, error_);
   if (error_ != QUIC_NO_ERROR) {
     return false;
@@ -121,7 +121,7 @@
   QuicDataReader reader(buffer_.data(), buffer_.length(),
                         quiche::HOST_BYTE_ORDER);
   for (const std::pair<QuicTag, size_t>& item : tags_and_lengths_) {
-    quiche::QuicheStringPiece value;
+    absl::string_view value;
     if (reader.BytesRemaining() < item.second) {
       break;
     }
@@ -243,7 +243,7 @@
   state_ = STATE_READING_TAG;
 }
 
-QuicErrorCode CryptoFramer::Process(quiche::QuicheStringPiece input) {
+QuicErrorCode CryptoFramer::Process(absl::string_view input) {
   // Add this data to the buffer.
   buffer_.append(input.data(), input.length());
   QuicDataReader reader(buffer_.data(), buffer_.length(),
@@ -319,7 +319,7 @@
                         << values_len_ - reader.BytesRemaining() << " bytes.";
       }
       for (const std::pair<QuicTag, size_t>& item : tags_and_lengths_) {
-        quiche::QuicheStringPiece value;
+        absl::string_view value;
         if (!reader.ReadStringPiece(&value, item.second)) {
           DCHECK(process_truncated_messages_);
           // Store an empty value.
diff --git a/quic/core/crypto/crypto_framer.h b/quic/core/crypto/crypto_framer.h
index 8dc0d96..e7289eb 100644
--- a/quic/core/crypto/crypto_framer.h
+++ b/quic/core/crypto/crypto_framer.h
@@ -12,10 +12,10 @@
 #include <utility>
 #include <vector>
 
+#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_message_parser.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 {
 
@@ -43,10 +43,10 @@
   ~CryptoFramer() override;
 
   // ParseMessage parses exactly one message from the given
-  // quiche::QuicheStringPiece. If there is an error, the message is truncated,
+  // absl::string_view. If there is an error, the message is truncated,
   // or the message has trailing garbage then nullptr will be returned.
   static std::unique_ptr<CryptoHandshakeMessage> ParseMessage(
-      quiche::QuicheStringPiece in);
+      absl::string_view in);
 
   // Set callbacks to be called from the framer.  A visitor must be set, or
   // else the framer will crash.  It is acceptable for the visitor to do
@@ -63,9 +63,8 @@
   // false if there was an error, and true otherwise. ProcessInput optionally
   // takes an EncryptionLevel, but it is ignored. The variant with the
   // EncryptionLevel is provided to match the CryptoMessageParser interface.
-  bool ProcessInput(quiche::QuicheStringPiece input,
-                    EncryptionLevel level) override;
-  bool ProcessInput(quiche::QuicheStringPiece input);
+  bool ProcessInput(absl::string_view input, EncryptionLevel level) override;
+  bool ProcessInput(absl::string_view input);
 
   // Returns the number of bytes of buffered input data remaining to be
   // parsed.
@@ -96,7 +95,7 @@
 
   // Process does does the work of |ProcessInput|, but returns an error code,
   // doesn't set error_ and doesn't call |visitor_->OnError()|.
-  QuicErrorCode Process(quiche::QuicheStringPiece input);
+  QuicErrorCode Process(absl::string_view input);
 
   static bool WritePadTag(QuicDataWriter* writer,
                           size_t pad_length,
diff --git a/quic/core/crypto/crypto_framer_test.cc b/quic/core/crypto/crypto_framer_test.cc
index d598c49..c1f558f 100644
--- a/quic/core/crypto/crypto_framer_test.cc
+++ b/quic/core/crypto/crypto_framer_test.cc
@@ -8,6 +8,7 @@
 #include <memory>
 #include <vector>
 
+#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_protocol.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
@@ -16,7 +17,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.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"
 #include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h"
 
 namespace quic {
@@ -264,7 +264,7 @@
   };
 
   EXPECT_TRUE(framer.ProcessInput(
-      quiche::QuicheStringPiece(AsChars(input), QUICHE_ARRAYSIZE(input))));
+      absl::string_view(AsChars(input), QUICHE_ARRAYSIZE(input))));
   EXPECT_EQ(0u, framer.InputBytesRemaining());
   EXPECT_EQ(0, visitor.error_count_);
   ASSERT_EQ(1u, visitor.messages_.size());
@@ -308,7 +308,7 @@
   };
 
   EXPECT_TRUE(framer.ProcessInput(
-      quiche::QuicheStringPiece(AsChars(input), QUICHE_ARRAYSIZE(input))));
+      absl::string_view(AsChars(input), QUICHE_ARRAYSIZE(input))));
   EXPECT_EQ(0u, framer.InputBytesRemaining());
   EXPECT_EQ(0, visitor.error_count_);
   ASSERT_EQ(1u, visitor.messages_.size());
@@ -347,8 +347,7 @@
   };
 
   for (size_t i = 0; i < QUICHE_ARRAYSIZE(input); i++) {
-    EXPECT_TRUE(
-        framer.ProcessInput(quiche::QuicheStringPiece(AsChars(input) + i, 1)));
+    EXPECT_TRUE(framer.ProcessInput(absl::string_view(AsChars(input) + i, 1)));
   }
   EXPECT_EQ(0u, framer.InputBytesRemaining());
   ASSERT_EQ(1u, visitor.messages_.size());
@@ -382,7 +381,7 @@
   };
 
   EXPECT_FALSE(framer.ProcessInput(
-      quiche::QuicheStringPiece(AsChars(input), QUICHE_ARRAYSIZE(input))));
+      absl::string_view(AsChars(input), QUICHE_ARRAYSIZE(input))));
   EXPECT_THAT(framer.error(), IsError(QUIC_CRYPTO_TAGS_OUT_OF_ORDER));
   EXPECT_EQ(1, visitor.error_count_);
 }
@@ -410,7 +409,7 @@
   };
 
   EXPECT_FALSE(framer.ProcessInput(
-      quiche::QuicheStringPiece(AsChars(input), QUICHE_ARRAYSIZE(input))));
+      absl::string_view(AsChars(input), QUICHE_ARRAYSIZE(input))));
   EXPECT_THAT(framer.error(), IsError(QUIC_CRYPTO_TAGS_OUT_OF_ORDER));
   EXPECT_EQ(1, visitor.error_count_);
 }
@@ -430,7 +429,7 @@
   };
 
   EXPECT_FALSE(framer.ProcessInput(
-      quiche::QuicheStringPiece(AsChars(input), QUICHE_ARRAYSIZE(input))));
+      absl::string_view(AsChars(input), QUICHE_ARRAYSIZE(input))));
   EXPECT_THAT(framer.error(), IsError(QUIC_CRYPTO_TOO_MANY_ENTRIES));
   EXPECT_EQ(1, visitor.error_count_);
 }
@@ -458,7 +457,7 @@
   };
 
   EXPECT_TRUE(framer.ProcessInput(
-      quiche::QuicheStringPiece(AsChars(input), QUICHE_ARRAYSIZE(input))));
+      absl::string_view(AsChars(input), QUICHE_ARRAYSIZE(input))));
   EXPECT_EQ(0, visitor.error_count_);
 }
 
diff --git a/quic/core/crypto/crypto_handshake_message.cc b/quic/core/crypto/crypto_handshake_message.cc
index 3df9f12..db80a05 100644
--- a/quic/core/crypto/crypto_handshake_message.cc
+++ b/quic/core/crypto/crypto_handshake_message.cc
@@ -7,6 +7,7 @@
 #include <memory>
 #include <string>
 
+#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_protocol.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_utils.h"
@@ -15,7 +16,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 namespace quic {
@@ -97,7 +97,7 @@
 }
 
 void CryptoHandshakeMessage::SetStringPiece(QuicTag tag,
-                                            quiche::QuicheStringPiece value) {
+                                            absl::string_view value) {
   tag_value_map_[tag] = std::string(value);
 }
 
@@ -159,9 +159,8 @@
   return QUIC_NO_ERROR;
 }
 
-bool CryptoHandshakeMessage::GetStringPiece(
-    QuicTag tag,
-    quiche::QuicheStringPiece* out) const {
+bool CryptoHandshakeMessage::GetStringPiece(QuicTag tag,
+                                            absl::string_view* out) const {
   auto it = tag_value_map_.find(tag);
   if (it == tag_value_map_.end()) {
     return false;
@@ -177,8 +176,8 @@
 QuicErrorCode CryptoHandshakeMessage::GetNthValue24(
     QuicTag tag,
     unsigned index,
-    quiche::QuicheStringPiece* out) const {
-  quiche::QuicheStringPiece value;
+    absl::string_view* out) const {
+  absl::string_view value;
   if (!GetStringPiece(tag, &value)) {
     return QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND;
   }
@@ -203,7 +202,7 @@
     }
 
     if (i == index) {
-      *out = quiche::QuicheStringPiece(value.data(), size);
+      *out = absl::string_view(value.data(), size);
       return QUIC_NO_ERROR;
     }
 
diff --git a/quic/core/crypto/crypto_handshake_message.h b/quic/core/crypto/crypto_handshake_message.h
index 9539050..5c50127 100644
--- a/quic/core/crypto/crypto_handshake_message.h
+++ b/quic/core/crypto/crypto_handshake_message.h
@@ -11,10 +11,10 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.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 {
 
@@ -78,7 +78,7 @@
 
   const QuicTagValueMap& tag_value_map() const { return tag_value_map_; }
 
-  void SetStringPiece(QuicTag tag, quiche::QuicheStringPiece value);
+  void SetStringPiece(QuicTag tag, absl::string_view value);
 
   // Erase removes a tag/value, if present, from the message.
   void Erase(QuicTag tag);
@@ -99,7 +99,7 @@
   // Otherwise it populates |out| with the label and returns QUIC_NO_ERROR.
   QuicErrorCode GetVersionLabel(QuicTag tag, QuicVersionLabel* out) const;
 
-  bool GetStringPiece(QuicTag tag, quiche::QuicheStringPiece* out) const;
+  bool GetStringPiece(QuicTag tag, absl::string_view* out) const;
   bool HasStringPiece(QuicTag tag) const;
 
   // GetNthValue24 interprets the value with the given tag to be a series of
@@ -107,7 +107,7 @@
   // index.
   QuicErrorCode GetNthValue24(QuicTag tag,
                               unsigned index,
-                              quiche::QuicheStringPiece* out) const;
+                              absl::string_view* out) const;
   QuicErrorCode GetUint32(QuicTag tag, uint32_t* out) const;
   QuicErrorCode GetUint64(QuicTag tag, uint64_t* out) const;
   QuicErrorCode GetUint128(QuicTag tag, QuicUint128* out) const;
diff --git a/quic/core/crypto/crypto_message_parser.h b/quic/core/crypto/crypto_message_parser.h
index 8038664..b5e6a9d 100644
--- a/quic/core/crypto/crypto_message_parser.h
+++ b/quic/core/crypto/crypto_message_parser.h
@@ -7,9 +7,9 @@
 
 #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_types.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -23,8 +23,7 @@
   // Processes input data, which must be delivered in order. The input data
   // being processed was received at encryption level |level|. Returns
   // false if there was an error, and true otherwise.
-  virtual bool ProcessInput(quiche::QuicheStringPiece input,
-                            EncryptionLevel level) = 0;
+  virtual bool ProcessInput(absl::string_view input, EncryptionLevel level) = 0;
 
   // Returns the number of bytes of buffered input data remaining to be
   // parsed.
diff --git a/quic/core/crypto/crypto_secret_boxer.cc b/quic/core/crypto/crypto_secret_boxer.cc
index 78cf768..1f75e0c 100644
--- a/quic/core/crypto/crypto_secret_boxer.cc
+++ b/quic/core/crypto/crypto_secret_boxer.cc
@@ -7,11 +7,11 @@
 
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_secret_boxer.h"
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/aead.h"
 #include "third_party/boringssl/src/include/openssl/err.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -68,7 +68,7 @@
 }
 
 std::string CryptoSecretBoxer::Box(QuicRandom* rand,
-                                   quiche::QuicheStringPiece plaintext) const {
+                                   absl::string_view plaintext) const {
   // The box is formatted as:
   //   12 bytes of random nonce
   //   n bytes of ciphertext
@@ -104,9 +104,9 @@
   return ret;
 }
 
-bool CryptoSecretBoxer::Unbox(quiche::QuicheStringPiece in_ciphertext,
+bool CryptoSecretBoxer::Unbox(absl::string_view in_ciphertext,
                               std::string* out_storage,
-                              quiche::QuicheStringPiece* out) const {
+                              absl::string_view* out) const {
   if (in_ciphertext.size() < kSIVNonceSize) {
     return false;
   }
@@ -130,7 +130,7 @@
                             kSIVNonceSize, ciphertext, ciphertext_len, nullptr,
                             0)) {
         ok = true;
-        *out = quiche::QuicheStringPiece(out_storage->data(), bytes_written);
+        *out = absl::string_view(out_storage->data(), bytes_written);
         break;
       }
 
diff --git a/quic/core/crypto/crypto_secret_boxer.h b/quic/core/crypto/crypto_secret_boxer.h
index dc4e0b1..6cf61b4 100644
--- a/quic/core/crypto/crypto_secret_boxer.h
+++ b/quic/core/crypto/crypto_secret_boxer.h
@@ -10,9 +10,9 @@
 #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/quic/platform/api/quic_mutex.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -41,16 +41,16 @@
   // returns the resulting ciphertext. Since an authenticator and nonce are
   // included, the result will be slightly larger than |plaintext|. The first
   // key in the vector supplied to |SetKeys| will be used.
-  std::string Box(QuicRandom* rand, quiche::QuicheStringPiece plaintext) const;
+  std::string Box(QuicRandom* rand, absl::string_view plaintext) const;
 
   // Unbox takes the result of a previous call to |Box| in |ciphertext| and
   // authenticates+decrypts it. If |ciphertext| cannot be decrypted with any of
   // the supplied keys, the function returns false. Otherwise, |out_storage| is
   // used to store the result and |out| is set to point into |out_storage| and
   // contains the original plaintext.
-  bool Unbox(quiche::QuicheStringPiece ciphertext,
+  bool Unbox(absl::string_view ciphertext,
              std::string* out_storage,
-             quiche::QuicheStringPiece* out) const;
+             absl::string_view* out) const;
 
  private:
   struct State;
diff --git a/quic/core/crypto/crypto_secret_boxer_test.cc b/quic/core/crypto/crypto_secret_boxer_test.cc
index 57a5712..b63d081 100644
--- a/quic/core/crypto/crypto_secret_boxer_test.cc
+++ b/quic/core/crypto/crypto_secret_boxer_test.cc
@@ -6,9 +6,9 @@
 
 #include <string>
 
+#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/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -16,7 +16,7 @@
 class CryptoSecretBoxerTest : public QuicTest {};
 
 TEST_F(CryptoSecretBoxerTest, BoxAndUnbox) {
-  quiche::QuicheStringPiece message("hello world");
+  absl::string_view message("hello world");
 
   CryptoSecretBoxer boxer;
   boxer.SetKeys({std::string(CryptoSecretBoxer::GetKeySize(), 0x11)});
@@ -24,7 +24,7 @@
   const std::string box = boxer.Box(QuicRandom::GetInstance(), message);
 
   std::string storage;
-  quiche::QuicheStringPiece result;
+  absl::string_view result;
   EXPECT_TRUE(boxer.Unbox(box, &storage, &result));
   EXPECT_EQ(result, message);
 
@@ -40,10 +40,10 @@
 // Helper function to test whether one boxer can decode the output of another.
 static bool CanDecode(const CryptoSecretBoxer& decoder,
                       const CryptoSecretBoxer& encoder) {
-  quiche::QuicheStringPiece message("hello world");
+  absl::string_view message("hello world");
   const std::string boxed = encoder.Box(QuicRandom::GetInstance(), message);
   std::string storage;
-  quiche::QuicheStringPiece result;
+  absl::string_view result;
   bool ok = decoder.Unbox(boxed, &storage, &result);
   if (ok) {
     EXPECT_EQ(result, message);
diff --git a/quic/core/crypto/crypto_server_test.cc b/quic/core/crypto/crypto_server_test.cc
index 17ab10b..2236448 100644
--- a/quic/core/crypto/crypto_server_test.cc
+++ b/quic/core/crypto/crypto_server_test.cc
@@ -10,6 +10,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/sha.h"
 #include "net/third_party/quiche/src/quic/core/crypto/cert_compressor.h"
 #include "net/third_party/quiche/src/quic/core/crypto/common_cert_set.h"
@@ -31,7 +32,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_endian.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 {
@@ -127,7 +127,7 @@
     std::unique_ptr<CryptoHandshakeMessage> msg(
         config_.AddConfig(primary_config, clock_.WallNow()));
 
-    quiche::QuicheStringPiece orbit;
+    absl::string_view orbit;
     CHECK(msg->GetStringPiece(kORBT, &orbit));
     CHECK_EQ(sizeof(orbit_), orbit.size());
     memcpy(orbit_, orbit.data(), orbit.size());
@@ -156,15 +156,15 @@
         SERVER_CONFIG_INCHOATE_HELLO_FAILURE};
     CheckRejectReasons(kRejectReasons, QUICHE_ARRAYSIZE(kRejectReasons));
 
-    quiche::QuicheStringPiece srct;
+    absl::string_view srct;
     ASSERT_TRUE(out_.GetStringPiece(kSourceAddressTokenTag, &srct));
     srct_hex_ = "#" + quiche::QuicheTextUtils::HexEncode(srct);
 
-    quiche::QuicheStringPiece scfg;
+    absl::string_view scfg;
     ASSERT_TRUE(out_.GetStringPiece(kSCFG, &scfg));
     server_config_ = CryptoFramer::ParseMessage(scfg);
 
-    quiche::QuicheStringPiece scid;
+    absl::string_view scid;
     ASSERT_TRUE(server_config_->GetStringPiece(kSCID, &scid));
     scid_hex_ = "#" + quiche::QuicheTextUtils::HexEncode(scid);
 
@@ -211,7 +211,7 @@
       EXPECT_EQ(CreateQuicVersionLabel(supported_versions_[i]), versions[i]);
     }
 
-    quiche::QuicheStringPiece address;
+    absl::string_view address;
     ASSERT_TRUE(server_hello.GetStringPiece(kCADR, &address));
     QuicSocketAddressCoder decoder;
     ASSERT_TRUE(decoder.Decode(address.data(), address.size()));
@@ -313,8 +313,8 @@
     std::string nonce;
     CryptoUtils::GenerateNonce(
         clock_.WallNow(), rand_,
-        quiche::QuicheStringPiece(reinterpret_cast<const char*>(orbit_),
-                                  sizeof(orbit_)),
+        absl::string_view(reinterpret_cast<const char*>(orbit_),
+                          sizeof(orbit_)),
         &nonce);
     return nonce;
   }
@@ -413,7 +413,7 @@
                                     kClientHelloMinimumSize);
 
   ShouldSucceed(msg);
-  quiche::QuicheStringPiece cert, proof, cert_sct;
+  absl::string_view cert, proof, cert_sct;
   EXPECT_TRUE(out_.GetStringPiece(kCertificateTag, &cert));
   EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof));
   EXPECT_TRUE(out_.GetStringPiece(kCertificateSCTTag, &cert_sct));
@@ -442,7 +442,7 @@
   config_.set_chlo_multiplier(1);
 
   ShouldSucceed(msg);
-  quiche::QuicheStringPiece cert, proof, cert_sct;
+  absl::string_view cert, proof, cert_sct;
   EXPECT_FALSE(out_.GetStringPiece(kCertificateTag, &cert));
   EXPECT_FALSE(out_.GetStringPiece(kPROF, &proof));
   EXPECT_FALSE(out_.GetStringPiece(kCertificateSCTTag, &cert_sct));
@@ -469,7 +469,7 @@
   config_.set_chlo_multiplier(1);
 
   ShouldSucceed(msg);
-  quiche::QuicheStringPiece cert, proof, cert_sct;
+  absl::string_view cert, proof, cert_sct;
   EXPECT_TRUE(out_.GetStringPiece(kCertificateTag, &cert));
   EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof));
   EXPECT_TRUE(out_.GetStringPiece(kCertificateSCTTag, &cert_sct));
@@ -496,7 +496,7 @@
   config_.set_chlo_multiplier(1);
 
   ShouldSucceed(msg);
-  quiche::QuicheStringPiece cert, proof, cert_sct;
+  absl::string_view cert, proof, cert_sct;
   EXPECT_TRUE(out_.GetStringPiece(kCertificateTag, &cert));
   EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof));
   EXPECT_TRUE(out_.GetStringPiece(kCertificateSCTTag, &cert_sct));
@@ -780,13 +780,13 @@
       SOURCE_ADDRESS_TOKEN_DIFFERENT_IP_ADDRESS_FAILURE};
   CheckRejectReasons(kRejectReasons, QUICHE_ARRAYSIZE(kRejectReasons));
 
-  quiche::QuicheStringPiece cert, proof, scfg_str;
+  absl::string_view cert, proof, scfg_str;
   EXPECT_TRUE(out_.GetStringPiece(kCertificateTag, &cert));
   EXPECT_TRUE(out_.GetStringPiece(kPROF, &proof));
   EXPECT_TRUE(out_.GetStringPiece(kSCFG, &scfg_str));
   std::unique_ptr<CryptoHandshakeMessage> scfg(
       CryptoFramer::ParseMessage(scfg_str));
-  quiche::QuicheStringPiece scid;
+  absl::string_view scid;
   EXPECT_TRUE(scfg->GetStringPiece(kSCID, &scid));
   EXPECT_NE(scid, kOldConfigId);
 
@@ -886,7 +886,7 @@
   ShouldSucceed(msg);
   EXPECT_EQ(kSHLO, out_.tag());
 
-  quiche::QuicheStringPiece nonce;
+  absl::string_view nonce;
   EXPECT_TRUE(out_.GetStringPiece(kServerNonceTag, &nonce));
 }
 
@@ -922,7 +922,7 @@
   ShouldSucceed(msg);
 
   // Decompress cert chain from server to individual certs.
-  quiche::QuicheStringPiece certs_compressed;
+  absl::string_view certs_compressed;
   ASSERT_TRUE(out_.GetStringPiece(kCertificateTag, &certs_compressed));
   ASSERT_NE(0u, certs_compressed.size());
   std::vector<std::string> certs;
@@ -942,7 +942,7 @@
   ShouldSucceed(msg);
 
   // Server responds with inchoate REJ containing valid source-address token.
-  quiche::QuicheStringPiece srct;
+  absl::string_view srct;
   ASSERT_TRUE(out_.GetStringPiece(kSourceAddressTokenTag, &srct));
 
   // Client now drops cached certs; sends CHLO with updated source-address
@@ -1003,7 +1003,7 @@
   std::unique_ptr<CryptoHandshakeMessage> scfg_b(
       b.AddDefaultConfig(&rand_b, &clock, options));
 
-  quiche::QuicheStringPiece scid_a, scid_b;
+  absl::string_view scid_a, scid_b;
   EXPECT_TRUE(scfg_a->GetStringPiece(kSCID, &scid_a));
   EXPECT_TRUE(scfg_b->GetStringPiece(kSCID, &scid_b));
 
@@ -1021,7 +1021,7 @@
   std::unique_ptr<CryptoHandshakeMessage> scfg(
       a.AddDefaultConfig(&rand_a, &clock, options));
 
-  quiche::QuicheStringPiece scid;
+  absl::string_view scid;
   EXPECT_TRUE(scfg->GetStringPiece(kSCID, &scid));
   // Need to take a copy of |scid| has we're about to call |Erase|.
   const std::string scid_str(scid);
diff --git a/quic/core/crypto/crypto_utils.cc b/quic/core/crypto/crypto_utils.cc
index d98cf58..6c435ff 100644
--- a/quic/core/crypto/crypto_utils.cc
+++ b/quic/core/crypto/crypto_utils.cc
@@ -8,6 +8,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/bytestring.h"
 #include "third_party/boringssl/src/include/openssl/hkdf.h"
 #include "third_party/boringssl/src/include/openssl/mem.h"
@@ -35,7 +36,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"
 
 namespace quic {
 
@@ -105,12 +105,12 @@
       HkdfExpandLabel(prf, pp_secret, "quic iv", crypter->GetIVSize());
   std::vector<uint8_t> pn =
       HkdfExpandLabel(prf, pp_secret, "quic hp", crypter->GetKeySize());
-  crypter->SetKey(quiche::QuicheStringPiece(reinterpret_cast<char*>(key.data()),
-                                            key.size()));
+  crypter->SetKey(
+      absl::string_view(reinterpret_cast<char*>(key.data()), key.size()));
   crypter->SetIV(
-      quiche::QuicheStringPiece(reinterpret_cast<char*>(iv.data()), iv.size()));
+      absl::string_view(reinterpret_cast<char*>(iv.data()), iv.size()));
   crypter->SetHeaderProtectionKey(
-      quiche::QuicheStringPiece(reinterpret_cast<char*>(pn.data()), pn.size()));
+      absl::string_view(reinterpret_cast<char*>(pn.data()), pn.size()));
 }
 
 namespace {
@@ -214,8 +214,8 @@
     0x35, 0x9f, 0x16, 0xd1, 0xed, 0x80, 0x90, 0x8e, 0xec, 0x85, 0xc4, 0xd6};
 
 bool RetryIntegrityKeysForVersion(const ParsedQuicVersion& version,
-                                  quiche::QuicheStringPiece* key,
-                                  quiche::QuicheStringPiece* nonce) {
+                                  absl::string_view* key,
+                                  absl::string_view* nonce) {
   static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync with retry integrity keys");
   if (!version.HasRetryIntegrityTag()) {
@@ -223,42 +223,42 @@
              << version;
     return false;
   } else if (version == ParsedQuicVersion::Draft29()) {
-    *key = quiche::QuicheStringPiece(
+    *key = absl::string_view(
         reinterpret_cast<const char*>(kDraft29RetryIntegrityKey),
         QUICHE_ARRAYSIZE(kDraft29RetryIntegrityKey));
-    *nonce = quiche::QuicheStringPiece(
+    *nonce = absl::string_view(
         reinterpret_cast<const char*>(kDraft29RetryIntegrityNonce),
         QUICHE_ARRAYSIZE(kDraft29RetryIntegrityNonce));
     return true;
   } else if (version == ParsedQuicVersion::Draft27()) {
-    *key = quiche::QuicheStringPiece(
+    *key = absl::string_view(
         reinterpret_cast<const char*>(kDraft27RetryIntegrityKey),
         QUICHE_ARRAYSIZE(kDraft27RetryIntegrityKey));
-    *nonce = quiche::QuicheStringPiece(
+    *nonce = absl::string_view(
         reinterpret_cast<const char*>(kDraft27RetryIntegrityNonce),
         QUICHE_ARRAYSIZE(kDraft27RetryIntegrityNonce));
     return true;
   } else if (version == ParsedQuicVersion::T051()) {
-    *key = quiche::QuicheStringPiece(
-        reinterpret_cast<const char*>(kT051RetryIntegrityKey),
-        QUICHE_ARRAYSIZE(kT051RetryIntegrityKey));
-    *nonce = quiche::QuicheStringPiece(
+    *key =
+        absl::string_view(reinterpret_cast<const char*>(kT051RetryIntegrityKey),
+                          QUICHE_ARRAYSIZE(kT051RetryIntegrityKey));
+    *nonce = absl::string_view(
         reinterpret_cast<const char*>(kT051RetryIntegrityNonce),
         QUICHE_ARRAYSIZE(kT051RetryIntegrityNonce));
     return true;
   } else if (version == ParsedQuicVersion::T050()) {
-    *key = quiche::QuicheStringPiece(
-        reinterpret_cast<const char*>(kT050RetryIntegrityKey),
-        QUICHE_ARRAYSIZE(kT050RetryIntegrityKey));
-    *nonce = quiche::QuicheStringPiece(
+    *key =
+        absl::string_view(reinterpret_cast<const char*>(kT050RetryIntegrityKey),
+                          QUICHE_ARRAYSIZE(kT050RetryIntegrityKey));
+    *nonce = absl::string_view(
         reinterpret_cast<const char*>(kT050RetryIntegrityNonce),
         QUICHE_ARRAYSIZE(kT050RetryIntegrityNonce));
     return true;
   } else if (version == ParsedQuicVersion::ReservedForNegotiation()) {
-    *key = quiche::QuicheStringPiece(
+    *key = absl::string_view(
         reinterpret_cast<const char*>(kReservedForNegotiationRetryIntegrityKey),
         QUICHE_ARRAYSIZE(kReservedForNegotiationRetryIntegrityKey));
-    *nonce = quiche::QuicheStringPiece(
+    *nonce = absl::string_view(
         reinterpret_cast<const char*>(
             kReservedForNegotiationRetryIntegrityNonce),
         QUICHE_ARRAYSIZE(kReservedForNegotiationRetryIntegrityNonce));
@@ -329,8 +329,8 @@
 bool CryptoUtils::ValidateRetryIntegrityTag(
     ParsedQuicVersion version,
     QuicConnectionId original_connection_id,
-    quiche::QuicheStringPiece retry_without_tag,
-    quiche::QuicheStringPiece integrity_tag) {
+    absl::string_view retry_without_tag,
+    absl::string_view integrity_tag) {
   unsigned char computed_integrity_tag[kRetryIntegrityTagLength];
   if (integrity_tag.length() != QUICHE_ARRAYSIZE(computed_integrity_tag)) {
     QUIC_BUG << "Invalid retry integrity tag length " << integrity_tag.length();
@@ -347,16 +347,16 @@
     QUIC_BUG << "Failed to write retry without tag in retry pseudo packet";
     return false;
   }
-  quiche::QuicheStringPiece key;
-  quiche::QuicheStringPiece nonce;
+  absl::string_view key;
+  absl::string_view nonce;
   if (!RetryIntegrityKeysForVersion(version, &key, &nonce)) {
     // RetryIntegrityKeysForVersion already logs failures.
     return false;
   }
   Aes128GcmEncrypter crypter;
   crypter.SetKey(key);
-  quiche::QuicheStringPiece associated_data(writer.data(), writer.length());
-  quiche::QuicheStringPiece plaintext;  // Plaintext is empty.
+  absl::string_view associated_data(writer.data(), writer.length());
+  absl::string_view plaintext;  // Plaintext is empty.
   if (!crypter.Encrypt(nonce, associated_data, plaintext,
                        computed_integrity_tag)) {
     QUIC_BUG << "Failed to compute retry integrity tag";
@@ -373,7 +373,7 @@
 // static
 void CryptoUtils::GenerateNonce(QuicWallTime now,
                                 QuicRandom* random_generator,
-                                quiche::QuicheStringPiece orbit,
+                                absl::string_view orbit,
                                 std::string* nonce) {
   // a 4-byte timestamp + 28 random bytes.
   nonce->reserve(kNonceSize);
@@ -399,11 +399,11 @@
 
 // static
 bool CryptoUtils::DeriveKeys(const ParsedQuicVersion& version,
-                             quiche::QuicheStringPiece premaster_secret,
+                             absl::string_view premaster_secret,
                              QuicTag aead,
-                             quiche::QuicheStringPiece client_nonce,
-                             quiche::QuicheStringPiece server_nonce,
-                             quiche::QuicheStringPiece pre_shared_key,
+                             absl::string_view client_nonce,
+                             absl::string_view server_nonce,
+                             absl::string_view pre_shared_key,
                              const std::string& hkdf_input,
                              Perspective perspective,
                              Diversification diversification,
@@ -412,7 +412,7 @@
   // If the connection is using PSK, concatenate it with the pre-master secret.
   std::unique_ptr<char[]> psk_premaster_secret;
   if (!pre_shared_key.empty()) {
-    const quiche::QuicheStringPiece label(kPreSharedKeyLabel);
+    const absl::string_view label(kPreSharedKeyLabel);
     const size_t psk_premaster_secret_size = label.size() + 1 +
                                              pre_shared_key.size() + 8 +
                                              premaster_secret.size() + 8;
@@ -430,8 +430,8 @@
       return false;
     }
 
-    premaster_secret = quiche::QuicheStringPiece(psk_premaster_secret.get(),
-                                                 psk_premaster_secret_size);
+    premaster_secret = absl::string_view(psk_premaster_secret.get(),
+                                         psk_premaster_secret_size);
   }
 
   crypters->encrypter = QuicEncrypter::Create(version, aead);
@@ -445,7 +445,7 @@
   size_t subkey_secret_bytes =
       subkey_secret == nullptr ? 0 : premaster_secret.length();
 
-  quiche::QuicheStringPiece nonce = client_nonce;
+  absl::string_view nonce = client_nonce;
   std::string nonce_storage;
   if (!server_nonce.empty()) {
     nonce_storage = std::string(client_nonce) + std::string(server_nonce);
@@ -542,9 +542,9 @@
 }
 
 // static
-bool CryptoUtils::ExportKeyingMaterial(quiche::QuicheStringPiece subkey_secret,
-                                       quiche::QuicheStringPiece label,
-                                       quiche::QuicheStringPiece context,
+bool CryptoUtils::ExportKeyingMaterial(absl::string_view subkey_secret,
+                                       absl::string_view label,
+                                       absl::string_view context,
                                        size_t result_len,
                                        std::string* result) {
   for (size_t i = 0; i < label.length(); i++) {
@@ -564,14 +564,14 @@
   info.append(reinterpret_cast<char*>(&context_length), sizeof(context_length));
   info.append(context.data(), context.length());
 
-  QuicHKDF hkdf(subkey_secret, quiche::QuicheStringPiece() /* no salt */, info,
+  QuicHKDF hkdf(subkey_secret, absl::string_view() /* no salt */, info,
                 result_len, 0 /* no fixed IV */, 0 /* no subkey secret */);
   *result = std::string(hkdf.client_write_key());
   return true;
 }
 
 // static
-uint64_t CryptoUtils::ComputeLeafCertHash(quiche::QuicheStringPiece cert) {
+uint64_t CryptoUtils::ComputeLeafCertHash(absl::string_view cert) {
   return QuicUtils::FNV1a_64_Hash(cert);
 }
 
diff --git a/quic/core/crypto/crypto_utils.h b/quic/core/crypto/crypto_utils.h
index 964f81f..c21c534 100644
--- a/quic/core/crypto/crypto_utils.h
+++ b/quic/core/crypto/crypto_utils.h
@@ -11,6 +11,7 @@
 #include <cstdint>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/evp.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
@@ -22,7 +23,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_time.h"
 #include "net/third_party/quiche/src/quic/core/quic_versions.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 {
 
@@ -101,11 +101,10 @@
   // IETF QUIC Retry packets carry a retry integrity tag to detect packet
   // corruption and make it harder for an attacker to spoof. This function
   // checks whether a given retry packet is valid.
-  static bool ValidateRetryIntegrityTag(
-      ParsedQuicVersion version,
-      QuicConnectionId original_connection_id,
-      quiche::QuicheStringPiece retry_without_tag,
-      quiche::QuicheStringPiece integrity_tag);
+  static bool ValidateRetryIntegrityTag(ParsedQuicVersion version,
+                                        QuicConnectionId original_connection_id,
+                                        absl::string_view retry_without_tag,
+                                        absl::string_view integrity_tag);
 
   // Generates the connection nonce. The nonce is formed as:
   //   <4 bytes> current time
@@ -113,7 +112,7 @@
   //   <20 bytes> random
   static void GenerateNonce(QuicWallTime now,
                             QuicRandom* random_generator,
-                            quiche::QuicheStringPiece orbit,
+                            absl::string_view orbit,
                             std::string* nonce);
 
   // DeriveKeys populates |crypters->encrypter|, |crypters->decrypter|, and
@@ -136,11 +135,11 @@
   // |SetDiversificationNonce| with a diversification nonce will be needed to
   // complete keying.
   static bool DeriveKeys(const ParsedQuicVersion& version,
-                         quiche::QuicheStringPiece premaster_secret,
+                         absl::string_view premaster_secret,
                          QuicTag aead,
-                         quiche::QuicheStringPiece client_nonce,
-                         quiche::QuicheStringPiece server_nonce,
-                         quiche::QuicheStringPiece pre_shared_key,
+                         absl::string_view client_nonce,
+                         absl::string_view server_nonce,
+                         absl::string_view pre_shared_key,
                          const std::string& hkdf_input,
                          Perspective perspective,
                          Diversification diversification,
@@ -151,15 +150,15 @@
   // dependent on |subkey_secret|, |label|, and |context|. Returns false if the
   // parameters are invalid (e.g. |label| contains null bytes); returns true on
   // success.
-  static bool ExportKeyingMaterial(quiche::QuicheStringPiece subkey_secret,
-                                   quiche::QuicheStringPiece label,
-                                   quiche::QuicheStringPiece context,
+  static bool ExportKeyingMaterial(absl::string_view subkey_secret,
+                                   absl::string_view label,
+                                   absl::string_view context,
                                    size_t result_len,
                                    std::string* result);
 
   // Computes the FNV-1a hash of the provided DER-encoded cert for use in the
   // XLCT tag.
-  static uint64_t ComputeLeafCertHash(quiche::QuicheStringPiece cert);
+  static uint64_t ComputeLeafCertHash(absl::string_view cert);
 
   // Validates that |server_hello| is actually an SHLO message and that it is
   // not part of a downgrade attack.
diff --git a/quic/core/crypto/curve25519_key_exchange.cc b/quic/core/crypto/curve25519_key_exchange.cc
index 2f19e9d..acdf9a8 100644
--- a/quic/core/crypto/curve25519_key_exchange.cc
+++ b/quic/core/crypto/curve25519_key_exchange.cc
@@ -8,11 +8,11 @@
 #include <cstring>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/curve25519.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.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 {
 
@@ -31,7 +31,7 @@
 
 // static
 std::unique_ptr<Curve25519KeyExchange> Curve25519KeyExchange::New(
-    quiche::QuicheStringPiece private_key) {
+    absl::string_view private_key) {
   // We don't want to #include the BoringSSL headers in the public header file,
   // so we use literals for the sizes of private_key_ and public_key_. Here we
   // assert that those values are equal to the values from the BoringSSL
@@ -61,7 +61,7 @@
 }
 
 bool Curve25519KeyExchange::CalculateSharedKeySync(
-    quiche::QuicheStringPiece peer_public_value,
+    absl::string_view peer_public_value,
     std::string* shared_key) const {
   if (peer_public_value.size() != X25519_PUBLIC_VALUE_LEN) {
     return false;
@@ -77,9 +77,9 @@
   return true;
 }
 
-quiche::QuicheStringPiece Curve25519KeyExchange::public_value() const {
-  return quiche::QuicheStringPiece(reinterpret_cast<const char*>(public_key_),
-                                   sizeof(public_key_));
+absl::string_view Curve25519KeyExchange::public_value() const {
+  return absl::string_view(reinterpret_cast<const char*>(public_key_),
+                           sizeof(public_key_));
 }
 
 }  // namespace quic
diff --git a/quic/core/crypto/curve25519_key_exchange.h b/quic/core/crypto/curve25519_key_exchange.h
index 76fd23f..e6703ec 100644
--- a/quic/core/crypto/curve25519_key_exchange.h
+++ b/quic/core/crypto/curve25519_key_exchange.h
@@ -8,9 +8,9 @@
 #include <cstdint>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/key_exchange.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 {
 
@@ -29,16 +29,16 @@
   // New creates a new key-exchange object from a private key. If |private_key|
   // is invalid, nullptr is returned.
   static std::unique_ptr<Curve25519KeyExchange> New(
-      quiche::QuicheStringPiece private_key);
+      absl::string_view private_key);
 
   // NewPrivateKey returns a private key, generated from |rand|, suitable for
   // passing to |New|.
   static std::string NewPrivateKey(QuicRandom* rand);
 
   // SynchronousKeyExchange interface.
-  bool CalculateSharedKeySync(quiche::QuicheStringPiece peer_public_value,
+  bool CalculateSharedKeySync(absl::string_view peer_public_value,
                               std::string* shared_key) const override;
-  quiche::QuicheStringPiece public_value() const override;
+  absl::string_view public_value() const override;
   QuicTag type() const override { return kC255; }
 
  private:
diff --git a/quic/core/crypto/curve25519_key_exchange_test.cc b/quic/core/crypto/curve25519_key_exchange_test.cc
index 2e5dfb4..f100df5 100644
--- a/quic/core/crypto/curve25519_key_exchange_test.cc
+++ b/quic/core/crypto/curve25519_key_exchange_test.cc
@@ -8,9 +8,9 @@
 #include <string>
 #include <utility>
 
+#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/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -55,8 +55,8 @@
     std::unique_ptr<Curve25519KeyExchange> bob(
         Curve25519KeyExchange::New(bob_key));
 
-    const quiche::QuicheStringPiece alice_public(alice->public_value());
-    const quiche::QuicheStringPiece bob_public(bob->public_value());
+    const absl::string_view alice_public(alice->public_value());
+    const absl::string_view bob_public(bob->public_value());
 
     std::string alice_shared, bob_shared;
     ASSERT_TRUE(alice->CalculateSharedKeySync(bob_public, &alice_shared));
@@ -79,8 +79,8 @@
     std::unique_ptr<Curve25519KeyExchange> bob(
         Curve25519KeyExchange::New(bob_key));
 
-    const quiche::QuicheStringPiece alice_public(alice->public_value());
-    const quiche::QuicheStringPiece bob_public(bob->public_value());
+    const absl::string_view alice_public(alice->public_value());
+    const absl::string_view bob_public(bob->public_value());
 
     std::string alice_shared, bob_shared;
     TestCallbackResult alice_result;
diff --git a/quic/core/crypto/key_exchange.cc b/quic/core/crypto/key_exchange.cc
index 84f9c86..d7c0105 100644
--- a/quic/core/crypto/key_exchange.cc
+++ b/quic/core/crypto/key_exchange.cc
@@ -3,16 +3,16 @@
 // found in the LICENSE file.
 
 #include "net/third_party/quiche/src/quic/core/crypto/key_exchange.h"
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/curve25519_key_exchange.h"
 #include "net/third_party/quiche/src/quic/core/crypto/p256_key_exchange.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
 std::unique_ptr<SynchronousKeyExchange> CreateLocalSynchronousKeyExchange(
     QuicTag type,
-    quiche::QuicheStringPiece private_key) {
+    absl::string_view private_key) {
   switch (type) {
     case kC255:
       return Curve25519KeyExchange::New(private_key);
diff --git a/quic/core/crypto/key_exchange.h b/quic/core/crypto/key_exchange.h
index cb6fdbc..e4288d7 100644
--- a/quic/core/crypto/key_exchange.h
+++ b/quic/core/crypto/key_exchange.h
@@ -8,9 +8,9 @@
 #include <memory>
 #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/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -48,7 +48,7 @@
   // that |callback| might be invoked synchronously.  Results will be written
   // into |*shared_key|.
   virtual void CalculateSharedKeyAsync(
-      quiche::QuicheStringPiece peer_public_value,
+      absl::string_view peer_public_value,
       std::string* shared_key,
       std::unique_ptr<Callback> callback) const = 0;
 
@@ -66,7 +66,7 @@
 
   // AyncKeyExchange API.  Note that this method is marked 'final.'  Subclasses
   // should implement CalculateSharedKeySync only.
-  void CalculateSharedKeyAsync(quiche::QuicheStringPiece peer_public_value,
+  void CalculateSharedKeyAsync(absl::string_view peer_public_value,
                                std::string* shared_key,
                                std::unique_ptr<Callback> callback) const final {
     const bool ok = CalculateSharedKeySync(peer_public_value, shared_key);
@@ -75,15 +75,14 @@
 
   // CalculateSharedKey computes the shared key between a local private key and
   // a public value from the peer.  Results will be written into |*shared_key|.
-  virtual bool CalculateSharedKeySync(
-      quiche::QuicheStringPiece peer_public_value,
-      std::string* shared_key) const = 0;
+  virtual bool CalculateSharedKeySync(absl::string_view peer_public_value,
+                                      std::string* shared_key) const = 0;
 
   // public_value returns the local public key which can be sent to a peer in
-  // order to complete a key exchange. The returned quiche::QuicheStringPiece is
+  // order to complete a key exchange. The returned absl::string_view is
   // a reference to a member of this object and is only valid for as long as it
   // exists.
-  virtual quiche::QuicheStringPiece public_value() const = 0;
+  virtual absl::string_view public_value() const = 0;
 };
 
 // Create a SynchronousKeyExchange object which will use a keypair generated
@@ -92,7 +91,7 @@
 // invalid.
 std::unique_ptr<SynchronousKeyExchange> CreateLocalSynchronousKeyExchange(
     QuicTag type,
-    quiche::QuicheStringPiece private_key);
+    absl::string_view private_key);
 
 // Create a SynchronousKeyExchange object which will use a keypair generated
 // from |rand|, and a key-exchange algorithm specified by |type|, which must be
diff --git a/quic/core/crypto/null_decrypter.cc b/quic/core/crypto/null_decrypter.cc
index d453a35..ef0342c 100644
--- a/quic/core/crypto/null_decrypter.cc
+++ b/quic/core/crypto/null_decrypter.cc
@@ -6,35 +6,35 @@
 
 #include <cstdint>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_data_reader.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_uint128.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 {
 
 NullDecrypter::NullDecrypter(Perspective perspective)
     : perspective_(perspective) {}
 
-bool NullDecrypter::SetKey(quiche::QuicheStringPiece key) {
+bool NullDecrypter::SetKey(absl::string_view key) {
   return key.empty();
 }
 
-bool NullDecrypter::SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) {
+bool NullDecrypter::SetNoncePrefix(absl::string_view nonce_prefix) {
   return nonce_prefix.empty();
 }
 
-bool NullDecrypter::SetIV(quiche::QuicheStringPiece iv) {
+bool NullDecrypter::SetIV(absl::string_view iv) {
   return iv.empty();
 }
 
-bool NullDecrypter::SetHeaderProtectionKey(quiche::QuicheStringPiece key) {
+bool NullDecrypter::SetHeaderProtectionKey(absl::string_view key) {
   return key.empty();
 }
 
-bool NullDecrypter::SetPreliminaryKey(quiche::QuicheStringPiece /*key*/) {
+bool NullDecrypter::SetPreliminaryKey(absl::string_view /*key*/) {
   QUIC_BUG << "Should not be called";
   return false;
 }
@@ -46,8 +46,8 @@
 }
 
 bool NullDecrypter::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) {
@@ -59,7 +59,7 @@
     return false;
   }
 
-  quiche::QuicheStringPiece plaintext = reader.ReadRemainingPayload();
+  absl::string_view plaintext = reader.ReadRemainingPayload();
   if (plaintext.length() > max_output_length) {
     QUIC_BUG << "Output buffer must be larger than the plaintext.";
     return false;
@@ -90,12 +90,12 @@
   return 0;
 }
 
-quiche::QuicheStringPiece NullDecrypter::GetKey() const {
-  return quiche::QuicheStringPiece();
+absl::string_view NullDecrypter::GetKey() const {
+  return absl::string_view();
 }
 
-quiche::QuicheStringPiece NullDecrypter::GetNoncePrefix() const {
-  return quiche::QuicheStringPiece();
+absl::string_view NullDecrypter::GetNoncePrefix() const {
+  return absl::string_view();
 }
 
 uint32_t NullDecrypter::cipher_id() const {
@@ -112,9 +112,8 @@
   return true;
 }
 
-QuicUint128 NullDecrypter::ComputeHash(
-    const quiche::QuicheStringPiece data1,
-    const quiche::QuicheStringPiece data2) const {
+QuicUint128 NullDecrypter::ComputeHash(const absl::string_view data1,
+                                       const absl::string_view data2) const {
   QuicUint128 correct_hash;
   if (perspective_ == Perspective::IS_CLIENT) {
     // Peer is a server.
diff --git a/quic/core/crypto/null_decrypter.h b/quic/core/crypto/null_decrypter.h
index c3bd203..a760ab5 100644
--- a/quic/core/crypto/null_decrypter.h
+++ b/quic/core/crypto/null_decrypter.h
@@ -8,11 +8,11 @@
 #include <cstddef>
 #include <cstdint>
 
+#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/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_uint128.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -29,15 +29,15 @@
   ~NullDecrypter() override {}
 
   // QuicDecrypter implementation
-  bool SetKey(quiche::QuicheStringPiece key) override;
-  bool SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) override;
-  bool SetIV(quiche::QuicheStringPiece iv) override;
-  bool SetHeaderProtectionKey(quiche::QuicheStringPiece key) override;
-  bool SetPreliminaryKey(quiche::QuicheStringPiece key) override;
+  bool SetKey(absl::string_view key) override;
+  bool SetNoncePrefix(absl::string_view nonce_prefix) override;
+  bool SetIV(absl::string_view iv) override;
+  bool SetHeaderProtectionKey(absl::string_view key) override;
+  bool SetPreliminaryKey(absl::string_view key) override;
   bool SetDiversificationNonce(const DiversificationNonce& nonce) override;
   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;
@@ -46,15 +46,15 @@
   size_t GetKeySize() const override;
   size_t GetNoncePrefixSize() const override;
   size_t GetIVSize() const override;
-  quiche::QuicheStringPiece GetKey() const override;
-  quiche::QuicheStringPiece GetNoncePrefix() const override;
+  absl::string_view GetKey() const override;
+  absl::string_view GetNoncePrefix() const override;
 
   uint32_t cipher_id() const override;
 
  private:
   bool ReadHash(QuicDataReader* reader, QuicUint128* hash);
-  QuicUint128 ComputeHash(quiche::QuicheStringPiece data1,
-                          quiche::QuicheStringPiece data2) const;
+  QuicUint128 ComputeHash(absl::string_view data1,
+                          absl::string_view data2) const;
 
   Perspective perspective_;
 };
diff --git a/quic/core/crypto/null_decrypter_test.cc b/quic/core/crypto/null_decrypter_test.cc
index 1baecad..63b715b 100644
--- a/quic/core/crypto/null_decrypter_test.cc
+++ b/quic/core/crypto/null_decrypter_test.cc
@@ -42,11 +42,10 @@
   NullDecrypter decrypter(Perspective::IS_SERVER);
   char buffer[256];
   size_t length = 0;
-  ASSERT_TRUE(decrypter.DecryptPacket(0, "hello world!",
-                                      quiche::QuicheStringPiece(data, len),
-                                      buffer, &length, 256));
+  ASSERT_TRUE(decrypter.DecryptPacket(
+      0, "hello world!", absl::string_view(data, len), buffer, &length, 256));
   EXPECT_LT(0u, length);
-  EXPECT_EQ("goodbye!", quiche::QuicheStringPiece(buffer, length));
+  EXPECT_EQ("goodbye!", absl::string_view(buffer, length));
 }
 
 TEST_F(NullDecrypterTest, DecryptServer) {
@@ -79,11 +78,10 @@
   NullDecrypter decrypter(Perspective::IS_CLIENT);
   char buffer[256];
   size_t length = 0;
-  ASSERT_TRUE(decrypter.DecryptPacket(0, "hello world!",
-                                      quiche::QuicheStringPiece(data, len),
-                                      buffer, &length, 256));
+  ASSERT_TRUE(decrypter.DecryptPacket(
+      0, "hello world!", absl::string_view(data, len), buffer, &length, 256));
   EXPECT_LT(0u, length);
-  EXPECT_EQ("goodbye!", quiche::QuicheStringPiece(buffer, length));
+  EXPECT_EQ("goodbye!", absl::string_view(buffer, length));
 }
 
 TEST_F(NullDecrypterTest, BadHash) {
@@ -116,9 +114,8 @@
   NullDecrypter decrypter(Perspective::IS_CLIENT);
   char buffer[256];
   size_t length = 0;
-  ASSERT_FALSE(decrypter.DecryptPacket(0, "hello world!",
-                                       quiche::QuicheStringPiece(data, len),
-                                       buffer, &length, 256));
+  ASSERT_FALSE(decrypter.DecryptPacket(
+      0, "hello world!", absl::string_view(data, len), buffer, &length, 256));
 }
 
 TEST_F(NullDecrypterTest, ShortInput) {
@@ -131,9 +128,8 @@
   NullDecrypter decrypter(Perspective::IS_CLIENT);
   char buffer[256];
   size_t length = 0;
-  ASSERT_FALSE(decrypter.DecryptPacket(0, "hello world!",
-                                       quiche::QuicheStringPiece(data, len),
-                                       buffer, &length, 256));
+  ASSERT_FALSE(decrypter.DecryptPacket(
+      0, "hello world!", absl::string_view(data, len), buffer, &length, 256));
 }
 
 }  // namespace test
diff --git a/quic/core/crypto/null_encrypter.cc b/quic/core/crypto/null_encrypter.cc
index 4de1510..1d5dd8b 100644
--- a/quic/core/crypto/null_encrypter.cc
+++ b/quic/core/crypto/null_encrypter.cc
@@ -4,9 +4,9 @@
 
 #include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
 
+#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_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -15,25 +15,25 @@
 NullEncrypter::NullEncrypter(Perspective perspective)
     : perspective_(perspective) {}
 
-bool NullEncrypter::SetKey(quiche::QuicheStringPiece key) {
+bool NullEncrypter::SetKey(absl::string_view key) {
   return key.empty();
 }
 
-bool NullEncrypter::SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) {
+bool NullEncrypter::SetNoncePrefix(absl::string_view nonce_prefix) {
   return nonce_prefix.empty();
 }
 
-bool NullEncrypter::SetIV(quiche::QuicheStringPiece iv) {
+bool NullEncrypter::SetIV(absl::string_view iv) {
   return iv.empty();
 }
 
-bool NullEncrypter::SetHeaderProtectionKey(quiche::QuicheStringPiece key) {
+bool NullEncrypter::SetHeaderProtectionKey(absl::string_view key) {
   return key.empty();
 }
 
 bool NullEncrypter::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) {
@@ -59,7 +59,7 @@
 }
 
 std::string NullEncrypter::GenerateHeaderProtectionMask(
-    quiche::QuicheStringPiece /*sample*/) {
+    absl::string_view /*sample*/) {
   return std::string(5, 0);
 }
 
@@ -83,12 +83,12 @@
   return plaintext_size + GetHashLength();
 }
 
-quiche::QuicheStringPiece NullEncrypter::GetKey() const {
-  return quiche::QuicheStringPiece();
+absl::string_view NullEncrypter::GetKey() const {
+  return absl::string_view();
 }
 
-quiche::QuicheStringPiece NullEncrypter::GetNoncePrefix() const {
-  return quiche::QuicheStringPiece();
+absl::string_view NullEncrypter::GetNoncePrefix() const {
+  return absl::string_view();
 }
 
 size_t NullEncrypter::GetHashLength() const {
diff --git a/quic/core/crypto/null_encrypter.h b/quic/core/crypto/null_encrypter.h
index bda73dc..bdfd2e7 100644
--- a/quic/core/crypto/null_encrypter.h
+++ b/quic/core/crypto/null_encrypter.h
@@ -7,10 +7,10 @@
 
 #include <cstddef>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.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 {
 
@@ -25,25 +25,24 @@
   ~NullEncrypter() override {}
 
   // QuicEncrypter implementation
-  bool SetKey(quiche::QuicheStringPiece key) override;
-  bool SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) override;
-  bool SetIV(quiche::QuicheStringPiece iv) override;
-  bool SetHeaderProtectionKey(quiche::QuicheStringPiece key) override;
+  bool SetKey(absl::string_view key) override;
+  bool SetNoncePrefix(absl::string_view nonce_prefix) override;
+  bool SetIV(absl::string_view iv) override;
+  bool SetHeaderProtectionKey(absl::string_view key) override;
   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;
+  std::string GenerateHeaderProtectionMask(absl::string_view sample) override;
   size_t GetKeySize() const override;
   size_t GetNoncePrefixSize() const override;
   size_t GetIVSize() const override;
   size_t GetMaxPlaintextSize(size_t ciphertext_size) const override;
   size_t GetCiphertextSize(size_t plaintext_size) const override;
-  quiche::QuicheStringPiece GetKey() const override;
-  quiche::QuicheStringPiece GetNoncePrefix() const override;
+  absl::string_view GetKey() const override;
+  absl::string_view GetNoncePrefix() const override;
 
  private:
   size_t GetHashLength() const;
diff --git a/quic/core/crypto/p256_key_exchange.cc b/quic/core/crypto/p256_key_exchange.cc
index 01f345d..7a543b9 100644
--- a/quic/core/crypto/p256_key_exchange.cc
+++ b/quic/core/crypto/p256_key_exchange.cc
@@ -10,13 +10,13 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/ec.h"
 #include "third_party/boringssl/src/include/openssl/ecdh.h"
 #include "third_party/boringssl/src/include/openssl/err.h"
 #include "third_party/boringssl/src/include/openssl/evp.h"
 #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/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -34,8 +34,7 @@
 }
 
 // static
-std::unique_ptr<P256KeyExchange> P256KeyExchange::New(
-    quiche::QuicheStringPiece key) {
+std::unique_ptr<P256KeyExchange> P256KeyExchange::New(absl::string_view key) {
   if (key.empty()) {
     QUIC_DLOG(INFO) << "Private key is empty";
     return nullptr;
@@ -85,7 +84,7 @@
 }
 
 bool P256KeyExchange::CalculateSharedKeySync(
-    quiche::QuicheStringPiece peer_public_value,
+    absl::string_view peer_public_value,
     std::string* shared_key) const {
   if (peer_public_value.size() != kUncompressedP256PointBytes) {
     QUIC_DLOG(INFO) << "Peer public value is invalid";
@@ -115,9 +114,9 @@
   return true;
 }
 
-quiche::QuicheStringPiece P256KeyExchange::public_value() const {
-  return quiche::QuicheStringPiece(reinterpret_cast<const char*>(public_key_),
-                                   sizeof(public_key_));
+absl::string_view P256KeyExchange::public_value() const {
+  return absl::string_view(reinterpret_cast<const char*>(public_key_),
+                           sizeof(public_key_));
 }
 
 }  // namespace quic
diff --git a/quic/core/crypto/p256_key_exchange.h b/quic/core/crypto/p256_key_exchange.h
index 10cc542..2b6f9b8 100644
--- a/quic/core/crypto/p256_key_exchange.h
+++ b/quic/core/crypto/p256_key_exchange.h
@@ -8,10 +8,10 @@
 #include <cstdint>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/base.h"
 #include "net/third_party/quiche/src/quic/core/crypto/key_exchange.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 {
 
@@ -26,8 +26,7 @@
 
   // New creates a new key-exchange object from a private key. If |private_key|
   // is invalid, nullptr is returned.
-  static std::unique_ptr<P256KeyExchange> New(
-      quiche::QuicheStringPiece private_key);
+  static std::unique_ptr<P256KeyExchange> New(absl::string_view private_key);
 
   // NewPrivateKey returns a private key, suitable for passing to |New|.
   // If |NewPrivateKey| can't generate a private key, it returns an empty
@@ -35,9 +34,9 @@
   static std::string NewPrivateKey();
 
   // SynchronousKeyExchange interface.
-  bool CalculateSharedKeySync(quiche::QuicheStringPiece peer_public_value,
+  bool CalculateSharedKeySync(absl::string_view peer_public_value,
                               std::string* shared_key) const override;
-  quiche::QuicheStringPiece public_value() const override;
+  absl::string_view public_value() const override;
   QuicTag type() const override { return kP256; }
 
  private:
diff --git a/quic/core/crypto/p256_key_exchange_test.cc b/quic/core/crypto/p256_key_exchange_test.cc
index 7e7dcd7..9419dcb 100644
--- a/quic/core/crypto/p256_key_exchange_test.cc
+++ b/quic/core/crypto/p256_key_exchange_test.cc
@@ -8,8 +8,8 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -57,8 +57,8 @@
     ASSERT_TRUE(alice != nullptr);
     ASSERT_TRUE(bob != nullptr);
 
-    const quiche::QuicheStringPiece alice_public(alice->public_value());
-    const quiche::QuicheStringPiece bob_public(bob->public_value());
+    const absl::string_view alice_public(alice->public_value());
+    const absl::string_view bob_public(bob->public_value());
 
     std::string alice_shared, bob_shared;
     ASSERT_TRUE(alice->CalculateSharedKeySync(bob_public, &alice_shared));
@@ -84,8 +84,8 @@
     ASSERT_TRUE(alice != nullptr);
     ASSERT_TRUE(bob != nullptr);
 
-    const quiche::QuicheStringPiece alice_public(alice->public_value());
-    const quiche::QuicheStringPiece bob_public(bob->public_value());
+    const absl::string_view alice_public(alice->public_value());
+    const absl::string_view bob_public(bob->public_value());
 
     std::string alice_shared, bob_shared;
     TestCallbackResult alice_result;
diff --git a/quic/core/crypto/proof_source.h b/quic/core/crypto/proof_source.h
index 637dd0c..e9358d5 100644
--- a/quic/core/crypto/proof_source.h
+++ b/quic/core/crypto/proof_source.h
@@ -9,13 +9,13 @@
 #include <string>
 #include <vector>
 
+#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_proof.h"
 #include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_reference_counted.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 {
 
@@ -137,7 +137,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) = 0;
 
   // Returns the certificate chain for |hostname| in leaf-first order.
@@ -159,7 +159,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) = 0;
 
   class QUIC_EXPORT_PRIVATE DecryptCallback {
@@ -193,13 +193,13 @@
     // returns the encrypted ticket. The resulting value must not be larger than
     // MaxOverhead bytes larger than |in|. If encryption fails, this method
     // returns an empty vector.
-    virtual std::vector<uint8_t> Encrypt(quiche::QuicheStringPiece in) = 0;
+    virtual std::vector<uint8_t> Encrypt(absl::string_view in) = 0;
 
     // Decrypt takes an encrypted ticket |in|, decrypts it, and calls
     // |callback->Run| with the decrypted ticket, which must not be larger than
     // |in|. If decryption fails, the callback is invoked with an empty
     // vector.
-    virtual void Decrypt(quiche::QuicheStringPiece in,
+    virtual void Decrypt(absl::string_view in,
                          std::unique_ptr<DecryptCallback> callback) = 0;
   };
 
diff --git a/quic/core/crypto/proof_source_x509.cc b/quic/core/crypto/proof_source_x509.cc
index e432682..7a46ff2 100644
--- a/quic/core/crypto/proof_source_x509.cc
+++ b/quic/core/crypto/proof_source_x509.cc
@@ -6,6 +6,7 @@
 
 #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/crypto/certificate_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
@@ -13,7 +14,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.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 {
 
@@ -34,7 +34,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) {
   QuicCryptoProof proof;
 
@@ -54,9 +54,9 @@
   }
 
   Certificate* certificate = GetCertificate(hostname);
-  proof.signature = certificate->key.Sign(
-      quiche::QuicheStringPiece(payload.get(), payload_size),
-      SSL_SIGN_RSA_PSS_RSAE_SHA256);
+  proof.signature =
+      certificate->key.Sign(absl::string_view(payload.get(), payload_size),
+                            SSL_SIGN_RSA_PSS_RSAE_SHA256);
   callback->Run(/*ok=*/!proof.signature.empty(), certificate->chain, proof,
                 nullptr);
 }
@@ -73,7 +73,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) {
   std::string signature =
       GetCertificate(hostname)->key.Sign(in, signature_algorithm);
@@ -109,7 +109,7 @@
   });
   Certificate* certificate = &certificates_.front();
 
-  for (quiche::QuicheStringPiece host : leaf->subject_alt_name_domains()) {
+  for (absl::string_view host : leaf->subject_alt_name_domains()) {
     certificate_map_[std::string(host)] = certificate;
   }
   return true;
diff --git a/quic/core/crypto/proof_source_x509.h b/quic/core/crypto/proof_source_x509.h
index 8632d4b..38a70ae 100644
--- a/quic/core/crypto/proof_source_x509.h
+++ b/quic/core/crypto/proof_source_x509.h
@@ -8,11 +8,11 @@
 #include <forward_list>
 #include <memory>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/certificate_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/proof_source.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_containers.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 {
 
@@ -32,7 +32,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(
       const QuicSocketAddress& server_address,
@@ -43,7 +43,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;
 
diff --git a/quic/core/crypto/proof_source_x509_test.cc b/quic/core/crypto/proof_source_x509_test.cc
index 23311d0..e0b45c6 100644
--- a/quic/core/crypto/proof_source_x509_test.cc
+++ b/quic/core/crypto/proof_source_x509_test.cc
@@ -6,6 +6,7 @@
 
 #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/crypto/certificate_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/proof_source.h"
@@ -15,14 +16,13 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/test_certificates.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
 namespace {
 
 QuicReferenceCountedPointer<ProofSource::Chain> MakeChain(
-    quiche::QuicheStringPiece cert) {
+    absl::string_view cert) {
   return QuicReferenceCountedPointer<ProofSource::Chain>(
       new ProofSource::Chain(std::vector<std::string>{std::string(cert)}));
 }
diff --git a/quic/core/crypto/proof_verifier.h b/quic/core/crypto/proof_verifier.h
index 0380b8a..7576620 100644
--- a/quic/core/crypto/proof_verifier.h
+++ b/quic/core/crypto/proof_verifier.h
@@ -9,10 +9,10 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/core/quic_versions.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 {
 
@@ -79,7 +79,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,
diff --git a/quic/core/crypto/quic_crypter.cc b/quic/core/crypto/quic_crypter.cc
index d8e7f2d..036f694 100644
--- a/quic/core/crypto/quic_crypter.cc
+++ b/quic/core/crypto/quic_crypter.cc
@@ -3,13 +3,12 @@
 // found in the LICENSE file.
 
 #include "net/third_party/quiche/src/quic/core/crypto/quic_crypter.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "absl/strings/string_view.h"
 
 namespace quic {
 
-bool QuicCrypter::SetNoncePrefixOrIV(
-    const ParsedQuicVersion& version,
-    quiche::QuicheStringPiece nonce_prefix_or_iv) {
+bool QuicCrypter::SetNoncePrefixOrIV(const ParsedQuicVersion& version,
+                                     absl::string_view nonce_prefix_or_iv) {
   if (version.UsesInitialObfuscators()) {
     return SetIV(nonce_prefix_or_iv);
   }
diff --git a/quic/core/crypto/quic_crypter.h b/quic/core/crypto/quic_crypter.h
index a12cd6f..348a3fb 100644
--- a/quic/core/crypto/quic_crypter.h
+++ b/quic/core/crypto/quic_crypter.h
@@ -5,9 +5,9 @@
 #ifndef QUICHE_QUIC_CORE_CRYPTO_QUIC_CRYPTER_H_
 #define QUICHE_QUIC_CORE_CRYPTO_QUIC_CRYPTER_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_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -24,7 +24,7 @@
   //
   // NOTE: The key is the client_write_key or server_write_key derived from
   // the master secret.
-  virtual bool SetKey(quiche::QuicheStringPiece key) = 0;
+  virtual bool SetKey(absl::string_view key) = 0;
 
   // Sets the fixed initial bytes of the nonce. Returns true on success,
   // false on failure. This method must only be used with Google QUIC crypters.
@@ -41,7 +41,7 @@
   //
   // The security of the nonce format requires that QUIC never reuse a
   // packet number, even when retransmitting a lost packet.
-  virtual bool SetNoncePrefix(quiche::QuicheStringPiece nonce_prefix) = 0;
+  virtual bool SetNoncePrefix(absl::string_view nonce_prefix) = 0;
 
   // Sets |iv| as the initialization vector to use when constructing the nonce.
   // Returns true on success, false on failure. This method must only be used
@@ -68,15 +68,15 @@
   //
   // The security of the nonce format requires that QUIC never reuse a
   // packet number, even when retransmitting a lost packet.
-  virtual bool SetIV(quiche::QuicheStringPiece iv) = 0;
+  virtual bool SetIV(absl::string_view iv) = 0;
 
   // Calls SetNoncePrefix or SetIV depending on whether |version| uses the
   // Google QUIC crypto or IETF QUIC nonce construction.
   virtual bool SetNoncePrefixOrIV(const ParsedQuicVersion& version,
-                                  quiche::QuicheStringPiece nonce_prefix_or_iv);
+                                  absl::string_view nonce_prefix_or_iv);
 
   // Sets the key to use for header protection.
-  virtual bool SetHeaderProtectionKey(quiche::QuicheStringPiece key) = 0;
+  virtual bool SetHeaderProtectionKey(absl::string_view key) = 0;
 
   // GetKeySize, GetIVSize, and GetNoncePrefixSize are used to know how many
   // bytes of key material needs to be derived from the master secret.
diff --git a/quic/core/crypto/quic_crypto_client_config.cc b/quic/core/crypto/quic_crypto_client_config.cc
index c110f8e..a74e16f 100644
--- a/quic/core/crypto/quic_crypto_client_config.cc
+++ b/quic/core/crypto/quic_crypto_client_config.cc
@@ -8,6 +8,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/cert_compressor.h"
 #include "net/third_party/quiche/src/quic/core/crypto/chacha20_poly1305_encrypter.h"
@@ -32,7 +33,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.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 {
@@ -144,7 +144,7 @@
 
 QuicCryptoClientConfig::CachedState::ServerConfigState
 QuicCryptoClientConfig::CachedState::SetServerConfig(
-    quiche::QuicheStringPiece server_config,
+    absl::string_view server_config,
     QuicWallTime now,
     QuicWallTime expiry_time,
     std::string* error_details) {
@@ -199,9 +199,9 @@
 
 void QuicCryptoClientConfig::CachedState::SetProof(
     const std::vector<std::string>& certs,
-    quiche::QuicheStringPiece cert_sct,
-    quiche::QuicheStringPiece chlo_hash,
-    quiche::QuicheStringPiece signature) {
+    absl::string_view cert_sct,
+    absl::string_view chlo_hash,
+    absl::string_view signature) {
   bool has_changed = signature != server_config_sig_ ||
                      chlo_hash != chlo_hash_ || certs_.size() != certs.size();
 
@@ -257,12 +257,12 @@
 }
 
 bool QuicCryptoClientConfig::CachedState::Initialize(
-    quiche::QuicheStringPiece server_config,
-    quiche::QuicheStringPiece source_address_token,
+    absl::string_view server_config,
+    absl::string_view source_address_token,
     const std::vector<std::string>& certs,
     const std::string& cert_sct,
-    quiche::QuicheStringPiece chlo_hash,
-    quiche::QuicheStringPiece signature,
+    absl::string_view chlo_hash,
+    absl::string_view signature,
     QuicWallTime now,
     QuicWallTime expiration_time) {
   DCHECK(server_config_.empty());
@@ -330,12 +330,12 @@
 }
 
 void QuicCryptoClientConfig::CachedState::set_source_address_token(
-    quiche::QuicheStringPiece token) {
+    absl::string_view token) {
   source_address_token_ = std::string(token);
 }
 
 void QuicCryptoClientConfig::CachedState::set_cert_sct(
-    quiche::QuicheStringPiece cert_sct) {
+    absl::string_view cert_sct) {
   cert_sct_ = std::string(cert_sct);
 }
 
@@ -439,7 +439,7 @@
   // the STK can be validated by the server.
   const CryptoHandshakeMessage* scfg = cached->GetServerConfig();
   if (scfg != nullptr) {
-    quiche::QuicheStringPiece scid;
+    absl::string_view scid;
     if (scfg->GetStringPiece(kSCID, &scid)) {
       out->SetStringPiece(kSCID, scid);
     }
@@ -455,8 +455,8 @@
 
   char proof_nonce[32];
   rand->RandBytes(proof_nonce, QUICHE_ARRAYSIZE(proof_nonce));
-  out->SetStringPiece(kNONP, quiche::QuicheStringPiece(
-                                 proof_nonce, QUICHE_ARRAYSIZE(proof_nonce)));
+  out->SetStringPiece(
+      kNONP, absl::string_view(proof_nonce, QUICHE_ARRAYSIZE(proof_nonce)));
 
   out->SetVector(kPDMD, QuicTagVector{kX509});
 
@@ -513,7 +513,7 @@
     return QUIC_CRYPTO_INTERNAL_ERROR;
   }
 
-  quiche::QuicheStringPiece scid;
+  absl::string_view scid;
   if (!scfg->GetStringPiece(kSCID, &scid)) {
     *error_details = "SCFG missing SCID";
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
@@ -545,14 +545,14 @@
   out->SetVector(kAEAD, QuicTagVector{out_params->aead});
   out->SetVector(kKEXS, QuicTagVector{out_params->key_exchange});
 
-  quiche::QuicheStringPiece public_value;
+  absl::string_view public_value;
   if (scfg->GetNthValue24(kPUBS, key_exchange_index, &public_value) !=
       QUIC_NO_ERROR) {
     *error_details = "Missing public value";
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
   }
 
-  quiche::QuicheStringPiece orbit;
+  absl::string_view orbit;
   if (!scfg->GetStringPiece(kORBT, &orbit) || orbit.size() != kOrbitSize) {
     *error_details = "SCFG missing OBIT";
     return QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND;
@@ -635,13 +635,13 @@
     const CryptoHandshakeMessage& message,
     QuicWallTime now,
     QuicTransportVersion /*version*/,
-    quiche::QuicheStringPiece chlo_hash,
+    absl::string_view chlo_hash,
     const std::vector<std::string>& cached_certs,
     CachedState* cached,
     std::string* error_details) {
   DCHECK(error_details != nullptr);
 
-  quiche::QuicheStringPiece scfg;
+  absl::string_view scfg;
   if (!message.GetStringPiece(kSCFG, &scfg)) {
     *error_details = "Missing SCFG";
     return QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND;
@@ -666,12 +666,12 @@
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
   }
 
-  quiche::QuicheStringPiece token;
+  absl::string_view token;
   if (message.GetStringPiece(kSourceAddressTokenTag, &token)) {
     cached->set_source_address_token(token);
   }
 
-  quiche::QuicheStringPiece proof, cert_bytes, cert_sct;
+  absl::string_view proof, cert_bytes, cert_sct;
   bool has_proof = message.GetStringPiece(kPROF, &proof);
   bool has_cert = message.GetStringPiece(kCertificateTag, &cert_bytes);
   if (has_proof && has_cert) {
@@ -707,7 +707,7 @@
     const CryptoHandshakeMessage& rej,
     QuicWallTime now,
     const QuicTransportVersion version,
-    quiche::QuicheStringPiece chlo_hash,
+    absl::string_view chlo_hash,
     CachedState* cached,
     QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
     std::string* error_details) {
@@ -725,7 +725,7 @@
     return error;
   }
 
-  quiche::QuicheStringPiece nonce;
+  absl::string_view nonce;
   if (rej.GetStringPiece(kServerNonceTag, &nonce)) {
     out_params->server_nonce = std::string(nonce);
   }
@@ -750,12 +750,12 @@
   }
 
   // Learn about updated source address tokens.
-  quiche::QuicheStringPiece token;
+  absl::string_view token;
   if (server_hello.GetStringPiece(kSourceAddressTokenTag, &token)) {
     cached->set_source_address_token(token);
   }
 
-  quiche::QuicheStringPiece shlo_nonce;
+  absl::string_view shlo_nonce;
   if (!server_hello.GetStringPiece(kServerNonceTag, &shlo_nonce)) {
     *error_details = "server hello missing server nonce";
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
@@ -764,7 +764,7 @@
   // TODO(agl):
   //   learn about updated SCFGs.
 
-  quiche::QuicheStringPiece public_value;
+  absl::string_view public_value;
   if (!server_hello.GetStringPiece(kPUBS, &public_value)) {
     *error_details = "server hello missing forward secure public value";
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
@@ -800,7 +800,7 @@
     const CryptoHandshakeMessage& server_config_update,
     QuicWallTime now,
     const QuicTransportVersion version,
-    quiche::QuicheStringPiece chlo_hash,
+    absl::string_view chlo_hash,
     CachedState* cached,
     QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
     std::string* error_details) {
diff --git a/quic/core/crypto/quic_crypto_client_config.h b/quic/core/crypto/quic_crypto_client_config.h
index 701b7ff..913ddf9 100644
--- a/quic/core/crypto/quic_crypto_client_config.h
+++ b/quic/core/crypto/quic_crypto_client_config.h
@@ -11,6 +11,7 @@
 #include <string>
 #include <vector>
 
+#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"
@@ -21,7 +22,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_server_id.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_reference_counted.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -131,7 +131,7 @@
     // SetServerConfig checks that |server_config| parses correctly and stores
     // it in |server_config_|. |now| is used to judge whether |server_config|
     // has expired.
-    ServerConfigState SetServerConfig(quiche::QuicheStringPiece server_config,
+    ServerConfigState SetServerConfig(absl::string_view server_config,
                                       QuicWallTime now,
                                       QuicWallTime expiry_time,
                                       std::string* error_details);
@@ -141,9 +141,9 @@
 
     // SetProof stores a cert chain, cert signed timestamp and signature.
     void SetProof(const std::vector<std::string>& certs,
-                  quiche::QuicheStringPiece cert_sct,
-                  quiche::QuicheStringPiece chlo_hash,
-                  quiche::QuicheStringPiece signature);
+                  absl::string_view cert_sct,
+                  absl::string_view chlo_hash,
+                  absl::string_view signature);
 
     // Clears all the data.
     void Clear();
@@ -171,9 +171,9 @@
     uint64_t generation_counter() const;
     const ProofVerifyDetails* proof_verify_details() const;
 
-    void set_source_address_token(quiche::QuicheStringPiece token);
+    void set_source_address_token(absl::string_view token);
 
-    void set_cert_sct(quiche::QuicheStringPiece cert_sct);
+    void set_cert_sct(absl::string_view cert_sct);
 
     // Adds the servernonce to the queue of server nonces.
     void add_server_nonce(const std::string& server_nonce);
@@ -198,12 +198,12 @@
 
     // Initializes this cached state based on the arguments provided.
     // Returns false if there is a problem parsing the server config.
-    bool Initialize(quiche::QuicheStringPiece server_config,
-                    quiche::QuicheStringPiece source_address_token,
+    bool Initialize(absl::string_view server_config,
+                    absl::string_view source_address_token,
                     const std::vector<std::string>& certs,
                     const std::string& cert_sct,
-                    quiche::QuicheStringPiece chlo_hash,
-                    quiche::QuicheStringPiece signature,
+                    absl::string_view chlo_hash,
+                    absl::string_view signature,
                     QuicWallTime now,
                     QuicWallTime expiration_time);
 
@@ -311,7 +311,7 @@
       const CryptoHandshakeMessage& rej,
       QuicWallTime now,
       QuicTransportVersion version,
-      quiche::QuicheStringPiece chlo_hash,
+      absl::string_view chlo_hash,
       CachedState* cached,
       QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
       std::string* error_details);
@@ -343,7 +343,7 @@
       const CryptoHandshakeMessage& server_update,
       QuicWallTime now,
       const QuicTransportVersion version,
-      quiche::QuicheStringPiece chlo_hash,
+      absl::string_view chlo_hash,
       CachedState* cached,
       QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> out_params,
       std::string* error_details);
@@ -380,7 +380,7 @@
   void set_alpn(const std::string& alpn) { alpn_ = alpn; }
 
   // Saves the pre-shared key used during the handshake.
-  void set_pre_shared_key(quiche::QuicheStringPiece psk) {
+  void set_pre_shared_key(absl::string_view psk) {
     pre_shared_key_ = std::string(psk);
   }
 
@@ -407,7 +407,7 @@
       const CryptoHandshakeMessage& message,
       QuicWallTime now,
       QuicTransportVersion version,
-      quiche::QuicheStringPiece chlo_hash,
+      absl::string_view chlo_hash,
       const std::vector<std::string>& cached_certs,
       CachedState* cached,
       std::string* error_details);
diff --git a/quic/core/crypto/quic_crypto_client_config_test.cc b/quic/core/crypto/quic_crypto_client_config_test.cc
index 88b3eb6..d7625cd 100644
--- a/quic/core/crypto/quic_crypto_client_config_test.cc
+++ b/quic/core/crypto/quic_crypto_client_config_test.cc
@@ -6,6 +6,7 @@
 
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/proof_verifier.h"
 #include "net/third_party/quiche/src/quic/core/quic_server_id.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
@@ -15,7 +16,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.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"
 
 using testing::StartsWith;
 
@@ -149,13 +149,13 @@
   QuicVersionLabel cver;
   EXPECT_THAT(msg.GetVersionLabel(kVER, &cver), IsQuicNoError());
   EXPECT_EQ(CreateQuicVersionLabel(QuicVersionMax()), cver);
-  quiche::QuicheStringPiece proof_nonce;
+  absl::string_view proof_nonce;
   EXPECT_TRUE(msg.GetStringPiece(kNONP, &proof_nonce));
   EXPECT_EQ(std::string(32, 'r'), proof_nonce);
-  quiche::QuicheStringPiece user_agent_id;
+  absl::string_view user_agent_id;
   EXPECT_TRUE(msg.GetStringPiece(kUAID, &user_agent_id));
   EXPECT_EQ("quic-tester", user_agent_id);
-  quiche::QuicheStringPiece alpn;
+  absl::string_view alpn;
   EXPECT_TRUE(msg.GetStringPiece(kALPN, &alpn));
   EXPECT_EQ("hq", alpn);
   EXPECT_EQ(msg.minimum_size(), 1u);
@@ -203,7 +203,7 @@
   QuicTag pdmd;
   EXPECT_THAT(msg.GetUint32(kPDMD, &pdmd), IsQuicNoError());
   EXPECT_EQ(kX509, pdmd);
-  quiche::QuicheStringPiece scid;
+  absl::string_view scid;
   EXPECT_FALSE(msg.GetStringPiece(kSCID, &scid));
 }
 
@@ -229,7 +229,7 @@
   config.FillInchoateClientHello(server_id, QuicVersionMax(), &state, &rand,
                                  /* demand_x509_proof= */ true, params, &msg);
 
-  quiche::QuicheStringPiece scid;
+  absl::string_view scid;
   EXPECT_TRUE(msg.GetStringPiece(kSCID, &scid));
   EXPECT_EQ("12345678", scid);
 }
@@ -255,7 +255,7 @@
   config.FillInchoateClientHello(server_id, QuicVersionMax(), &state, &rand,
                                  /* demand_x509_proof= */ true, params, &msg);
 
-  quiche::QuicheStringPiece scid;
+  absl::string_view scid;
   EXPECT_TRUE(msg.GetStringPiece(kSCID, &scid));
   EXPECT_EQ("12345678", scid);
 }
diff --git a/quic/core/crypto/quic_crypto_server_config.cc b/quic/core/crypto/quic_crypto_server_config.cc
index ec535cf..3e558d0 100644
--- a/quic/core/crypto/quic_crypto_server_config.cc
+++ b/quic/core/crypto/quic_crypto_server_config.cc
@@ -10,6 +10,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/sha.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 #include "net/third_party/quiche/src/quic/core/crypto/aes_128_gcm_12_decrypter.h"
@@ -48,7 +49,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_reference_counted.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_testvalue.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 {
@@ -64,11 +64,11 @@
 const int kMaxTokenAddresses = 4;
 
 std::string DeriveSourceAddressTokenKey(
-    quiche::QuicheStringPiece source_address_token_secret) {
-  QuicHKDF hkdf(
-      source_address_token_secret, quiche::QuicheStringPiece() /* no salt */,
-      "QUIC source address token key", CryptoSecretBoxer::GetKeySize(),
-      0 /* no fixed IV needed */, 0 /* no subkey secret */);
+    absl::string_view source_address_token_secret) {
+  QuicHKDF hkdf(source_address_token_secret, absl::string_view() /* no salt */,
+                "QUIC source address token key",
+                CryptoSecretBoxer::GetKeySize(), 0 /* no fixed IV needed */,
+                0 /* no subkey secret */);
   return std::string(hkdf.server_write_key());
 }
 
@@ -82,7 +82,7 @@
       std::string /*server_config_id*/,
       bool /* is_fallback */,
       QuicTag type,
-      quiche::QuicheStringPiece private_key) override {
+      absl::string_view private_key) override {
     if (private_key.empty()) {
       QUIC_LOG(WARNING) << "Server config contains key exchange method without "
                            "corresponding private key of type "
@@ -232,7 +232,7 @@
 }
 
 QuicCryptoServerConfig::QuicCryptoServerConfig(
-    quiche::QuicheStringPiece source_address_token_secret,
+    absl::string_view source_address_token_secret,
     QuicRandom* server_nonce_entropy,
     std::unique_ptr<ProofSource> proof_source,
     std::unique_ptr<KeyExchangeSource> key_exchange_source)
@@ -281,8 +281,7 @@
       Curve25519KeyExchange::NewPrivateKey(rand);
   std::unique_ptr<Curve25519KeyExchange> curve25519 =
       Curve25519KeyExchange::New(curve25519_private_key);
-  quiche::QuicheStringPiece curve25519_public_value =
-      curve25519->public_value();
+  absl::string_view curve25519_public_value = curve25519->public_value();
 
   std::string encoded_public_values;
   // First three bytes encode the length of the public value.
@@ -301,7 +300,7 @@
     p256_private_key = P256KeyExchange::NewPrivateKey();
     std::unique_ptr<P256KeyExchange> p256(
         P256KeyExchange::New(p256_private_key));
-    quiche::QuicheStringPiece p256_public_value = p256->public_value();
+    absl::string_view p256_public_value = p256->public_value();
 
     DCHECK_LT(p256_public_value.size(), (1U << 24));
     encoded_public_values.push_back(
@@ -340,8 +339,8 @@
     DCHECK(options.orbit.empty());
     rand->RandBytes(orbit_bytes, sizeof(orbit_bytes));
   }
-  msg.SetStringPiece(
-      kORBT, quiche::QuicheStringPiece(orbit_bytes, sizeof(orbit_bytes)));
+  msg.SetStringPiece(kORBT,
+                     absl::string_view(orbit_bytes, sizeof(orbit_bytes)));
 
   if (options.channel_id_enabled) {
     msg.SetVector(kPDMD, QuicTagVector{kCHID});
@@ -358,9 +357,9 @@
            serialized->length(), scid_bytes);
     // The SCID is a truncated SHA-256 digest.
     static_assert(16 <= SHA256_DIGEST_LENGTH, "SCID length too high.");
-    msg.SetStringPiece(kSCID,
-                       quiche::QuicheStringPiece(
-                           reinterpret_cast<const char*>(scid_bytes), 16));
+    msg.SetStringPiece(
+        kSCID,
+        absl::string_view(reinterpret_cast<const char*>(scid_bytes), 16));
   } else {
     msg.SetStringPiece(kSCID, options.id);
   }
@@ -538,7 +537,7 @@
       new ValidateClientHelloResultCallback::Result(
           client_hello, client_address.host(), now));
 
-  quiche::QuicheStringPiece requested_scid;
+  absl::string_view requested_scid;
   client_hello.GetStringPiece(kSCID, &requested_scid);
   Configs configs;
   if (!GetCurrentConfigs(now, requested_scid,
@@ -594,7 +593,7 @@
       std::unique_ptr<ProofSource::Details> proof_source_details,
       QuicTag key_exchange_type,
       std::unique_ptr<CryptoHandshakeMessage> out,
-      quiche::QuicheStringPiece public_value,
+      absl::string_view public_value,
       std::unique_ptr<ProcessClientHelloContext> context,
       const Configs& configs)
       : config_(config),
@@ -687,7 +686,7 @@
     return;
   }
 
-  quiche::QuicheStringPiece requested_scid;
+  absl::string_view requested_scid;
   context->client_hello().GetStringPiece(kSCID, &requested_scid);
   Configs configs;
   if (!GetCurrentConfigs(context->clock()->WallNow(), requested_scid,
@@ -748,7 +747,7 @@
 
   auto out_diversification_nonce = std::make_unique<DiversificationNonce>();
 
-  quiche::QuicheStringPiece cert_sct;
+  absl::string_view cert_sct;
   if (context->client_hello().GetStringPiece(kCertificateSCTTag, &cert_sct) &&
       cert_sct.empty()) {
     context->params()->sct_supported_by_client = true;
@@ -791,7 +790,7 @@
     return;
   }
 
-  quiche::QuicheStringPiece public_value;
+  absl::string_view public_value;
   if (!context->client_hello().GetStringPiece(kPUBS, &public_value)) {
     context->Fail(QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER,
                   "Missing public value");
@@ -819,7 +818,7 @@
     std::unique_ptr<ProofSource::Details> proof_source_details,
     QuicTag key_exchange_type,
     std::unique_ptr<CryptoHandshakeMessage> out,
-    quiche::QuicheStringPiece public_value,
+    absl::string_view public_value,
     std::unique_ptr<ProcessClientHelloContext> context,
     const Configs& configs) const {
   QUIC_BUG_IF(!QuicUtils::IsConnectionIdValidForVersion(
@@ -868,7 +867,7 @@
   }
   hkdf_suffix.append(context->signed_config()->chain->certs.at(0));
 
-  quiche::QuicheStringPiece cetv_ciphertext;
+  absl::string_view cetv_ciphertext;
   if (configs.requested->channel_id_enabled &&
       context->client_hello().GetStringPiece(kCETV, &cetv_ciphertext)) {
     CryptoHandshakeMessage client_hello_copy(context->client_hello());
@@ -901,22 +900,21 @@
     char plaintext[kMaxOutgoingPacketSize];
     size_t plaintext_length = 0;
     const bool success = crypters.decrypter->DecryptPacket(
-        0 /* packet number */,
-        quiche::QuicheStringPiece() /* associated data */, cetv_ciphertext,
-        plaintext, &plaintext_length, kMaxOutgoingPacketSize);
+        0 /* packet number */, absl::string_view() /* associated data */,
+        cetv_ciphertext, plaintext, &plaintext_length, kMaxOutgoingPacketSize);
     if (!success) {
       context->Fail(QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER,
                     "CETV decryption failure");
       return;
     }
     std::unique_ptr<CryptoHandshakeMessage> cetv(CryptoFramer::ParseMessage(
-        quiche::QuicheStringPiece(plaintext, plaintext_length)));
+        absl::string_view(plaintext, plaintext_length)));
     if (!cetv) {
       context->Fail(QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER, "CETV parse error");
       return;
     }
 
-    quiche::QuicheStringPiece key, signature;
+    absl::string_view key, signature;
     if (cetv->GetStringPiece(kCIDK, &key) &&
         cetv->GetStringPiece(kCIDS, &signature)) {
       if (!ChannelIDVerifier::Verify(key, hkdf_input, signature)) {
@@ -1055,7 +1053,7 @@
 
 QuicReferenceCountedPointer<QuicCryptoServerConfig::Config>
 QuicCryptoServerConfig::GetConfigWithScid(
-    quiche::QuicheStringPiece requested_scid) const {
+    absl::string_view requested_scid) const {
   configs_lock_.AssertReaderHeld();
 
   if (!requested_scid.empty()) {
@@ -1072,7 +1070,7 @@
 
 bool QuicCryptoServerConfig::GetCurrentConfigs(
     const QuicWallTime& now,
-    quiche::QuicheStringPiece requested_scid,
+    absl::string_view requested_scid,
     QuicReferenceCountedPointer<Config> old_primary_config,
     Configs* configs) const {
   QuicReaderMutexLock locked(&configs_lock_);
@@ -1230,7 +1228,7 @@
 
   HandshakeFailureReason source_address_token_error = MAX_FAILURE_REASON;
   if (validate_source_address_token_) {
-    quiche::QuicheStringPiece srct;
+    absl::string_view srct;
     if (client_hello.GetStringPiece(kSourceAddressTokenTag, &srct)) {
       Config& config =
           configs.requested != nullptr ? *configs.requested : *configs.primary;
@@ -1253,7 +1251,7 @@
   }
 
   if (!configs.requested) {
-    quiche::QuicheStringPiece requested_scid;
+    absl::string_view requested_scid;
     if (client_hello.GetStringPiece(kSCID, &requested_scid)) {
       info->reject_reasons.push_back(SERVER_CONFIG_UNKNOWN_CONFIG_FAILURE);
     } else {
@@ -1308,7 +1306,7 @@
 
 void QuicCryptoServerConfig::BuildServerConfigUpdateMessage(
     QuicTransportVersion version,
-    quiche::QuicheStringPiece chlo_hash,
+    absl::string_view chlo_hash,
     const SourceAddressTokens& previous_source_address_tokens,
     const QuicSocketAddress& server_address,
     const QuicSocketAddress& client_address,
@@ -1457,13 +1455,13 @@
     return;
   }
 
-  quiche::QuicheStringPiece client_common_set_hashes;
+  absl::string_view client_common_set_hashes;
   if (context.client_hello().GetStringPiece(kCCS, &client_common_set_hashes)) {
     context.params()->client_common_set_hashes =
         std::string(client_common_set_hashes);
   }
 
-  quiche::QuicheStringPiece client_cached_cert_hashes;
+  absl::string_view client_cached_cert_hashes;
   if (context.client_hello().GetStringPiece(kCCRT,
                                             &client_cached_cert_hashes)) {
     context.params()->client_cached_cert_hashes =
@@ -1511,7 +1509,7 @@
         // This is for debugging b/28342827.
         const std::vector<std::string>& certs =
             context.signed_config()->chain->certs;
-        quiche::QuicheStringPiece ca_subject;
+        absl::string_view ca_subject;
         if (!certs.empty()) {
           QuicCertUtils::ExtractSubjectNameFromDERCert(certs[0], &ca_subject);
         }
@@ -1578,7 +1576,7 @@
 
   config->priority = protobuf.priority();
 
-  quiche::QuicheStringPiece scid;
+  absl::string_view scid;
   if (!msg->GetStringPiece(kSCID, &scid)) {
     QUIC_LOG(WARNING) << "Server config message is missing SCID";
     return nullptr;
@@ -1596,7 +1594,7 @@
     return nullptr;
   }
 
-  quiche::QuicheStringPiece orbit;
+  absl::string_view orbit;
   if (!msg->GetStringPiece(kORBT, &orbit)) {
     QUIC_LOG(WARNING) << "Server config message is missing ORBT";
     return nullptr;
@@ -1767,10 +1765,10 @@
 
 HandshakeFailureReason QuicCryptoServerConfig::ParseSourceAddressToken(
     const Config& config,
-    quiche::QuicheStringPiece token,
+    absl::string_view token,
     SourceAddressTokens* tokens) const {
   std::string storage;
-  quiche::QuicheStringPiece plaintext;
+  absl::string_view plaintext;
   if (!config.source_address_token_boxer->Unbox(token, &storage, &plaintext)) {
     return SOURCE_ADDRESS_TOKEN_DECRYPTION_FAILURE;
   }
@@ -1860,8 +1858,8 @@
                   sizeof(server_nonce) - sizeof(timestamp));
 
   return server_nonce_boxer_.Box(
-      rand, quiche::QuicheStringPiece(reinterpret_cast<char*>(server_nonce),
-                                      sizeof(server_nonce)));
+      rand, absl::string_view(reinterpret_cast<char*>(server_nonce),
+                              sizeof(server_nonce)));
 }
 
 bool QuicCryptoServerConfig::ValidateExpectedLeafCertificate(
diff --git a/quic/core/crypto/quic_crypto_server_config.h b/quic/core/crypto/quic_crypto_server_config.h
index 9f2db60..bd3111b 100644
--- a/quic/core/crypto/quic_crypto_server_config.h
+++ b/quic/core/crypto/quic_crypto_server_config.h
@@ -12,6 +12,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/base.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"
@@ -30,7 +31,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_mutex.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_reference_counted.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 {
 
@@ -54,10 +54,10 @@
 
   // Outputs from EvaluateClientHello.
   bool valid_source_address_token;
-  quiche::QuicheStringPiece sni;
-  quiche::QuicheStringPiece client_nonce;
-  quiche::QuicheStringPiece server_nonce;
-  quiche::QuicheStringPiece user_agent_id;
+  absl::string_view sni;
+  absl::string_view client_nonce;
+  absl::string_view server_nonce;
+  absl::string_view user_agent_id;
   SourceAddressTokens source_address_tokens;
 
   // Errors from EvaluateClientHello.
@@ -171,7 +171,7 @@
       std::string server_config_id,
       bool is_fallback,
       QuicTag type,
-      quiche::QuicheStringPiece private_key) = 0;
+      absl::string_view private_key) = 0;
 };
 
 // QuicCryptoServerConfig contains the crypto configuration of a QUIC server.
@@ -215,7 +215,7 @@
   // |proof_source|: provides certificate chains and signatures.
   // |key_exchange_source|: provides key-exchange functionality.
   QuicCryptoServerConfig(
-      quiche::QuicheStringPiece source_address_token_secret,
+      absl::string_view source_address_token_secret,
       QuicRandom* server_nonce_entropy,
       std::unique_ptr<ProofSource> proof_source,
       std::unique_ptr<KeyExchangeSource> key_exchange_source);
@@ -357,7 +357,7 @@
   // |cached_network_params| is optional, and can be nullptr.
   void BuildServerConfigUpdateMessage(
       QuicTransportVersion version,
-      quiche::QuicheStringPiece chlo_hash,
+      absl::string_view chlo_hash,
       const SourceAddressTokens& previous_source_address_tokens,
       const QuicSocketAddress& server_address,
       const QuicSocketAddress& client_address,
@@ -434,7 +434,7 @@
 
   // Pre-shared key used during the handshake.
   const std::string& pre_shared_key() const { return pre_shared_key_; }
-  void set_pre_shared_key(quiche::QuicheStringPiece psk) {
+  void set_pre_shared_key(absl::string_view psk) {
     pre_shared_key_ = std::string(psk);
   }
 
@@ -516,7 +516,7 @@
 
   // Get a ref to the config with a given server config id.
   QuicReferenceCountedPointer<Config> GetConfigWithScid(
-      quiche::QuicheStringPiece requested_scid) const
+      absl::string_view requested_scid) const
       QUIC_SHARED_LOCKS_REQUIRED(configs_lock_);
 
   // A snapshot of the configs associated with an in-progress handshake.
@@ -533,7 +533,7 @@
   // Returns true if any configs are loaded.  If false is returned, |configs| is
   // not modified.
   bool GetCurrentConfigs(const QuicWallTime& now,
-                         quiche::QuicheStringPiece requested_scid,
+                         absl::string_view requested_scid,
                          QuicReferenceCountedPointer<Config> old_primary_config,
                          Configs* configs) const;
 
@@ -687,7 +687,7 @@
       std::unique_ptr<ProofSource::Details> proof_source_details,
       QuicTag key_exchange_type,
       std::unique_ptr<CryptoHandshakeMessage> out,
-      quiche::QuicheStringPiece public_value,
+      absl::string_view public_value,
       std::unique_ptr<ProcessClientHelloContext> context,
       const Configs& configs) const;
 
@@ -761,7 +761,7 @@
   // failure.
   HandshakeFailureReason ParseSourceAddressToken(
       const Config& config,
-      quiche::QuicheStringPiece token,
+      absl::string_view token,
       SourceAddressTokens* tokens) const;
 
   // ValidateSourceAddressTokens returns HANDSHAKE_OK if the source address
diff --git a/quic/core/crypto/quic_crypto_server_config_test.cc b/quic/core/crypto/quic_crypto_server_config_test.cc
index 6f0c047..b91113d 100644
--- a/quic/core/crypto/quic_crypto_server_config_test.cc
+++ b/quic/core/crypto/quic_crypto_server_config_test.cc
@@ -9,6 +9,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/cert_compressor.h"
 #include "net/third_party/quiche/src/quic/core/crypto/chacha20_poly1305_encrypter.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake_message.h"
@@ -23,7 +24,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/mock_clock.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"
 #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 namespace quic {
@@ -142,7 +142,7 @@
   static const uint64_t set_hash = 42;
   std::unique_ptr<CommonCertSets> common_sets(
       crypto_test_utils::MockCommonCertSets(certs[0], set_hash, 1));
-  quiche::QuicheStringPiece different_common_certs(
+  absl::string_view different_common_certs(
       reinterpret_cast<const char*>(&set_hash), sizeof(set_hash));
   std::string compressed3 = QuicCryptoServerConfigPeer::CompressChain(
       &compressed_certs_cache, chain, std::string(different_common_certs),
@@ -193,16 +193,15 @@
                                        clock_.WallNow(), cached_network_params);
   }
 
-  HandshakeFailureReason ValidateSourceAddressTokens(
-      std::string config_id,
-      quiche::QuicheStringPiece srct,
-      const QuicIpAddress& ip) {
+  HandshakeFailureReason ValidateSourceAddressTokens(std::string config_id,
+                                                     absl::string_view srct,
+                                                     const QuicIpAddress& ip) {
     return ValidateSourceAddressTokens(config_id, srct, ip, nullptr);
   }
 
   HandshakeFailureReason ValidateSourceAddressTokens(
       std::string config_id,
-      quiche::QuicheStringPiece srct,
+      absl::string_view srct,
       const QuicIpAddress& ip,
       CachedNetworkParameters* cached_network_params) {
     return peer_.ValidateSourceAddressTokens(
diff --git a/quic/core/crypto/quic_decrypter.cc b/quic/core/crypto/quic_decrypter.cc
index c424901..29e1e18 100644
--- a/quic/core/crypto/quic_decrypter.cc
+++ b/quic/core/crypto/quic_decrypter.cc
@@ -7,6 +7,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/tls1.h"
 #include "net/third_party/quiche/src/quic/core/crypto/aes_128_gcm_12_decrypter.h"
 #include "net/third_party/quiche/src/quic/core/crypto/aes_128_gcm_decrypter.h"
@@ -18,7 +19,6 @@
 #include "net/third_party/quiche/src/quic/core/crypto/quic_hkdf.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -62,16 +62,15 @@
 }
 
 // static
-void QuicDecrypter::DiversifyPreliminaryKey(
-    quiche::QuicheStringPiece preliminary_key,
-    quiche::QuicheStringPiece nonce_prefix,
-    const DiversificationNonce& nonce,
-    size_t key_size,
-    size_t nonce_prefix_size,
-    std::string* out_key,
-    std::string* out_nonce_prefix) {
+void QuicDecrypter::DiversifyPreliminaryKey(absl::string_view preliminary_key,
+                                            absl::string_view nonce_prefix,
+                                            const DiversificationNonce& nonce,
+                                            size_t key_size,
+                                            size_t nonce_prefix_size,
+                                            std::string* out_key,
+                                            std::string* out_nonce_prefix) {
   QuicHKDF hkdf((std::string(preliminary_key)) + (std::string(nonce_prefix)),
-                quiche::QuicheStringPiece(nonce.data(), nonce.size()),
+                absl::string_view(nonce.data(), nonce.size()),
                 "QUIC key diversification", 0, key_size, 0, nonce_prefix_size,
                 0);
   *out_key = std::string(hkdf.server_write_key());
diff --git a/quic/core/crypto/quic_decrypter.h b/quic/core/crypto/quic_decrypter.h
index 7f4d93d..21712f6 100644
--- a/quic/core/crypto/quic_decrypter.h
+++ b/quic/core/crypto/quic_decrypter.h
@@ -10,11 +10,11 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_crypter.h"
 #include "net/third_party/quiche/src/quic/core/quic_data_reader.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.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 {
 
@@ -38,7 +38,7 @@
   //
   // If this function is called, neither |SetKey| nor |SetNoncePrefix| may be
   // called.
-  virtual bool SetPreliminaryKey(quiche::QuicheStringPiece key) = 0;
+  virtual bool SetPreliminaryKey(absl::string_view key) = 0;
 
   // SetDiversificationNonce uses |nonce| to derive final keys based on the
   // input keying material given by calling |SetPreliminaryKey|.
@@ -56,8 +56,8 @@
   // TODO(wtc): add a way for DecryptPacket to report decryption failure due
   // to non-authentic inputs, as opposed to other reasons for failure.
   virtual 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) = 0;
@@ -74,11 +74,11 @@
   virtual uint32_t cipher_id() const = 0;
 
   // For use by unit tests only.
-  virtual quiche::QuicheStringPiece GetKey() const = 0;
-  virtual quiche::QuicheStringPiece GetNoncePrefix() const = 0;
+  virtual absl::string_view GetKey() const = 0;
+  virtual absl::string_view GetNoncePrefix() const = 0;
 
-  static void DiversifyPreliminaryKey(quiche::QuicheStringPiece preliminary_key,
-                                      quiche::QuicheStringPiece nonce_prefix,
+  static void DiversifyPreliminaryKey(absl::string_view preliminary_key,
+                                      absl::string_view nonce_prefix,
                                       const DiversificationNonce& nonce,
                                       size_t key_size,
                                       size_t nonce_prefix_size,
diff --git a/quic/core/crypto/quic_encrypter.h b/quic/core/crypto/quic_encrypter.h
index 6fe552d..89d7fed 100644
--- a/quic/core/crypto/quic_encrypter.h
+++ b/quic/core/crypto/quic_encrypter.h
@@ -8,10 +8,10 @@
 #include <cstddef>
 #include <memory>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_crypter.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.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,8 @@
   // |associated_data|. If |output| overlaps with |plaintext| then
   // |plaintext| must be <= |output|.
   virtual 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) = 0;
@@ -47,7 +47,7 @@
   // success, the mask will be at least 5 bytes long; on failure the string will
   // be empty.
   virtual std::string GenerateHeaderProtectionMask(
-      quiche::QuicheStringPiece sample) = 0;
+      absl::string_view sample) = 0;
 
   // Returns the maximum length of plaintext that can be encrypted
   // to ciphertext no larger than |ciphertext_size|.
@@ -58,8 +58,8 @@
   virtual size_t GetCiphertextSize(size_t plaintext_size) const = 0;
 
   // For use by unit tests only.
-  virtual quiche::QuicheStringPiece GetKey() const = 0;
-  virtual quiche::QuicheStringPiece GetNoncePrefix() const = 0;
+  virtual absl::string_view GetKey() const = 0;
+  virtual absl::string_view GetNoncePrefix() const = 0;
 };
 
 }  // namespace quic
diff --git a/quic/core/crypto/quic_hkdf.cc b/quic/core/crypto/quic_hkdf.cc
index 28cf4a9..59c3eb0 100644
--- a/quic/core/crypto/quic_hkdf.cc
+++ b/quic/core/crypto/quic_hkdf.cc
@@ -6,19 +6,19 @@
 
 #include <memory>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/digest.h"
 #include "third_party/boringssl/src/include/openssl/hkdf.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
 const size_t kSHA256HashLength = 32;
 const size_t kMaxKeyMaterialSize = kSHA256HashLength * 256;
 
-QuicHKDF::QuicHKDF(quiche::QuicheStringPiece secret,
-                   quiche::QuicheStringPiece salt,
-                   quiche::QuicheStringPiece info,
+QuicHKDF::QuicHKDF(absl::string_view secret,
+                   absl::string_view salt,
+                   absl::string_view info,
                    size_t key_bytes_to_generate,
                    size_t iv_bytes_to_generate,
                    size_t subkey_secret_bytes_to_generate)
@@ -31,9 +31,9 @@
                iv_bytes_to_generate,
                subkey_secret_bytes_to_generate) {}
 
-QuicHKDF::QuicHKDF(quiche::QuicheStringPiece secret,
-                   quiche::QuicheStringPiece salt,
-                   quiche::QuicheStringPiece info,
+QuicHKDF::QuicHKDF(absl::string_view secret,
+                   absl::string_view salt,
+                   absl::string_view info,
                    size_t client_key_bytes_to_generate,
                    size_t server_key_bytes_to_generate,
                    size_t client_iv_bytes_to_generate,
@@ -60,44 +60,44 @@
 
   size_t j = 0;
   if (client_key_bytes_to_generate) {
-    client_write_key_ = quiche::QuicheStringPiece(
-        reinterpret_cast<char*>(&output_[j]), client_key_bytes_to_generate);
+    client_write_key_ = absl::string_view(reinterpret_cast<char*>(&output_[j]),
+                                          client_key_bytes_to_generate);
     j += client_key_bytes_to_generate;
   }
 
   if (server_key_bytes_to_generate) {
-    server_write_key_ = quiche::QuicheStringPiece(
-        reinterpret_cast<char*>(&output_[j]), server_key_bytes_to_generate);
+    server_write_key_ = absl::string_view(reinterpret_cast<char*>(&output_[j]),
+                                          server_key_bytes_to_generate);
     j += server_key_bytes_to_generate;
   }
 
   if (client_iv_bytes_to_generate) {
-    client_write_iv_ = quiche::QuicheStringPiece(
-        reinterpret_cast<char*>(&output_[j]), client_iv_bytes_to_generate);
+    client_write_iv_ = absl::string_view(reinterpret_cast<char*>(&output_[j]),
+                                         client_iv_bytes_to_generate);
     j += client_iv_bytes_to_generate;
   }
 
   if (server_iv_bytes_to_generate) {
-    server_write_iv_ = quiche::QuicheStringPiece(
-        reinterpret_cast<char*>(&output_[j]), server_iv_bytes_to_generate);
+    server_write_iv_ = absl::string_view(reinterpret_cast<char*>(&output_[j]),
+                                         server_iv_bytes_to_generate);
     j += server_iv_bytes_to_generate;
   }
 
   if (subkey_secret_bytes_to_generate) {
-    subkey_secret_ = quiche::QuicheStringPiece(
-        reinterpret_cast<char*>(&output_[j]), subkey_secret_bytes_to_generate);
+    subkey_secret_ = absl::string_view(reinterpret_cast<char*>(&output_[j]),
+                                       subkey_secret_bytes_to_generate);
     j += subkey_secret_bytes_to_generate;
   }
   // Repeat client and server key bytes for header protection keys.
   if (client_key_bytes_to_generate) {
-    client_hp_key_ = quiche::QuicheStringPiece(
-        reinterpret_cast<char*>(&output_[j]), client_key_bytes_to_generate);
+    client_hp_key_ = absl::string_view(reinterpret_cast<char*>(&output_[j]),
+                                       client_key_bytes_to_generate);
     j += client_key_bytes_to_generate;
   }
 
   if (server_key_bytes_to_generate) {
-    server_hp_key_ = quiche::QuicheStringPiece(
-        reinterpret_cast<char*>(&output_[j]), server_key_bytes_to_generate);
+    server_hp_key_ = absl::string_view(reinterpret_cast<char*>(&output_[j]),
+                                       server_key_bytes_to_generate);
     j += server_key_bytes_to_generate;
   }
 }
diff --git a/quic/core/crypto/quic_hkdf.h b/quic/core/crypto/quic_hkdf.h
index 2945173..63018b4 100644
--- a/quic/core/crypto/quic_hkdf.h
+++ b/quic/core/crypto/quic_hkdf.h
@@ -7,8 +7,8 @@
 
 #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 {
 
@@ -31,18 +31,18 @@
   // client and server.
   // |subkey_secret_bytes_to_generate|: the number of bytes of subkey secret to
   // generate, shared between client and server.
-  QuicHKDF(quiche::QuicheStringPiece secret,
-           quiche::QuicheStringPiece salt,
-           quiche::QuicheStringPiece info,
+  QuicHKDF(absl::string_view secret,
+           absl::string_view salt,
+           absl::string_view info,
            size_t key_bytes_to_generate,
            size_t iv_bytes_to_generate,
            size_t subkey_secret_bytes_to_generate);
 
   // An alternative constructor that allows the client and server key/IV
   // lengths to be different.
-  QuicHKDF(quiche::QuicheStringPiece secret,
-           quiche::QuicheStringPiece salt,
-           quiche::QuicheStringPiece info,
+  QuicHKDF(absl::string_view secret,
+           absl::string_view salt,
+           absl::string_view info,
            size_t client_key_bytes_to_generate,
            size_t server_key_bytes_to_generate,
            size_t client_iv_bytes_to_generate,
@@ -51,28 +51,24 @@
 
   ~QuicHKDF();
 
-  quiche::QuicheStringPiece client_write_key() const {
-    return client_write_key_;
-  }
-  quiche::QuicheStringPiece client_write_iv() const { return client_write_iv_; }
-  quiche::QuicheStringPiece server_write_key() const {
-    return server_write_key_;
-  }
-  quiche::QuicheStringPiece server_write_iv() const { return server_write_iv_; }
-  quiche::QuicheStringPiece subkey_secret() const { return subkey_secret_; }
-  quiche::QuicheStringPiece client_hp_key() const { return client_hp_key_; }
-  quiche::QuicheStringPiece server_hp_key() const { return server_hp_key_; }
+  absl::string_view client_write_key() const { return client_write_key_; }
+  absl::string_view client_write_iv() const { return client_write_iv_; }
+  absl::string_view server_write_key() const { return server_write_key_; }
+  absl::string_view server_write_iv() const { return server_write_iv_; }
+  absl::string_view subkey_secret() const { return subkey_secret_; }
+  absl::string_view client_hp_key() const { return client_hp_key_; }
+  absl::string_view server_hp_key() const { return server_hp_key_; }
 
  private:
   std::vector<uint8_t> output_;
 
-  quiche::QuicheStringPiece client_write_key_;
-  quiche::QuicheStringPiece server_write_key_;
-  quiche::QuicheStringPiece client_write_iv_;
-  quiche::QuicheStringPiece server_write_iv_;
-  quiche::QuicheStringPiece subkey_secret_;
-  quiche::QuicheStringPiece client_hp_key_;
-  quiche::QuicheStringPiece server_hp_key_;
+  absl::string_view client_write_key_;
+  absl::string_view server_write_key_;
+  absl::string_view client_write_iv_;
+  absl::string_view server_write_iv_;
+  absl::string_view subkey_secret_;
+  absl::string_view client_hp_key_;
+  absl::string_view server_hp_key_;
 };
 
 }  // namespace quic
diff --git a/quic/core/crypto/tls_connection.cc b/quic/core/crypto/tls_connection.cc
index 8e4d391..427474c 100644
--- a/quic/core/crypto/tls_connection.cc
+++ b/quic/core/crypto/tls_connection.cc
@@ -4,8 +4,8 @@
 
 #include "net/third_party/quiche/src/quic/core/crypto/tls_connection.h"
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -151,7 +151,7 @@
                                         size_t len) {
   ConnectionFromSsl(ssl)->delegate_->WriteMessage(
       QuicEncryptionLevel(level),
-      quiche::QuicheStringPiece(reinterpret_cast<const char*>(data), len));
+      absl::string_view(reinterpret_cast<const char*>(data), len));
   return 1;
 }
 
diff --git a/quic/core/crypto/tls_connection.h b/quic/core/crypto/tls_connection.h
index 15a4f4f..ef5ca58 100644
--- a/quic/core/crypto/tls_connection.h
+++ b/quic/core/crypto/tls_connection.h
@@ -7,9 +7,9 @@
 
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -53,7 +53,7 @@
     // the QUIC stack to write in a crypto frame. The data must be transmitted
     // at encryption level |level|.
     virtual void WriteMessage(EncryptionLevel level,
-                              quiche::QuicheStringPiece data) = 0;
+                              absl::string_view data) = 0;
 
     // FlushFlight is called to signal that the current flight of messages have
     // all been written (via calls to WriteMessage) and can be flushed to the
diff --git a/quic/core/crypto/tls_server_connection.cc b/quic/core/crypto/tls_server_connection.cc
index c821a38..1809c9e 100644
--- a/quic/core/crypto/tls_server_connection.cc
+++ b/quic/core/crypto/tls_server_connection.cc
@@ -4,10 +4,10 @@
 
 #include "net/third_party/quiche/src/quic/core/crypto/tls_server_connection.h"
 
+#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_source.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -82,7 +82,7 @@
                                                              size_t in_len) {
   return ConnectionFromSsl(ssl)->delegate_->PrivateKeySign(
       out, out_len, max_out, sig_alg,
-      quiche::QuicheStringPiece(reinterpret_cast<const char*>(in), in_len));
+      absl::string_view(reinterpret_cast<const char*>(in), in_len));
 }
 
 // static
@@ -116,7 +116,7 @@
                                            size_t in_len) {
   return ConnectionFromSsl(ssl)->delegate_->SessionTicketSeal(
       out, out_len, max_out_len,
-      quiche::QuicheStringPiece(reinterpret_cast<const char*>(in), in_len));
+      absl::string_view(reinterpret_cast<const char*>(in), in_len));
 }
 
 // static
@@ -129,7 +129,7 @@
     size_t in_len) {
   return ConnectionFromSsl(ssl)->delegate_->SessionTicketOpen(
       out, out_len, max_out_len,
-      quiche::QuicheStringPiece(reinterpret_cast<const char*>(in), in_len));
+      absl::string_view(reinterpret_cast<const char*>(in), in_len));
 }
 
 }  // namespace quic
diff --git a/quic/core/crypto/tls_server_connection.h b/quic/core/crypto/tls_server_connection.h
index 6da8114..954f830 100644
--- a/quic/core/crypto/tls_server_connection.h
+++ b/quic/core/crypto/tls_server_connection.h
@@ -5,9 +5,9 @@
 #ifndef QUICHE_QUIC_CORE_CRYPTO_TLS_SERVER_CONNECTION_H_
 #define QUICHE_QUIC_CORE_CRYPTO_TLS_SERVER_CONNECTION_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/quic/core/crypto/tls_connection.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -43,12 +43,11 @@
     // ssl_private_key_failure is returned. Otherwise, ssl_private_key_success
     // is returned with the signature put in |*out| and the length in
     // |*out_len|.
-    virtual ssl_private_key_result_t PrivateKeySign(
-        uint8_t* out,
-        size_t* out_len,
-        size_t max_out,
-        uint16_t sig_alg,
-        quiche::QuicheStringPiece in) = 0;
+    virtual 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) = 0;
 
     // When PrivateKeySign returns ssl_private_key_retry, PrivateKeyComplete
     // will be called after the async sign operation has completed.
@@ -76,7 +75,7 @@
     virtual int SessionTicketSeal(uint8_t* out,
                                   size_t* out_len,
                                   size_t max_out_len,
-                                  quiche::QuicheStringPiece in) = 0;
+                                  absl::string_view in) = 0;
 
     // SessionTicketOpen is called when BoringSSL has an encrypted session
     // ticket |in| and wants the ticket decrypted. This decryption operation can
@@ -102,7 +101,7 @@
         uint8_t* out,
         size_t* out_len,
         size_t max_out_len,
-        quiche::QuicheStringPiece in) = 0;
+        absl::string_view in) = 0;
 
     // Provides the delegate for callbacks that are shared between client and
     // server.
diff --git a/quic/core/crypto/transport_parameters.cc b/quic/core/crypto/transport_parameters.cc
index 71a9dfb..b143d9d 100644
--- a/quic/core/crypto/transport_parameters.cc
+++ b/quic/core/crypto/transport_parameters.cc
@@ -10,6 +10,7 @@
 #include <memory>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "third_party/boringssl/src/include/openssl/digest.h"
 #include "third_party/boringssl/src/include/openssl/sha.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
@@ -20,7 +21,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 {
@@ -210,7 +210,7 @@
 }
 
 bool WriteTransportParameterStringPiece(QuicDataWriter* writer,
-                                        quiche::QuicheStringPiece value,
+                                        absl::string_view value,
                                         ParsedQuicVersion version) {
   if (version.HasVarIntTransportParams()) {
     return writer->WriteStringPieceVarInt62(value);
@@ -240,10 +240,9 @@
   return true;
 }
 
-bool ReadTransportParameterLengthAndValue(
-    QuicDataReader* reader,
-    ParsedQuicVersion version,
-    quiche::QuicheStringPiece* out_value) {
+bool ReadTransportParameterLengthAndValue(QuicDataReader* reader,
+                                          ParsedQuicVersion version,
+                                          absl::string_view* out_value) {
   if (version.HasVarIntTransportParams()) {
     return reader->ReadStringPieceVarInt62(out_value);
   }
@@ -488,8 +487,7 @@
     if (kv.second.length() <= kMaxPrintableLength) {
       rv += quiche::QuicheTextUtils::HexEncode(kv.second);
     } else {
-      quiche::QuicheStringPiece truncated(kv.second.data(),
-                                          kMaxPrintableLength);
+      absl::string_view truncated(kv.second.data(), kMaxPrintableLength);
       rv += quiche::QuicheStrCat(quiche::QuicheTextUtils::HexEncode(truncated),
                                  "...(length ", kv.second.length(), ")");
     }
@@ -813,9 +811,8 @@
             version) ||
         !WriteTransportParameterStringPiece(
             &writer,
-            quiche::QuicheStringPiece(
-                original_destination_connection_id.data(),
-                original_destination_connection_id.length()),
+            absl::string_view(original_destination_connection_id.data(),
+                              original_destination_connection_id.length()),
             version)) {
       QUIC_BUG << "Failed to write original_destination_connection_id "
                << original_destination_connection_id << " for " << in;
@@ -836,7 +833,7 @@
             &writer, TransportParameters::kStatelessResetToken, version) ||
         !WriteTransportParameterStringPiece(
             &writer,
-            quiche::QuicheStringPiece(
+            absl::string_view(
                 reinterpret_cast<const char*>(in.stateless_reset_token.data()),
                 in.stateless_reset_token.size()),
             version)) {
@@ -919,8 +916,8 @@
             version) ||
         !WriteTransportParameterStringPiece(
             &writer,
-            quiche::QuicheStringPiece(initial_source_connection_id.data(),
-                                      initial_source_connection_id.length()),
+            absl::string_view(initial_source_connection_id.data(),
+                              initial_source_connection_id.length()),
             version)) {
       QUIC_BUG << "Failed to write initial_source_connection_id "
                << initial_source_connection_id << " for " << in;
@@ -937,8 +934,8 @@
             &writer, TransportParameters::kRetrySourceConnectionId, version) ||
         !WriteTransportParameterStringPiece(
             &writer,
-            quiche::QuicheStringPiece(retry_source_connection_id.data(),
-                                      retry_source_connection_id.length()),
+            absl::string_view(retry_source_connection_id.data(),
+                              retry_source_connection_id.length()),
             version)) {
       QUIC_BUG << "Failed to write retry_source_connection_id "
                << retry_source_connection_id << " for " << in;
@@ -1079,7 +1076,7 @@
     random->RandBytes(grease_contents, grease_length);
     if (!WriteTransportParameterId(&writer, grease_id, version) ||
         !WriteTransportParameterStringPiece(
-            &writer, quiche::QuicheStringPiece(grease_contents, grease_length),
+            &writer, absl::string_view(grease_contents, grease_length),
             version)) {
       QUIC_BUG << "Failed to write GREASE parameter "
                << TransportParameterIdToString(grease_id);
@@ -1141,7 +1138,7 @@
       *error_details = "Failed to parse transport parameter ID";
       return false;
     }
-    quiche::QuicheStringPiece value;
+    absl::string_view value;
     if (!ReadTransportParameterLengthAndValue(&reader, version, &value)) {
       *error_details =
           "Failed to read length and value of transport parameter " +
@@ -1183,7 +1180,7 @@
           *error_details = "Received a second stateless_reset_token";
           return false;
         }
-        quiche::QuicheStringPiece stateless_reset_token =
+        absl::string_view stateless_reset_token =
             value_reader.ReadRemainingPayload();
         if (stateless_reset_token.length() != kStatelessResetTokenLength) {
           *error_details = quiche::QuicheStrCat(
diff --git a/quic/core/crypto/transport_parameters.h b/quic/core/crypto/transport_parameters.h
index bf8c607..0ec57e2 100644
--- a/quic/core/crypto/transport_parameters.h
+++ b/quic/core/crypto/transport_parameters.h
@@ -8,6 +8,7 @@
 #include <memory>
 #include <vector>
 
+#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_data_writer.h"
@@ -17,7 +18,6 @@
 #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_optional.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
diff --git a/quic/core/crypto/transport_parameters_test.cc b/quic/core/crypto/transport_parameters_test.cc
index 0578e29..63adb63 100644
--- a/quic/core/crypto/transport_parameters_test.cc
+++ b/quic/core/crypto/transport_parameters_test.cc
@@ -7,6 +7,7 @@
 #include <cstring>
 #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/quic_connection_id.h"
 #include "net/third_party/quiche/src/quic/core/quic_tag.h"
@@ -17,7 +18,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_arraysize.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {