diff --git a/quic/platform/api/quic_cert_utils.h b/quic/platform/api/quic_cert_utils.h
index a680dd6..b2a5bc2 100644
--- a/quic/platform/api/quic_cert_utils.h
+++ b/quic/platform/api/quic_cert_utils.h
@@ -5,17 +5,16 @@
 #ifndef QUICHE_QUIC_PLATFORM_API_QUIC_CERT_UTILS_H_
 #define QUICHE_QUIC_PLATFORM_API_QUIC_CERT_UTILS_H_
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/quic/platform/impl/quic_cert_utils_impl.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
 class QUIC_EXPORT_PRIVATE QuicCertUtils {
  public:
-  static bool ExtractSubjectNameFromDERCert(
-      quiche::QuicheStringPiece cert,
-      quiche::QuicheStringPiece* subject_out) {
+  static bool ExtractSubjectNameFromDERCert(absl::string_view cert,
+                                            absl::string_view* subject_out) {
     return QuicCertUtilsImpl::ExtractSubjectNameFromDERCert(cert, subject_out);
   }
 };
diff --git a/quic/platform/api/quic_file_utils.cc b/quic/platform/api/quic_file_utils.cc
index 40dea3e..a9901e1 100644
--- a/quic/platform/api/quic_file_utils.cc
+++ b/quic/platform/api/quic_file_utils.cc
@@ -4,8 +4,8 @@
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_file_utils.h"
 
+#include "absl/strings/string_view.h"
 #include "net/quic/platform/impl/quic_file_utils_impl.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -16,8 +16,7 @@
 }
 
 // Reads the contents of |filename| as a string into |contents|.
-void ReadFileContents(quiche::QuicheStringPiece filename,
-                      std::string* contents) {
+void ReadFileContents(absl::string_view filename, std::string* contents) {
   ReadFileContentsImpl(filename, contents);
 }
 
diff --git a/quic/platform/api/quic_file_utils.h b/quic/platform/api/quic_file_utils.h
index 8191e0a..6142feb 100644
--- a/quic/platform/api/quic_file_utils.h
+++ b/quic/platform/api/quic_file_utils.h
@@ -8,8 +8,8 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -18,7 +18,7 @@
     const std::string& dirname);
 
 // Reads the contents of |filename| as a string into |contents|.
-QUIC_EXPORT_PRIVATE void ReadFileContents(quiche::QuicheStringPiece filename,
+QUIC_EXPORT_PRIVATE void ReadFileContents(absl::string_view filename,
                                           std::string* contents);
 
 }  // namespace quic
diff --git a/quic/platform/api/quic_hostname_utils.cc b/quic/platform/api/quic_hostname_utils.cc
index 5a0ccc0..d13339c 100644
--- a/quic/platform/api/quic_hostname_utils.cc
+++ b/quic/platform/api/quic_hostname_utils.cc
@@ -3,18 +3,17 @@
 // found in the LICENSE file.
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_hostname_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "absl/strings/string_view.h"
 
 namespace quic {
 
 // static
-bool QuicHostnameUtils::IsValidSNI(quiche::QuicheStringPiece sni) {
+bool QuicHostnameUtils::IsValidSNI(absl::string_view sni) {
   return QuicHostnameUtilsImpl::IsValidSNI(sni);
 }
 
 // static
-std::string QuicHostnameUtils::NormalizeHostname(
-    quiche::QuicheStringPiece hostname) {
+std::string QuicHostnameUtils::NormalizeHostname(absl::string_view hostname) {
   return QuicHostnameUtilsImpl::NormalizeHostname(hostname);
 }
 
diff --git a/quic/platform/api/quic_hostname_utils.h b/quic/platform/api/quic_hostname_utils.h
index 6a04044..a3c902e 100644
--- a/quic/platform/api/quic_hostname_utils.h
+++ b/quic/platform/api/quic_hostname_utils.h
@@ -7,9 +7,9 @@
 
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/quic/platform/impl/quic_hostname_utils_impl.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -21,12 +21,12 @@
   //  (1) disallow IP addresses;
   //  (2) check that the hostname contains valid characters only; and
   //  (3) contains at least one dot.
-  static bool IsValidSNI(quiche::QuicheStringPiece sni);
+  static bool IsValidSNI(absl::string_view sni);
 
   // Canonicalizes the specified hostname.  This involves a wide variety of
   // transformations, including lowercasing, removing trailing dots and IDNA
   // conversion.
-  static std::string NormalizeHostname(quiche::QuicheStringPiece hostname);
+  static std::string NormalizeHostname(absl::string_view hostname);
 };
 
 }  // namespace quic
diff --git a/quic/platform/api/quic_mem_slice_span.h b/quic/platform/api/quic_mem_slice_span.h
index a1e0bd0..741ecb1 100644
--- a/quic/platform/api/quic_mem_slice_span.h
+++ b/quic/platform/api/quic_mem_slice_span.h
@@ -5,9 +5,9 @@
 #ifndef QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_SPAN_H_
 #define QUICHE_QUIC_PLATFORM_API_QUIC_MEM_SLICE_SPAN_H_
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/quic/platform/impl/quic_mem_slice_span_impl.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -39,8 +39,8 @@
   }
 
   // Return data of the span at |index| by the form of a
-  // quiche::QuicheStringPiece.
-  quiche::QuicheStringPiece GetData(int index) { return impl_.GetData(index); }
+  // absl::string_view.
+  absl::string_view GetData(int index) { return impl_.GetData(index); }
 
   // Return the total length of the data inside the span.
   QuicByteCount total_length() { return impl_.total_length(); }
diff --git a/quic/platform/api/quic_string_utils_test.cc b/quic/platform/api/quic_string_utils_test.cc
index 4f65b7d..e23b6ff 100644
--- a/quic/platform/api/quic_string_utils_test.cc
+++ b/quic/platform/api/quic_string_utils_test.cc
@@ -6,9 +6,9 @@
 
 #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_str_cat.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -21,14 +21,14 @@
   // Single string-like argument.
   const char kFoo[] = "foo";
   const std::string string_foo(kFoo);
-  const quiche::QuicheStringPiece stringpiece_foo(string_foo);
+  const absl::string_view stringpiece_foo(string_foo);
   EXPECT_EQ("foo", quiche::QuicheStrCat(kFoo));
   EXPECT_EQ("foo", quiche::QuicheStrCat(string_foo));
   EXPECT_EQ("foo", quiche::QuicheStrCat(stringpiece_foo));
 
   // Two string-like arguments.
   const char kBar[] = "bar";
-  const quiche::QuicheStringPiece stringpiece_bar(kBar);
+  const absl::string_view stringpiece_bar(kBar);
   const std::string string_bar(kBar);
   EXPECT_EQ("foobar", quiche::QuicheStrCat(kFoo, kBar));
   EXPECT_EQ("foobar", quiche::QuicheStrCat(kFoo, string_bar));
@@ -81,7 +81,7 @@
   // Single string-like argument.
   const char kFoo[] = "foo";
   const std::string string_foo(kFoo);
-  const quiche::QuicheStringPiece stringpiece_foo(string_foo);
+  const absl::string_view stringpiece_foo(string_foo);
   QuicStrAppend(&output, kFoo);
   EXPECT_EQ("foo", output);
   QuicStrAppend(&output, string_foo);
@@ -97,7 +97,7 @@
 
   // Two string-like arguments.
   const char kBar[] = "bar";
-  const quiche::QuicheStringPiece stringpiece_bar(kBar);
+  const absl::string_view stringpiece_bar(kBar);
   const std::string string_bar(kBar);
   QuicStrAppend(&output, kFoo, kBar);
   EXPECT_EQ("foobar", output);
diff --git a/quic/platform/api/quic_test_output.h b/quic/platform/api/quic_test_output.h
index 2499876..f925db6 100644
--- a/quic/platform/api/quic_test_output.h
+++ b/quic/platform/api/quic_test_output.h
@@ -5,22 +5,21 @@
 #ifndef QUICHE_QUIC_PLATFORM_API_QUIC_TEST_OUTPUT_H_
 #define QUICHE_QUIC_PLATFORM_API_QUIC_TEST_OUTPUT_H_
 
+#include "absl/strings/string_view.h"
 #include "net/quic/platform/impl/quic_test_output_impl.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
 // Save |data| into ${QUIC_TEST_OUTPUT_DIR}/filename. If a file with the same
 // path already exists, overwrite it.
-inline void QuicSaveTestOutput(quiche::QuicheStringPiece filename,
-                               quiche::QuicheStringPiece data) {
+inline void QuicSaveTestOutput(absl::string_view filename,
+                               absl::string_view data) {
   QuicSaveTestOutputImpl(filename, data);
 }
 
 // Load the content of ${QUIC_TEST_OUTPUT_DIR}/filename into |*data|.
 // Return whether it is successfully loaded.
-inline bool QuicLoadTestOutput(quiche::QuicheStringPiece filename,
-                               std::string* data) {
+inline bool QuicLoadTestOutput(absl::string_view filename, std::string* data) {
   return QuicLoadTestOutputImpl(filename, data);
 }
 
@@ -31,8 +30,8 @@
 // The |identifier| is a human-readable identifier that will be combined with
 // the name of the unit test and a timestamp.  |data| is the serialized
 // quic_trace.Trace protobuf that is being recorded into the file.
-inline void QuicRecordTrace(quiche::QuicheStringPiece identifier,
-                            quiche::QuicheStringPiece data) {
+inline void QuicRecordTrace(absl::string_view identifier,
+                            absl::string_view data) {
   QuicRecordTraceImpl(identifier, data);
 }
 
diff --git a/quic/platform/api/quic_testvalue.h b/quic/platform/api/quic_testvalue.h
index 0df0c40..96ce968 100644
--- a/quic/platform/api/quic_testvalue.h
+++ b/quic/platform/api/quic_testvalue.h
@@ -5,8 +5,8 @@
 #ifndef QUICHE_QUIC_PLATFORM_API_QUIC_TESTVALUE_H_
 #define QUICHE_QUIC_PLATFORM_API_QUIC_TESTVALUE_H_
 
+#include "absl/strings/string_view.h"
 #include "net/quic/platform/impl/quic_testvalue_impl.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -16,7 +16,7 @@
 //
 // Note that this method does nothing in Chromium.
 template <class T>
-void AdjustTestValue(quiche::QuicheStringPiece label, T* var) {
+void AdjustTestValue(absl::string_view label, T* var) {
   AdjustTestValueImpl(label, var);
 }
 
diff --git a/quic/test_tools/qpack/qpack_decoder_test_utils.cc b/quic/test_tools/qpack/qpack_decoder_test_utils.cc
index 4189290..3d4f8ca 100644
--- a/quic/test_tools/qpack/qpack_decoder_test_utils.cc
+++ b/quic/test_tools/qpack/qpack_decoder_test_utils.cc
@@ -8,20 +8,20 @@
 #include <cstddef>
 #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 {
 
 void NoopEncoderStreamErrorDelegate::OnEncoderStreamError(
-    quiche::QuicheStringPiece /*error_message*/) {}
+    absl::string_view /*error_message*/) {}
 
 TestHeadersHandler::TestHeadersHandler()
     : decoding_completed_(false), decoding_error_detected_(false) {}
 
-void TestHeadersHandler::OnHeaderDecoded(quiche::QuicheStringPiece name,
-                                         quiche::QuicheStringPiece value) {
+void TestHeadersHandler::OnHeaderDecoded(absl::string_view name,
+                                         absl::string_view value) {
   ASSERT_FALSE(decoding_completed_);
   ASSERT_FALSE(decoding_error_detected_);
 
@@ -36,7 +36,7 @@
 }
 
 void TestHeadersHandler::OnDecodingErrorDetected(
-    quiche::QuicheStringPiece error_message) {
+    absl::string_view error_message) {
   ASSERT_FALSE(decoding_completed_);
   ASSERT_FALSE(decoding_error_detected_);
 
@@ -71,7 +71,7 @@
     QpackStreamSenderDelegate* decoder_stream_sender_delegate,
     QpackProgressiveDecoder::HeadersHandlerInterface* handler,
     const FragmentSizeGenerator& fragment_size_generator,
-    quiche::QuicheStringPiece data) {
+    absl::string_view data) {
   QpackDecoder decoder(maximum_dynamic_table_capacity, maximum_blocked_streams,
                        encoder_stream_error_delegate);
   decoder.set_qpack_stream_sender_delegate(decoder_stream_sender_delegate);
diff --git a/quic/test_tools/qpack/qpack_decoder_test_utils.h b/quic/test_tools/qpack/qpack_decoder_test_utils.h
index 9741b05..b7a9410 100644
--- a/quic/test_tools/qpack/qpack_decoder_test_utils.h
+++ b/quic/test_tools/qpack/qpack_decoder_test_utils.h
@@ -7,11 +7,11 @@
 
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_decoder.h"
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_progressive_decoder.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_header_block.h"
 
 namespace quic {
@@ -23,7 +23,7 @@
  public:
   ~NoopEncoderStreamErrorDelegate() override = default;
 
-  void OnEncoderStreamError(quiche::QuicheStringPiece error_message) override;
+  void OnEncoderStreamError(absl::string_view error_message) override;
 };
 
 // Mock QpackDecoder::EncoderStreamErrorDelegate implementation.
@@ -34,7 +34,7 @@
 
   MOCK_METHOD(void,
               OnEncoderStreamError,
-              (quiche::QuicheStringPiece error_message),
+              (absl::string_view error_message),
               (override));
 };
 
@@ -47,11 +47,10 @@
   ~TestHeadersHandler() override = default;
 
   // HeadersHandlerInterface implementation:
-  void OnHeaderDecoded(quiche::QuicheStringPiece name,
-                       quiche::QuicheStringPiece value) override;
+  void OnHeaderDecoded(absl::string_view name,
+                       absl::string_view value) override;
   void OnDecodingCompleted() override;
-  void OnDecodingErrorDetected(
-      quiche::QuicheStringPiece error_message) override;
+  void OnDecodingErrorDetected(absl::string_view error_message) override;
 
   // Release decoded header list.  Must only be called if decoding is complete
   // and no errors have been detected.
@@ -78,12 +77,12 @@
 
   MOCK_METHOD(void,
               OnHeaderDecoded,
-              (quiche::QuicheStringPiece name, quiche::QuicheStringPiece value),
+              (absl::string_view name, absl::string_view value),
               (override));
   MOCK_METHOD(void, OnDecodingCompleted, (), (override));
   MOCK_METHOD(void,
               OnDecodingErrorDetected,
-              (quiche::QuicheStringPiece error_message),
+              (absl::string_view error_message),
               (override));
 };
 
@@ -92,11 +91,10 @@
  public:
   ~NoOpHeadersHandler() override = default;
 
-  void OnHeaderDecoded(quiche::QuicheStringPiece /*name*/,
-                       quiche::QuicheStringPiece /*value*/) override {}
+  void OnHeaderDecoded(absl::string_view /*name*/,
+                       absl::string_view /*value*/) override {}
   void OnDecodingCompleted() override {}
-  void OnDecodingErrorDetected(
-      quiche::QuicheStringPiece /*error_message*/) override {}
+  void OnDecodingErrorDetected(absl::string_view /*error_message*/) override {}
 };
 
 void QpackDecode(
@@ -106,7 +104,7 @@
     QpackStreamSenderDelegate* decoder_stream_sender_delegate,
     QpackProgressiveDecoder::HeadersHandlerInterface* handler,
     const FragmentSizeGenerator& fragment_size_generator,
-    quiche::QuicheStringPiece data);
+    absl::string_view data);
 
 }  // namespace test
 }  // namespace quic
diff --git a/quic/test_tools/qpack/qpack_encoder_test_utils.cc b/quic/test_tools/qpack/qpack_encoder_test_utils.cc
index 1303511..3f05815 100644
--- a/quic/test_tools/qpack/qpack_encoder_test_utils.cc
+++ b/quic/test_tools/qpack/qpack_encoder_test_utils.cc
@@ -4,14 +4,14 @@
 
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_encoder_test_utils.h"
 
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_encoder.h"
 
 namespace quic {
 namespace test {
 
 void NoopDecoderStreamErrorDelegate::OnDecoderStreamError(
-    quiche::QuicheStringPiece /*error_message*/) {}
+    absl::string_view /*error_message*/) {}
 
 }  // namespace test
 }  // namespace quic
diff --git a/quic/test_tools/qpack/qpack_encoder_test_utils.h b/quic/test_tools/qpack/qpack_encoder_test_utils.h
index 9b18815..c6dcd72 100644
--- a/quic/test_tools/qpack/qpack_encoder_test_utils.h
+++ b/quic/test_tools/qpack/qpack_encoder_test_utils.h
@@ -7,10 +7,10 @@
 
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_encoder.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_header_block.h"
 
 namespace quic {
@@ -22,7 +22,7 @@
  public:
   ~NoopDecoderStreamErrorDelegate() override = default;
 
-  void OnDecoderStreamError(quiche::QuicheStringPiece error_message) override;
+  void OnDecoderStreamError(absl::string_view error_message) override;
 };
 
 // Mock QpackEncoder::DecoderStreamErrorDelegate implementation.
@@ -33,7 +33,7 @@
 
   MOCK_METHOD(void,
               OnDecoderStreamError,
-              (quiche::QuicheStringPiece error_message),
+              (absl::string_view error_message),
               (override));
 };
 
diff --git a/quic/test_tools/qpack/qpack_offline_decoder.cc b/quic/test_tools/qpack/qpack_offline_decoder.cc
index a7ba9e4..555b571 100644
--- a/quic/test_tools/qpack/qpack_offline_decoder.cc
+++ b/quic/test_tools/qpack/qpack_offline_decoder.cc
@@ -30,12 +30,12 @@
 #include <string>
 #include <utility>
 
+#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_file_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.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 {
@@ -44,8 +44,8 @@
     : encoder_stream_error_detected_(false) {}
 
 bool QpackOfflineDecoder::DecodeAndVerifyOfflineData(
-    quiche::QuicheStringPiece input_filename,
-    quiche::QuicheStringPiece expected_headers_filename) {
+    absl::string_view input_filename,
+    absl::string_view expected_headers_filename) {
   if (!ParseInputFilename(input_filename)) {
     QUIC_LOG(ERROR) << "Error parsing input filename " << input_filename;
     return false;
@@ -67,13 +67,12 @@
 }
 
 void QpackOfflineDecoder::OnEncoderStreamError(
-    quiche::QuicheStringPiece error_message) {
+    absl::string_view error_message) {
   QUIC_LOG(ERROR) << "Encoder stream error: " << error_message;
   encoder_stream_error_detected_ = true;
 }
 
-bool QpackOfflineDecoder::ParseInputFilename(
-    quiche::QuicheStringPiece input_filename) {
+bool QpackOfflineDecoder::ParseInputFilename(absl::string_view input_filename) {
   auto pieces = quiche::QuicheTextUtils::Split(input_filename, '.');
 
   if (pieces.size() < 3) {
@@ -132,12 +131,12 @@
 }
 
 bool QpackOfflineDecoder::DecodeHeaderBlocksFromFile(
-    quiche::QuicheStringPiece input_filename) {
-  // Store data in |input_data_storage|; use a quiche::QuicheStringPiece to
+    absl::string_view input_filename) {
+  // Store data in |input_data_storage|; use a absl::string_view to
   // efficiently keep track of remaining portion yet to be decoded.
   std::string input_data_storage;
   ReadFileContents(input_filename, &input_data_storage);
-  quiche::QuicheStringPiece input_data(input_data_storage);
+  absl::string_view input_data(input_data_storage);
 
   while (!input_data.empty()) {
     // Parse stream_id and length.
@@ -160,7 +159,7 @@
     }
 
     // Parse data.
-    quiche::QuicheStringPiece data = input_data.substr(0, length);
+    absl::string_view data = input_data.substr(0, length);
     input_data = input_data.substr(length);
 
     // Process data.
@@ -228,14 +227,13 @@
 }
 
 bool QpackOfflineDecoder::VerifyDecodedHeaderLists(
-    quiche::QuicheStringPiece expected_headers_filename) {
+    absl::string_view expected_headers_filename) {
   // Store data in |expected_headers_data_storage|; use a
-  // quiche::QuicheStringPiece to efficiently keep track of remaining portion
+  // absl::string_view to efficiently keep track of remaining portion
   // yet to be decoded.
   std::string expected_headers_data_storage;
   ReadFileContents(expected_headers_filename, &expected_headers_data_storage);
-  quiche::QuicheStringPiece expected_headers_data(
-      expected_headers_data_storage);
+  absl::string_view expected_headers_data(expected_headers_data_storage);
 
   while (!decoded_header_lists_.empty()) {
     spdy::SpdyHeaderBlock decoded_header_list =
@@ -268,14 +266,13 @@
 }
 
 bool QpackOfflineDecoder::ReadNextExpectedHeaderList(
-    quiche::QuicheStringPiece* expected_headers_data,
+    absl::string_view* expected_headers_data,
     spdy::SpdyHeaderBlock* expected_header_list) {
   while (true) {
-    quiche::QuicheStringPiece::size_type endline =
-        expected_headers_data->find('\n');
+    absl::string_view::size_type endline = expected_headers_data->find('\n');
 
     // Even last header list must be followed by an empty line.
-    if (endline == quiche::QuicheStringPiece::npos) {
+    if (endline == absl::string_view::npos) {
       QUIC_LOG(ERROR) << "Unexpected end of expected header list file.";
       return false;
     }
@@ -286,8 +283,7 @@
       return true;
     }
 
-    quiche::QuicheStringPiece header_field =
-        expected_headers_data->substr(0, endline);
+    absl::string_view header_field = expected_headers_data->substr(0, endline);
     auto pieces = quiche::QuicheTextUtils::Split(header_field, '\t');
 
     if (pieces.size() != 2) {
@@ -316,7 +312,7 @@
   const char* kPseudoHeaderPrefix = ":";
   for (spdy::SpdyHeaderBlock::iterator decoded_it = decoded_header_list.begin();
        decoded_it != decoded_header_list.end();) {
-    const quiche::QuicheStringPiece key = decoded_it->first;
+    const absl::string_view key = decoded_it->first;
     if (key != kContentLength &&
         !quiche::QuicheTextUtils::StartsWith(key, kPseudoHeaderPrefix)) {
       ++decoded_it;
diff --git a/quic/test_tools/qpack/qpack_offline_decoder.h b/quic/test_tools/qpack/qpack_offline_decoder.h
index f90b2c7..3393650 100644
--- a/quic/test_tools/qpack/qpack_offline_decoder.h
+++ b/quic/test_tools/qpack/qpack_offline_decoder.h
@@ -7,10 +7,10 @@
 
 #include <list>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_decoder.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_decoder_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_header_block.h"
 
 namespace quic {
@@ -29,12 +29,11 @@
   // |expected_headers_filename|, and compare decoded header lists to expected
   // ones.  Returns true if there is an equal number of them and the
   // corresponding ones match, false otherwise.
-  bool DecodeAndVerifyOfflineData(
-      quiche::QuicheStringPiece input_filename,
-      quiche::QuicheStringPiece expected_headers_filename);
+  bool DecodeAndVerifyOfflineData(absl::string_view input_filename,
+                                  absl::string_view expected_headers_filename);
 
   // QpackDecoder::EncoderStreamErrorDelegate implementation:
-  void OnEncoderStreamError(quiche::QuicheStringPiece error_message) override;
+  void OnEncoderStreamError(absl::string_view error_message) override;
 
  private:
   // Data structure to hold TestHeadersHandler and QpackProgressiveDecoder until
@@ -48,24 +47,22 @@
 
   // Parse decoder parameters from |input_filename| and set up |qpack_decoder_|
   // accordingly.
-  bool ParseInputFilename(quiche::QuicheStringPiece input_filename);
+  bool ParseInputFilename(absl::string_view input_filename);
 
   // Read encoded header blocks and encoder stream data from |input_filename|,
   // pass them to |qpack_decoder_| for decoding, and add decoded header lists to
   // |decoded_header_lists_|.
-  bool DecodeHeaderBlocksFromFile(quiche::QuicheStringPiece input_filename);
+  bool DecodeHeaderBlocksFromFile(absl::string_view input_filename);
 
   // Read expected header lists from |expected_headers_filename| and verify
   // decoded header lists in |decoded_header_lists_| against them.
-  bool VerifyDecodedHeaderLists(
-      quiche::QuicheStringPiece expected_headers_filename);
+  bool VerifyDecodedHeaderLists(absl::string_view expected_headers_filename);
 
   // Parse next header list from |*expected_headers_data| into
   // |*expected_header_list|, removing consumed data from the beginning of
   // |*expected_headers_data|.  Returns true on success, false if parsing fails.
-  bool ReadNextExpectedHeaderList(
-      quiche::QuicheStringPiece* expected_headers_data,
-      spdy::SpdyHeaderBlock* expected_header_list);
+  bool ReadNextExpectedHeaderList(absl::string_view* expected_headers_data,
+                                  spdy::SpdyHeaderBlock* expected_header_list);
 
   // Compare two header lists.  Allow for different orders of certain headers as
   // described at
diff --git a/quic/test_tools/qpack/qpack_test_utils.h b/quic/test_tools/qpack/qpack_test_utils.h
index b9f4adf..0d0594d 100644
--- a/quic/test_tools/qpack/qpack_test_utils.h
+++ b/quic/test_tools/qpack/qpack_test_utils.h
@@ -8,9 +8,9 @@
 #include <cstddef>
 #include <functional>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_stream_sender_delegate.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 {
@@ -32,17 +32,14 @@
  public:
   ~MockQpackStreamSenderDelegate() override = default;
 
-  MOCK_METHOD(void,
-              WriteStreamData,
-              (quiche::QuicheStringPiece data),
-              (override));
+  MOCK_METHOD(void, WriteStreamData, (absl::string_view data), (override));
 };
 
 class NoopQpackStreamSenderDelegate : public QpackStreamSenderDelegate {
  public:
   ~NoopQpackStreamSenderDelegate() override = default;
 
-  void WriteStreamData(quiche::QuicheStringPiece /*data*/) override {}
+  void WriteStreamData(absl::string_view /*data*/) override {}
 };
 
 }  // namespace test