diff --git a/quic/qbone/mock_qbone_client.h b/quic/qbone/mock_qbone_client.h
index 3170b7e..c5ec95b 100644
--- a/quic/qbone/mock_qbone_client.h
+++ b/quic/qbone/mock_qbone_client.h
@@ -5,9 +5,9 @@
 #ifndef QUICHE_QUIC_QBONE_MOCK_QBONE_CLIENT_H_
 #define QUICHE_QUIC_QBONE_MOCK_QBONE_CLIENT_H_
 
+#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/qbone/qbone_client_interface.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -15,7 +15,7 @@
  public:
   MOCK_METHOD(void,
               ProcessPacketFromNetwork,
-              (quiche::QuicheStringPiece packet),
+              (absl::string_view packet),
               (override));
 };
 
diff --git a/quic/qbone/mock_qbone_server_session.h b/quic/qbone/mock_qbone_server_session.h
index 0781e7f..d398ba5 100644
--- a/quic/qbone/mock_qbone_server_session.h
+++ b/quic/qbone/mock_qbone_server_session.h
@@ -27,14 +27,8 @@
 
   MOCK_METHOD(bool, SendClientRequest, (const QboneClientRequest&), (override));
 
-  MOCK_METHOD(void,
-              ProcessPacketFromNetwork,
-              (quiche::QuicheStringPiece),
-              (override));
-  MOCK_METHOD(void,
-              ProcessPacketFromPeer,
-              (quiche::QuicheStringPiece),
-              (override));
+  MOCK_METHOD(void, ProcessPacketFromNetwork, (absl::string_view), (override));
+  MOCK_METHOD(void, ProcessPacketFromPeer, (absl::string_view), (override));
 };
 
 }  // namespace quic
diff --git a/quic/qbone/qbone_client.cc b/quic/qbone/qbone_client.cc
index a2ba117..44aec9c 100644
--- a/quic/qbone/qbone_client.cc
+++ b/quic/qbone/qbone_client.cc
@@ -6,12 +6,12 @@
 
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_epoll_alarm_factory.h"
 #include "net/third_party/quiche/src/quic/core/quic_epoll_connection_helper.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_epoll.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_exported_stats.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_stream.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace {
@@ -58,7 +58,7 @@
   return static_cast<QboneClientSession*>(QuicClientBase::session());
 }
 
-void QboneClient::ProcessPacketFromNetwork(quiche::QuicheStringPiece packet) {
+void QboneClient::ProcessPacketFromNetwork(absl::string_view packet) {
   qbone_session()->ProcessPacketFromNetwork(packet);
 }
 
diff --git a/quic/qbone/qbone_client.h b/quic/qbone/qbone_client.h
index 2095110..7fbba4b 100644
--- a/quic/qbone/qbone_client.h
+++ b/quic/qbone/qbone_client.h
@@ -5,12 +5,12 @@
 #ifndef QUICHE_QUIC_QBONE_QBONE_CLIENT_H_
 #define QUICHE_QUIC_QBONE_QBONE_CLIENT_H_
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_client_interface.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_client_session.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_packet_writer.h"
 #include "net/third_party/quiche/src/quic/tools/quic_client_base.h"
 #include "net/third_party/quiche/src/quic/tools/quic_client_epoll_network_helper.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 // A QboneClient encapsulates connecting to a server via an epoll server
@@ -34,7 +34,7 @@
 
   // From QboneClientInterface. Accepts a given packet from the network and
   // sends the packet down to the QBONE connection.
-  void ProcessPacketFromNetwork(quiche::QuicheStringPiece packet) override;
+  void ProcessPacketFromNetwork(absl::string_view packet) override;
 
   bool EarlyDataAccepted() override;
   bool ReceivedInchoateReject() override;
diff --git a/quic/qbone/qbone_client_interface.h b/quic/qbone/qbone_client_interface.h
index aec3a8f..8b31cce 100644
--- a/quic/qbone/qbone_client_interface.h
+++ b/quic/qbone/qbone_client_interface.h
@@ -7,7 +7,7 @@
 
 #include <cstdint>
 
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "absl/strings/string_view.h"
 
 namespace quic {
 
@@ -17,7 +17,7 @@
   virtual ~QboneClientInterface() {}
   // Accepts a given packet from the network and sends the packet down to the
   // QBONE connection.
-  virtual void ProcessPacketFromNetwork(quiche::QuicheStringPiece packet) = 0;
+  virtual void ProcessPacketFromNetwork(absl::string_view packet) = 0;
 };
 
 }  // namespace quic
diff --git a/quic/qbone/qbone_client_session.cc b/quic/qbone/qbone_client_session.cc
index d6ce811..4697fcc 100644
--- a/quic/qbone/qbone_client_session.cc
+++ b/quic/qbone/qbone_client_session.cc
@@ -6,9 +6,9 @@
 
 #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/qbone/qbone_constants.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -77,13 +77,11 @@
   return control_stream_->SendRequest(request);
 }
 
-void QboneClientSession::ProcessPacketFromNetwork(
-    quiche::QuicheStringPiece packet) {
+void QboneClientSession::ProcessPacketFromNetwork(absl::string_view packet) {
   SendPacketToPeer(packet);
 }
 
-void QboneClientSession::ProcessPacketFromPeer(
-    quiche::QuicheStringPiece packet) {
+void QboneClientSession::ProcessPacketFromPeer(absl::string_view packet) {
   writer_->WritePacketToNetwork(packet.data(), packet.size());
 }
 
diff --git a/quic/qbone/qbone_client_session.h b/quic/qbone/qbone_client_session.h
index 4eeb7b1..f3cd020 100644
--- a/quic/qbone/qbone_client_session.h
+++ b/quic/qbone/qbone_client_session.h
@@ -5,13 +5,13 @@
 #ifndef QUICHE_QUIC_QBONE_QBONE_CLIENT_SESSION_H_
 #define QUICHE_QUIC_QBONE_QBONE_CLIENT_SESSION_H_
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_crypto_client_stream.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_control.pb.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_control_stream.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_packet_writer.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_session_base.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -55,8 +55,8 @@
 
   bool SendServerRequest(const QboneServerRequest& request);
 
-  void ProcessPacketFromNetwork(quiche::QuicheStringPiece packet) override;
-  void ProcessPacketFromPeer(quiche::QuicheStringPiece packet) override;
+  void ProcessPacketFromNetwork(absl::string_view packet) override;
+  void ProcessPacketFromPeer(absl::string_view packet) override;
 
   // Returns true if there are active requests on this session.
   bool HasActiveRequests() const;
diff --git a/quic/qbone/qbone_client_test.cc b/quic/qbone/qbone_client_test.cc
index 5a637a2..e423c52 100644
--- a/quic/qbone/qbone_client_test.cc
+++ b/quic/qbone/qbone_client_test.cc
@@ -6,6 +6,7 @@
 
 #include "net/third_party/quiche/src/quic/qbone/qbone_client.h"
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_alarm_factory.h"
 #include "net/third_party/quiche/src/quic/core/quic_default_packet_writer.h"
 #include "net/third_party/quiche/src/quic/core/quic_dispatcher.h"
@@ -26,7 +27,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/server_thread.h"
 #include "net/third_party/quiche/src/quic/tools/quic_memory_cache_backend.h"
 #include "net/third_party/quiche/src/quic/tools/quic_server.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -125,7 +125,7 @@
       QuicConnectionId id,
       const QuicSocketAddress& self_address,
       const QuicSocketAddress& peer_address,
-      quiche::QuicheStringPiece alpn,
+      absl::string_view alpn,
       const quic::ParsedQuicVersion& version) override {
     CHECK_EQ(alpn, "qbone");
     QuicConnection* connection = new QuicConnection(
diff --git a/quic/qbone/qbone_control_stream.cc b/quic/qbone/qbone_control_stream.cc
index 0b453a7..04f074c 100644
--- a/quic/qbone/qbone_control_stream.cc
+++ b/quic/qbone/qbone_control_stream.cc
@@ -4,10 +4,10 @@
 
 #include "net/third_party/quiche/src/quic/qbone/qbone_control_stream.h"
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_session.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_constants.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -59,8 +59,8 @@
   uint16_t size = tmp.size();
   char size_str[kRequestSizeBytes];
   memcpy(size_str, &size, kRequestSizeBytes);
-  WriteOrBufferData(quiche::QuicheStringPiece(size_str, kRequestSizeBytes),
-                    false, nullptr);
+  WriteOrBufferData(absl::string_view(size_str, kRequestSizeBytes), false,
+                    nullptr);
   WriteOrBufferData(tmp, false, nullptr);
   return true;
 }
diff --git a/quic/qbone/qbone_packet_processor.cc b/quic/qbone/qbone_packet_processor.cc
index ef78efa..148c75a 100644
--- a/quic/qbone/qbone_packet_processor.cc
+++ b/quic/qbone/qbone_packet_processor.cc
@@ -6,13 +6,13 @@
 
 #include <cstring>
 
+#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/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/quic/qbone/platform/icmp_packet.h"
 #include "net/third_party/quiche/src/quic/qbone/platform/internet_checksum.h"
 #include "net/third_party/quiche/src/quic/qbone/platform/tcp_packet.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 {
 
@@ -51,12 +51,11 @@
 QbonePacketProcessor::Filter::~Filter() {}
 
 QbonePacketProcessor::ProcessingResult
-QbonePacketProcessor::Filter::FilterPacket(
-    Direction direction,
-    quiche::QuicheStringPiece full_packet,
-    quiche::QuicheStringPiece payload,
-    icmp6_hdr* icmp_header,
-    OutputInterface* output) {
+QbonePacketProcessor::Filter::FilterPacket(Direction direction,
+                                           absl::string_view full_packet,
+                                           absl::string_view payload,
+                                           icmp6_hdr* icmp_header,
+                                           OutputInterface* output) {
   return ProcessingResult::OK;
 }
 
@@ -128,8 +127,7 @@
 
     result = filter_->FilterPacket(
         direction, *packet,
-        quiche::QuicheStringPiece(*transport_data,
-                                  packet->size() - header_size),
+        absl::string_view(*transport_data, packet->size() - header_size),
         icmp_header, output_);
   }
 
@@ -237,32 +235,29 @@
   return ProcessingResult::OK;
 }
 
-void QbonePacketProcessor::SendIcmpResponse(
-    icmp6_hdr* icmp_header,
-    quiche::QuicheStringPiece original_packet,
-    Direction original_direction) {
+void QbonePacketProcessor::SendIcmpResponse(icmp6_hdr* icmp_header,
+                                            absl::string_view original_packet,
+                                            Direction original_direction) {
   in6_addr dst;
   // TODO(b/70339814): ensure this is actually a unicast address.
   memcpy(dst.s6_addr, &original_packet[8], kIPv6AddressSize);
 
-  CreateIcmpPacket(
-      self_ip_, dst, *icmp_header, original_packet,
-      [this, original_direction](quiche::QuicheStringPiece packet) {
-        SendResponse(original_direction, packet);
-      });
+  CreateIcmpPacket(self_ip_, dst, *icmp_header, original_packet,
+                   [this, original_direction](absl::string_view packet) {
+                     SendResponse(original_direction, packet);
+                   });
 }
 
-void QbonePacketProcessor::SendTcpReset(
-    quiche::QuicheStringPiece original_packet,
-    Direction original_direction) {
-  CreateTcpResetPacket(original_packet, [this, original_direction](
-                                            quiche::QuicheStringPiece packet) {
-    SendResponse(original_direction, packet);
-  });
+void QbonePacketProcessor::SendTcpReset(absl::string_view original_packet,
+                                        Direction original_direction) {
+  CreateTcpResetPacket(original_packet,
+                       [this, original_direction](absl::string_view packet) {
+                         SendResponse(original_direction, packet);
+                       });
 }
 
 void QbonePacketProcessor::SendResponse(Direction original_direction,
-                                        quiche::QuicheStringPiece packet) {
+                                        absl::string_view packet) {
   switch (original_direction) {
     case Direction::FROM_OFF_NETWORK:
       output_->SendPacketToClient(packet);
diff --git a/quic/qbone/qbone_packet_processor.h b/quic/qbone/qbone_packet_processor.h
index 130770d..bb5e816 100644
--- a/quic/qbone/qbone_packet_processor.h
+++ b/quic/qbone/qbone_packet_processor.h
@@ -8,9 +8,9 @@
 #include <netinet/icmp6.h>
 #include <netinet/ip6.h>
 
+#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_ip_address.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -52,8 +52,8 @@
    public:
     virtual ~OutputInterface();
 
-    virtual void SendPacketToClient(quiche::QuicheStringPiece packet) = 0;
-    virtual void SendPacketToNetwork(quiche::QuicheStringPiece packet) = 0;
+    virtual void SendPacketToClient(absl::string_view packet) = 0;
+    virtual void SendPacketToNetwork(absl::string_view packet) = 0;
   };
 
   class StatsInterface {
@@ -94,8 +94,8 @@
     // Note that |output| should not be used except in the DEFER case, as the
     // processor will perform the necessary writes itself.
     virtual ProcessingResult FilterPacket(Direction direction,
-                                          quiche::QuicheStringPiece full_packet,
-                                          quiche::QuicheStringPiece payload,
+                                          absl::string_view full_packet,
+                                          absl::string_view payload,
                                           icmp6_hdr* icmp_header,
                                           OutputInterface* output);
 
@@ -104,19 +104,17 @@
     // for filtering from the |ipv6_header| argument.  All of those assume that
     // the header is of valid size, which is true for everything passed into
     // FilterPacket().
-    inline uint8_t TransportProtocolFromHeader(
-        quiche::QuicheStringPiece ipv6_header) {
+    inline uint8_t TransportProtocolFromHeader(absl::string_view ipv6_header) {
       return ipv6_header[6];
     }
-    inline QuicIpAddress SourceIpFromHeader(
-        quiche::QuicheStringPiece ipv6_header) {
+    inline QuicIpAddress SourceIpFromHeader(absl::string_view ipv6_header) {
       QuicIpAddress address;
       address.FromPackedString(&ipv6_header[8],
                                QuicIpAddress::kIPv6AddressSize);
       return address;
     }
     inline QuicIpAddress DestinationIpFromHeader(
-        quiche::QuicheStringPiece ipv6_header) {
+        absl::string_view ipv6_header) {
       QuicIpAddress address;
       address.FromPackedString(&ipv6_header[24],
                                QuicIpAddress::kIPv6AddressSize);
@@ -167,10 +165,10 @@
                                               icmp6_hdr* icmp_header);
 
   void SendIcmpResponse(icmp6_hdr* icmp_header,
-                        quiche::QuicheStringPiece original_packet,
+                        absl::string_view original_packet,
                         Direction original_direction);
 
-  void SendTcpReset(quiche::QuicheStringPiece original_packet,
+  void SendTcpReset(absl::string_view original_packet,
                     Direction original_direction);
 
   inline bool IsValid() const { return client_ip_ != kInvalidIpAddress; }
@@ -194,8 +192,7 @@
                                      char** transport_data,
                                      icmp6_hdr* icmp_header);
 
-  void SendResponse(Direction original_direction,
-                    quiche::QuicheStringPiece packet);
+  void SendResponse(Direction original_direction, absl::string_view packet);
 };
 
 }  // namespace quic
diff --git a/quic/qbone/qbone_packet_processor_test.cc b/quic/qbone/qbone_packet_processor_test.cc
index 2820a7a..569df91 100644
--- a/quic/qbone/qbone_packet_processor_test.cc
+++ b/quic/qbone/qbone_packet_processor_test.cc
@@ -6,9 +6,9 @@
 
 #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/quic/qbone/qbone_packet_processor_test_tools.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace {
@@ -101,15 +101,15 @@
 
 // clang-format on
 
-static const quiche::QuicheStringPiece kReferenceClientPacket(
+static const absl::string_view kReferenceClientPacket(
     kReferenceClientPacketData,
     arraysize(kReferenceClientPacketData));
 
-static const quiche::QuicheStringPiece kReferenceNetworkPacket(
+static const absl::string_view kReferenceNetworkPacket(
     kReferenceNetworkPacketData,
     arraysize(kReferenceNetworkPacketData));
 
-static const quiche::QuicheStringPiece kReferenceClientSubnetPacket(
+static const absl::string_view kReferenceClientSubnetPacket(
     kReferenceClientSubnetPacketData,
     arraysize(kReferenceClientSubnetPacketData));
 
@@ -128,8 +128,8 @@
   MOCK_METHOD(ProcessingResult,
               FilterPacket,
               (Direction,
-               quiche::QuicheStringPiece,
-               quiche::QuicheStringPiece,
+               absl::string_view,
+               absl::string_view,
                icmp6_hdr*,
                OutputInterface*),
               (override));
@@ -147,12 +147,12 @@
         &stats_);
   }
 
-  void SendPacketFromClient(quiche::QuicheStringPiece packet) {
+  void SendPacketFromClient(absl::string_view packet) {
     std::string packet_buffer(packet.data(), packet.size());
     processor_->ProcessPacket(&packet_buffer, Direction::FROM_OFF_NETWORK);
   }
 
-  void SendPacketFromNetwork(quiche::QuicheStringPiece packet) {
+  void SendPacketFromNetwork(absl::string_view packet) {
     std::string packet_buffer(packet.data(), packet.size());
     processor_->ProcessPacket(&packet_buffer, Direction::FROM_NETWORK);
   }
@@ -249,8 +249,8 @@
   TestFilter(QuicIpAddress client_ip, QuicIpAddress network_ip)
       : client_ip_(client_ip), network_ip_(network_ip) {}
   ProcessingResult FilterPacket(Direction direction,
-                                quiche::QuicheStringPiece full_packet,
-                                quiche::QuicheStringPiece payload,
+                                absl::string_view full_packet,
+                                absl::string_view payload,
                                 icmp6_hdr* icmp_header,
                                 OutputInterface* output) override {
     EXPECT_EQ(kIPv6HeaderSize, full_packet.size() - payload.size());
diff --git a/quic/qbone/qbone_packet_processor_test_tools.h b/quic/qbone/qbone_packet_processor_test_tools.h
index 7203050..8384821 100644
--- a/quic/qbone/qbone_packet_processor_test_tools.h
+++ b/quic/qbone/qbone_packet_processor_test_tools.h
@@ -5,9 +5,9 @@
 #ifndef QUICHE_QUIC_QBONE_QBONE_PACKET_PROCESSOR_TEST_TOOLS_H_
 #define QUICHE_QUIC_QBONE_QBONE_PACKET_PROCESSOR_TEST_TOOLS_H_
 
+#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/qbone/qbone_packet_processor.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -15,14 +15,8 @@
  public:
   MockPacketProcessorOutput() {}
 
-  MOCK_METHOD(void,
-              SendPacketToClient,
-              (quiche::QuicheStringPiece),
-              (override));
-  MOCK_METHOD(void,
-              SendPacketToNetwork,
-              (quiche::QuicheStringPiece),
-              (override));
+  MOCK_METHOD(void, SendPacketToClient, (absl::string_view), (override));
+  MOCK_METHOD(void, SendPacketToNetwork, (absl::string_view), (override));
 };
 
 class MockPacketProcessorStats : public QbonePacketProcessor::StatsInterface {
diff --git a/quic/qbone/qbone_server_session.cc b/quic/qbone/qbone_server_session.cc
index 6561f57..7f83381 100644
--- a/quic/qbone/qbone_server_session.cc
+++ b/quic/qbone/qbone_server_session.cc
@@ -6,11 +6,11 @@
 
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_constants.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -20,7 +20,7 @@
     const QuicSocketAddress& peer_address,
     const QuicSocketAddress& self_address,
     std::string* error_details) const {
-  quiche::QuicheStringPiece alpn;
+  absl::string_view alpn;
   chlo.GetStringPiece(quic::kALPN, &alpn);
   if (alpn != QboneConstants::kQboneAlpn) {
     *error_details = "ALPN-indicated protocol is not qbone";
@@ -72,25 +72,23 @@
   return control_stream_->SendRequest(request);
 }
 
-void QboneServerSession::ProcessPacketFromNetwork(
-    quiche::QuicheStringPiece packet) {
+void QboneServerSession::ProcessPacketFromNetwork(absl::string_view packet) {
   std::string buffer = std::string(packet);
   processor_.ProcessPacket(&buffer,
                            QbonePacketProcessor::Direction::FROM_NETWORK);
 }
 
-void QboneServerSession::ProcessPacketFromPeer(
-    quiche::QuicheStringPiece packet) {
+void QboneServerSession::ProcessPacketFromPeer(absl::string_view packet) {
   std::string buffer = std::string(packet);
   processor_.ProcessPacket(&buffer,
                            QbonePacketProcessor::Direction::FROM_OFF_NETWORK);
 }
 
-void QboneServerSession::SendPacketToClient(quiche::QuicheStringPiece packet) {
+void QboneServerSession::SendPacketToClient(absl::string_view packet) {
   SendPacketToPeer(packet);
 }
 
-void QboneServerSession::SendPacketToNetwork(quiche::QuicheStringPiece packet) {
+void QboneServerSession::SendPacketToNetwork(absl::string_view packet) {
   DCHECK(writer_ != nullptr);
   writer_->WritePacketToNetwork(packet.data(), packet.size());
 }
diff --git a/quic/qbone/qbone_server_session.h b/quic/qbone/qbone_server_session.h
index fee1c74..63a0d8d 100644
--- a/quic/qbone/qbone_server_session.h
+++ b/quic/qbone/qbone_server_session.h
@@ -5,6 +5,7 @@
 #ifndef QUICHE_QUIC_QBONE_QBONE_SERVER_SESSION_H_
 #define QUICHE_QUIC_QBONE_QBONE_SERVER_SESSION_H_
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_crypto_server_stream_base.h"
 #include "net/third_party/quiche/src/quic/core/quic_crypto_stream.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
@@ -13,7 +14,6 @@
 #include "net/third_party/quiche/src/quic/qbone/qbone_packet_processor.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_packet_writer.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_session_base.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -53,12 +53,12 @@
 
   virtual bool SendClientRequest(const QboneClientRequest& request);
 
-  void ProcessPacketFromNetwork(quiche::QuicheStringPiece packet) override;
-  void ProcessPacketFromPeer(quiche::QuicheStringPiece packet) override;
+  void ProcessPacketFromNetwork(absl::string_view packet) override;
+  void ProcessPacketFromPeer(absl::string_view packet) override;
 
   // QbonePacketProcessor::OutputInterface implementation.
-  void SendPacketToClient(quiche::QuicheStringPiece packet) override;
-  void SendPacketToNetwork(quiche::QuicheStringPiece packet) override;
+  void SendPacketToClient(absl::string_view packet) override;
+  void SendPacketToNetwork(absl::string_view packet) override;
 
   // QbonePacketProcessor::StatsInterface implementation.
   void OnPacketForwarded(QbonePacketProcessor::Direction direction) override {}
diff --git a/quic/qbone/qbone_session_base.cc b/quic/qbone/qbone_session_base.cc
index e534398..d2d2ab4 100644
--- a/quic/qbone/qbone_session_base.cc
+++ b/quic/qbone/qbone_session_base.cc
@@ -9,6 +9,7 @@
 
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_buffer_allocator.h"
 #include "net/third_party/quiche/src/quic/core/quic_data_reader.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
@@ -16,7 +17,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/quic/qbone/platform/icmp_packet.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_constants.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 ABSL_FLAG(
     bool,
@@ -79,7 +79,7 @@
   if (frame.offset == 0 && frame.fin && frame.data_length > 0) {
     ++num_ephemeral_packets_;
     ProcessPacketFromPeer(
-        quiche::QuicheStringPiece(frame.data_buffer, frame.data_length));
+        absl::string_view(frame.data_buffer, frame.data_length));
     flow_controller()->AddBytesConsumed(frame.data_length);
     // TODO(b/147817422): Add a counter for how many streams were actually
     // closed here.
@@ -91,7 +91,7 @@
   QuicSession::OnStreamFrame(frame);
 }
 
-void QboneSessionBase::OnMessageReceived(quiche::QuicheStringPiece message) {
+void QboneSessionBase::OnMessageReceived(absl::string_view message) {
   ++num_message_packets_;
   ProcessPacketFromPeer(message);
 }
@@ -136,7 +136,7 @@
   return raw;
 }
 
-void QboneSessionBase::SendPacketToPeer(quiche::QuicheStringPiece packet) {
+void QboneSessionBase::SendPacketToPeer(absl::string_view packet) {
   if (crypto_stream_ == nullptr) {
     QUIC_BUG << "Attempting to send packet before encryption established";
     return;
@@ -162,7 +162,7 @@
             connection()->GetGuaranteedLargestMessagePayload();
 
         CreateIcmpPacket(header->ip6_dst, header->ip6_src, icmp_header, packet,
-                         [this](quiche::QuicheStringPiece icmp_packet) {
+                         [this](absl::string_view icmp_packet) {
                            writer_->WritePacketToNetwork(icmp_packet.data(),
                                                          icmp_packet.size());
                          });
diff --git a/quic/qbone/qbone_session_base.h b/quic/qbone/qbone_session_base.h
index 4b95130..222999b 100644
--- a/quic/qbone/qbone_session_base.h
+++ b/quic/qbone/qbone_session_base.h
@@ -5,6 +5,7 @@
 #ifndef QUICHE_QUIC_QBONE_QBONE_SESSION_BASE_H_
 #define QUICHE_QUIC_QBONE_QBONE_SESSION_BASE_H_
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_crypto_server_stream_base.h"
 #include "net/third_party/quiche/src/quic/core/quic_crypto_stream.h"
 #include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
@@ -13,7 +14,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_packet_writer.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_stream.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -34,10 +34,10 @@
   // This will check if the packet is wholly contained.
   void OnStreamFrame(const QuicStreamFrame& frame) override;
   // Called whenever a MESSAGE frame is received.
-  void OnMessageReceived(quiche::QuicheStringPiece message) override;
+  void OnMessageReceived(absl::string_view message) override;
 
-  virtual void ProcessPacketFromNetwork(quiche::QuicheStringPiece packet) = 0;
-  virtual void ProcessPacketFromPeer(quiche::QuicheStringPiece packet) = 0;
+  virtual void ProcessPacketFromNetwork(absl::string_view packet) = 0;
+  virtual void ProcessPacketFromPeer(absl::string_view packet) = 0;
 
   // Returns the number of QBONE network packets that were received
   // that fit into a single QuicStreamFrame and elided the creation of
@@ -86,7 +86,7 @@
   // packet. This function will return true if a stream was created
   // and the packet sent. It will return false if the stream could not
   // be created.
-  void SendPacketToPeer(quiche::QuicheStringPiece packet);
+  void SendPacketToPeer(absl::string_view packet);
 
   QbonePacketWriter* writer_;
 
diff --git a/quic/qbone/qbone_session_test.cc b/quic/qbone/qbone_session_test.cc
index 31129c2..92f8fa7 100644
--- a/quic/qbone/qbone_session_test.cc
+++ b/quic/qbone/qbone_session_test.cc
@@ -4,6 +4,7 @@
 
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/proto/crypto_server_config_proto.h"
 #include "net/third_party/quiche/src/quic/core/quic_alarm_factory.h"
 #include "net/third_party/quiche/src/quic/core/quic_epoll_alarm_factory.h"
@@ -22,7 +23,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_session_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 {
@@ -77,7 +77,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 {
     if (!proof_source_) {
       QuicReferenceCountedPointer<ProofSource::Chain> chain =
@@ -107,7 +107,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 {
     if (!proof_source_) {
       callback->Run(/*ok=*/true, "Signature", /*details=*/nullptr);
@@ -141,7 +141,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,
@@ -416,7 +416,7 @@
 
     std::string expected;
     CreateIcmpPacket(header->ip6_dst, header->ip6_src, icmp_header, packet,
-                     [&expected](quiche::QuicheStringPiece icmp_packet) {
+                     [&expected](absl::string_view icmp_packet) {
                        expected = std::string(icmp_packet);
                      });
 
diff --git a/quic/qbone/qbone_stream.cc b/quic/qbone/qbone_stream.cc
index 4d18889..db499ba 100644
--- a/quic/qbone/qbone_stream.cc
+++ b/quic/qbone/qbone_stream.cc
@@ -4,12 +4,12 @@
 
 #include "net/third_party/quiche/src/quic/qbone/qbone_stream.h"
 
+#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_data_writer.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_constants.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_session_base.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 ABSL_FLAG(int, qbone_stream_ttl_secs, 3, "The QBONE Stream TTL in seconds.");
 
@@ -24,8 +24,7 @@
       QuicTime::Delta::FromSeconds(GetQuicFlag(FLAGS_qbone_stream_ttl_secs)));
 }
 
-void QboneWriteOnlyStream::WritePacketToQuicStream(
-    quiche::QuicheStringPiece packet) {
+void QboneWriteOnlyStream::WritePacketToQuicStream(absl::string_view packet) {
   // Streams are one way and ephemeral. This function should only be
   // called once.
   WriteOrBufferData(packet, /* fin= */ true, nullptr);
diff --git a/quic/qbone/qbone_stream.h b/quic/qbone/qbone_stream.h
index 8a6313b..c27a91a 100644
--- a/quic/qbone/qbone_stream.h
+++ b/quic/qbone/qbone_stream.h
@@ -5,10 +5,10 @@
 #ifndef QUICHE_QUIC_QBONE_QBONE_STREAM_H_
 #define QUICHE_QUIC_QBONE_QBONE_STREAM_H_
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_session.h"
 #include "net/third_party/quiche/src/quic/core/quic_stream.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,7 +26,7 @@
   void OnDataAvailable() override {}
 
   // Write a network packet over the quic stream.
-  void WritePacketToQuicStream(quiche::QuicheStringPiece packet);
+  void WritePacketToQuicStream(absl::string_view packet);
 };
 
 // QboneReadOnlyStream will be used if we find an incoming stream that
diff --git a/quic/qbone/qbone_stream_test.cc b/quic/qbone/qbone_stream_test.cc
index fa43c5b..702b2a4 100644
--- a/quic/qbone/qbone_stream_test.cc
+++ b/quic/qbone/qbone_stream_test.cc
@@ -6,6 +6,7 @@
 
 #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/core/quic_session.h"
 #include "net/third_party/quiche/src/quic/core/quic_simple_buffer_allocator.h"
@@ -16,7 +17,6 @@
 #include "net/third_party/quiche/src/quic/qbone/qbone_session_base.h"
 #include "net/third_party/quiche/src/quic/test_tools/mock_clock.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/spdy/core/spdy_protocol.h"
 
 namespace quic {
@@ -89,14 +89,8 @@
     return nullptr;
   }
 
-  MOCK_METHOD(void,
-              ProcessPacketFromPeer,
-              (quiche::QuicheStringPiece),
-              (override));
-  MOCK_METHOD(void,
-              ProcessPacketFromNetwork,
-              (quiche::QuicheStringPiece),
-              (override));
+  MOCK_METHOD(void, ProcessPacketFromPeer, (absl::string_view), (override));
+  MOCK_METHOD(void, ProcessPacketFromNetwork, (absl::string_view), (override));
 
  private:
   // Whether data is written to write_buffer_.