diff --git a/quic/qbone/bonnet/icmp_reachable.cc b/quic/qbone/bonnet/icmp_reachable.cc
index a6913d1..47cd3ec 100644
--- a/quic/qbone/bonnet/icmp_reachable.cc
+++ b/quic/qbone/bonnet/icmp_reachable.cc
@@ -9,9 +9,10 @@
 #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/quic/platform/api/quic_mutex.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
 #include "net/third_party/quiche/src/quic/qbone/platform/icmp_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"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 namespace quic {
 namespace {
@@ -126,7 +127,8 @@
     return false;
   }
 
-  QUIC_VLOG(2) << QuicTextUtils::HexDump(QuicStringPiece(buffer, size));
+  QUIC_VLOG(2) << quiche::QuicheTextUtils::HexDump(
+      quiche::QuicheStringPiece(buffer, size));
 
   auto* header = reinterpret_cast<const icmp6_hdr*>(&buffer);
   QuicWriterMutexLock mu(&header_lock_);
@@ -166,8 +168,8 @@
 
   icmp_header_.icmp6_seq++;
   CreateIcmpPacket(src_.sin6_addr, dst_.sin6_addr, icmp_header_, "",
-                   [this](QuicStringPiece packet) {
-                     QUIC_VLOG(2) << QuicTextUtils::HexDump(packet);
+                   [this](quiche::QuicheStringPiece packet) {
+                     QUIC_VLOG(2) << quiche::QuicheTextUtils::HexDump(packet);
 
                      ssize_t size = kernel_->sendto(
                          send_fd_, packet.data(), packet.size(), 0,
@@ -183,7 +185,8 @@
   return absl::ToUnixMicros(absl::Now() + timeout_);
 }
 
-QuicStringPiece IcmpReachable::StatusName(IcmpReachable::Status status) {
+quiche::QuicheStringPiece IcmpReachable::StatusName(
+    IcmpReachable::Status status) {
   switch (status) {
     case REACHABLE:
       return "REACHABLE";
diff --git a/quic/qbone/bonnet/icmp_reachable.h b/quic/qbone/bonnet/icmp_reachable.h
index b4ce4c1..c9016d6 100644
--- a/quic/qbone/bonnet/icmp_reachable.h
+++ b/quic/qbone/bonnet/icmp_reachable.h
@@ -9,9 +9,9 @@
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_ip_address.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_mutex.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
 #include "net/third_party/quiche/src/quic/qbone/bonnet/icmp_reachable_interface.h"
 #include "net/third_party/quiche/src/quic/qbone/platform/kernel_interface.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -80,7 +80,7 @@
   int64 /* allow-non-std-int */ OnAlarm()
       QUIC_LOCKS_EXCLUDED(header_lock_) override;
 
-  static QuicStringPiece StatusName(Status status);
+  static quiche::QuicheStringPiece StatusName(Status status);
 
  private:
   class EpollCallback : public QuicEpollCallbackInterface {
diff --git a/quic/qbone/bonnet/tun_device_packet_exchanger.cc b/quic/qbone/bonnet/tun_device_packet_exchanger.cc
index 37fd2c0..c9c9edf 100644
--- a/quic/qbone/bonnet/tun_device_packet_exchanger.cc
+++ b/quic/qbone/bonnet/tun_device_packet_exchanger.cc
@@ -6,7 +6,7 @@
 
 #include <utility>
 
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
 
 namespace quic {
 
@@ -29,7 +29,8 @@
                                            string* error) {
   *blocked = false;
   if (fd_ < 0) {
-    *error = QuicStrCat("Invalid file descriptor of the TUN device: ", fd_);
+    *error = quiche::QuicheStrCat("Invalid file descriptor of the TUN device: ",
+                                  fd_);
     stats_->OnWriteError(error);
     return false;
   }
@@ -40,7 +41,8 @@
       // The tunnel is blocked. Note that this does not mean the receive buffer
       // of a TCP connection is filled. This simply means the TUN device itself
       // is blocked on handing packets to the rest part of the kernel.
-      *error = QuicStrCat("Write to the TUN device was blocked: ", errno);
+      *error =
+          quiche::QuicheStrCat("Write to the TUN device was blocked: ", errno);
       *blocked = true;
       stats_->OnWriteError(error);
     }
@@ -55,7 +57,8 @@
                                                                string* error) {
   *blocked = false;
   if (fd_ < 0) {
-    *error = QuicStrCat("Invalid file descriptor of the TUN device: ", fd_);
+    *error = quiche::QuicheStrCat("Invalid file descriptor of the TUN device: ",
+                                  fd_);
     stats_->OnReadError(error);
     return nullptr;
   }
@@ -67,7 +70,8 @@
   // is no end of file. Therefore 0 also indicates error.
   if (result <= 0) {
     if (errno == EAGAIN || errno == EWOULDBLOCK) {
-      *error = QuicStrCat("Read from the TUN device was blocked: ", errno);
+      *error =
+          quiche::QuicheStrCat("Read from the TUN device was blocked: ", errno);
       *blocked = true;
       stats_->OnReadError(error);
     }
diff --git a/quic/qbone/mock_qbone_client.h b/quic/qbone/mock_qbone_client.h
index 37df26d..0a089ea 100644
--- a/quic/qbone/mock_qbone_client.h
+++ b/quic/qbone/mock_qbone_client.h
@@ -7,12 +7,14 @@
 
 #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 {
 
 class MockQboneClient : public QboneClientInterface {
  public:
-  MOCK_METHOD1(ProcessPacketFromNetwork, void(QuicStringPiece packet));
+  MOCK_METHOD1(ProcessPacketFromNetwork,
+               void(quiche::QuicheStringPiece packet));
 };
 
 }  // namespace quic
diff --git a/quic/qbone/mock_qbone_server_session.h b/quic/qbone/mock_qbone_server_session.h
index 652c017..874ad21 100644
--- a/quic/qbone/mock_qbone_server_session.h
+++ b/quic/qbone/mock_qbone_server_session.h
@@ -27,8 +27,8 @@
 
   MOCK_METHOD1(SendClientRequest, bool(const QboneClientRequest&));
 
-  MOCK_METHOD1(ProcessPacketFromNetwork, void(QuicStringPiece));
-  MOCK_METHOD1(ProcessPacketFromPeer, void(QuicStringPiece));
+  MOCK_METHOD1(ProcessPacketFromNetwork, void(quiche::QuicheStringPiece));
+  MOCK_METHOD1(ProcessPacketFromPeer, void(quiche::QuicheStringPiece));
 };
 
 }  // namespace quic
diff --git a/quic/qbone/platform/icmp_packet.cc b/quic/qbone/platform/icmp_packet.cc
index 9039944..e64dbba 100644
--- a/quic/qbone/platform/icmp_packet.cc
+++ b/quic/qbone/platform/icmp_packet.cc
@@ -8,6 +8,7 @@
 
 #include "net/third_party/quiche/src/quic/qbone/platform/internet_checksum.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace {
@@ -35,11 +36,12 @@
 
 }  // namespace
 
-void CreateIcmpPacket(in6_addr src,
-                      in6_addr dst,
-                      const icmp6_hdr& icmp_header,
-                      QuicStringPiece body,
-                      const std::function<void(QuicStringPiece)>& cb) {
+void CreateIcmpPacket(
+    in6_addr src,
+    in6_addr dst,
+    const icmp6_hdr& icmp_header,
+    quiche::QuicheStringPiece body,
+    const std::function<void(quiche::QuicheStringPiece)>& cb) {
   const size_t body_size = std::min(body.size(), kICMPv6BodyMaxSize);
   const size_t payload_size = kICMPv6HeaderSize + body_size;
 
@@ -80,7 +82,7 @@
   const char* packet = reinterpret_cast<char*>(&icmp_packet);
   const size_t packet_size = offsetof(ICMPv6Packet, body) + body_size;
 
-  cb(QuicStringPiece(packet, packet_size));
+  cb(quiche::QuicheStringPiece(packet, packet_size));
 }
 
 }  // namespace quic
diff --git a/quic/qbone/platform/icmp_packet.h b/quic/qbone/platform/icmp_packet.h
index ae440d2..a762679 100644
--- a/quic/qbone/platform/icmp_packet.h
+++ b/quic/qbone/platform/icmp_packet.h
@@ -11,7 +11,7 @@
 #include <functional>
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_ip_address.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -21,8 +21,8 @@
 void CreateIcmpPacket(in6_addr src,
                       in6_addr dst,
                       const icmp6_hdr& icmp_header,
-                      quic::QuicStringPiece body,
-                      const std::function<void(quic::QuicStringPiece)>& cb);
+                      quiche::QuicheStringPiece body,
+                      const std::function<void(quiche::QuicheStringPiece)>& cb);
 
 }  // namespace quic
 
diff --git a/quic/qbone/platform/icmp_packet_test.cc b/quic/qbone/platform/icmp_packet_test.cc
index 1aeabe0..30fbe21 100644
--- a/quic/qbone/platform/icmp_packet_test.cc
+++ b/quic/qbone/platform/icmp_packet_test.cc
@@ -9,7 +9,8 @@
 #include <cstdint>
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_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 {
 namespace {
@@ -84,13 +85,13 @@
   icmp_header.icmp6_id = 0x82cb;
   icmp_header.icmp6_seq = 0x0100;
 
-  QuicStringPiece message_body = QuicStringPiece(
+  quiche::QuicheStringPiece message_body = quiche::QuicheStringPiece(
       reinterpret_cast<const char*>(kReferenceICMPMessageBody), 56);
-  QuicStringPiece expected_packet =
-      QuicStringPiece(reinterpret_cast<const char*>(kReferenceICMPPacket), 104);
+  quiche::QuicheStringPiece expected_packet = quiche::QuicheStringPiece(
+      reinterpret_cast<const char*>(kReferenceICMPPacket), 104);
   CreateIcmpPacket(src_addr, dst_addr, icmp_header, message_body,
-                   [&expected_packet](QuicStringPiece packet) {
-                     QUIC_LOG(INFO) << QuicTextUtils::HexDump(packet);
+                   [&expected_packet](quiche::QuicheStringPiece packet) {
+                     QUIC_LOG(INFO) << quiche::QuicheTextUtils::HexDump(packet);
                      ASSERT_EQ(packet, expected_packet);
                    });
 }
@@ -113,13 +114,13 @@
   // Set the checksum to a bogus value
   icmp_header.icmp6_cksum = 0x1234;
 
-  QuicStringPiece message_body = QuicStringPiece(
+  quiche::QuicheStringPiece message_body = quiche::QuicheStringPiece(
       reinterpret_cast<const char*>(kReferenceICMPMessageBody), 56);
-  QuicStringPiece expected_packet =
-      QuicStringPiece(reinterpret_cast<const char*>(kReferenceICMPPacket), 104);
+  quiche::QuicheStringPiece expected_packet = quiche::QuicheStringPiece(
+      reinterpret_cast<const char*>(kReferenceICMPPacket), 104);
   CreateIcmpPacket(src_addr, dst_addr, icmp_header, message_body,
-                   [&expected_packet](QuicStringPiece packet) {
-                     QUIC_LOG(INFO) << QuicTextUtils::HexDump(packet);
+                   [&expected_packet](quiche::QuicheStringPiece packet) {
+                     QUIC_LOG(INFO) << quiche::QuicheTextUtils::HexDump(packet);
                      ASSERT_EQ(packet, expected_packet);
                    });
 }
diff --git a/quic/qbone/platform/ip_range.h b/quic/qbone/platform/ip_range.h
index 545c32c..cc84bb2 100644
--- a/quic/qbone/platform/ip_range.h
+++ b/quic/qbone/platform/ip_range.h
@@ -6,7 +6,7 @@
 #define QUICHE_QUIC_QBONE_PLATFORM_IP_RANGE_H_
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_ip_address.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
 
 namespace quic {
 
@@ -29,7 +29,7 @@
   // Returns the string representation of this object.
   string ToString() const {
     if (IsInitialized()) {
-      return absl::StrCat(prefix_.ToString(), "/", prefix_length_);
+      return quiche::QuicheStrCat(prefix_.ToString(), "/", prefix_length_);
     }
     return "(uninitialized)";
   }
diff --git a/quic/qbone/platform/netlink.cc b/quic/qbone/platform/netlink.cc
index da68e54..307d2bc 100644
--- a/quic/qbone/platform/netlink.cc
+++ b/quic/qbone/platform/netlink.cc
@@ -11,9 +11,9 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_fallthrough.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_ip_address.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
 #include "net/quic/platform/impl/quic_ip_address_impl.h"
 #include "net/third_party/quiche/src/quic/qbone/platform/rtnetlink_message.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
 
 namespace quic {
 
@@ -80,7 +80,7 @@
 
   void Run(struct nlmsghdr* netlink_message) override {
     if (netlink_message->nlmsg_type != RTM_NEWLINK) {
-      QUIC_LOG(INFO) << QuicStrCat(
+      QUIC_LOG(INFO) << quiche::QuicheStrCat(
           "Unexpected nlmsg_type: ", netlink_message->nlmsg_type,
           " expected: ", RTM_NEWLINK);
       return;
@@ -91,7 +91,7 @@
 
     // make sure interface_info is what we asked for.
     if (interface_info->ifi_family != AF_UNSPEC) {
-      QUIC_LOG(INFO) << QuicStrCat(
+      QUIC_LOG(INFO) << quiche::QuicheStrCat(
           "Unexpected ifi_family: ", interface_info->ifi_family,
           " expected: ", AF_UNSPEC);
       return;
@@ -220,8 +220,8 @@
     // Make sure this is for an address family we're interested in.
     if (interface_address->ifa_family != AF_INET &&
         interface_address->ifa_family != AF_INET6) {
-      QUIC_VLOG(2) << QuicStrCat("uninteresting ifa family: ",
-                                 interface_address->ifa_family);
+      QUIC_VLOG(2) << quiche::QuicheStrCat("uninteresting ifa family: ",
+                                           interface_address->ifa_family);
       return;
     }
 
@@ -235,7 +235,8 @@
 
     uint8_t unwanted_flags = interface_address->ifa_flags & unwanted_flags_;
     if (unwanted_flags != 0) {
-      QUIC_VLOG(2) << QuicStrCat("unwanted ifa flags: ", unwanted_flags);
+      QUIC_VLOG(2) << quiche::QuicheStrCat("unwanted ifa flags: ",
+                                           unwanted_flags);
       return;
     }
 
@@ -274,8 +275,8 @@
           }
           break;
         default:
-          QUIC_LOG(ERROR) << QuicStrCat("Unknown address family: ",
-                                        interface_address->ifa_family);
+          QUIC_LOG(ERROR) << quiche::QuicheStrCat(
+              "Unknown address family: ", interface_address->ifa_family);
       }
     }
 
@@ -411,7 +412,7 @@
 
   void Run(struct nlmsghdr* netlink_message) override {
     if (netlink_message->nlmsg_type != RTM_NEWROUTE) {
-      QUIC_LOG(WARNING) << QuicStrCat(
+      QUIC_LOG(WARNING) << quiche::QuicheStrCat(
           "Unexpected nlmsg_type: ", netlink_message->nlmsg_type,
           " expected: ", RTM_NEWROUTE);
       return;
@@ -421,7 +422,8 @@
     int payload_length = RTM_PAYLOAD(netlink_message);
 
     if (route->rtm_family != AF_INET && route->rtm_family != AF_INET6) {
-      QUIC_VLOG(2) << QuicStrCat("Uninteresting family: ", route->rtm_family);
+      QUIC_VLOG(2) << quiche::QuicheStrCat("Uninteresting family: ",
+                                           route->rtm_family);
       return;
     }
 
@@ -455,8 +457,8 @@
           break;
         }
         default: {
-          QUIC_VLOG(2) << QuicStrCat("Uninteresting attribute: ",
-                                     rta->rta_type);
+          QUIC_VLOG(2) << quiche::QuicheStrCat("Uninteresting attribute: ",
+                                               rta->rta_type);
         }
       }
     }
@@ -598,7 +600,7 @@
 
   void Run(struct nlmsghdr* netlink_message) override {
     if (netlink_message->nlmsg_type != RTM_NEWRULE) {
-      QUIC_LOG(WARNING) << QuicStrCat(
+      QUIC_LOG(WARNING) << quiche::QuicheStrCat(
           "Unexpected nlmsg_type: ", netlink_message->nlmsg_type,
           " expected: ", RTM_NEWRULE);
       return;
@@ -608,7 +610,8 @@
     int payload_length = RTM_PAYLOAD(netlink_message);
 
     if (rule->rtm_family != AF_INET6) {
-      QUIC_LOG(ERROR) << QuicStrCat("Unexpected family: ", rule->rtm_family);
+      QUIC_LOG(ERROR) << quiche::QuicheStrCat("Unexpected family: ",
+                                              rule->rtm_family);
       return;
     }
 
@@ -632,8 +635,8 @@
           break;
         }
         default: {
-          QUIC_VLOG(2) << QuicStrCat("Uninteresting attribute: ",
-                                     rta->rta_type);
+          QUIC_VLOG(2) << quiche::QuicheStrCat("Uninteresting attribute: ",
+                                               rta->rta_type);
         }
       }
     }
diff --git a/quic/qbone/platform/rtnetlink_message.h b/quic/qbone/platform/rtnetlink_message.h
index 0412d54..f36cd4c 100644
--- a/quic/qbone/platform/rtnetlink_message.h
+++ b/quic/qbone/platform/rtnetlink_message.h
@@ -15,7 +15,6 @@
 #include <vector>
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
 
 namespace quic {
 
diff --git a/quic/qbone/platform/tcp_packet.cc b/quic/qbone/platform/tcp_packet.cc
index 2566d25..6da9faa 100644
--- a/quic/qbone/platform/tcp_packet.cc
+++ b/quic/qbone/platform/tcp_packet.cc
@@ -9,6 +9,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/quic/qbone/platform/internet_checksum.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace {
@@ -30,8 +31,8 @@
 }  // namespace
 
 void CreateTcpResetPacket(
-    quic::QuicStringPiece original_packet,
-    const std::function<void(quic::QuicStringPiece)>& cb) {
+    quiche::QuicheStringPiece original_packet,
+    const std::function<void(quiche::QuicheStringPiece)>& cb) {
   // By the time this method is called, original_packet should be fairly
   // strongly validated. However, it's better to be more paranoid than not, so
   // here are a bunch of very obvious checks.
@@ -120,7 +121,7 @@
 
   const char* packet = reinterpret_cast<char*>(&tcp_packet);
 
-  cb(QuicStringPiece(packet, sizeof(tcp_packet)));
+  cb(quiche::QuicheStringPiece(packet, sizeof(tcp_packet)));
 }
 
 }  // namespace quic
diff --git a/quic/qbone/platform/tcp_packet.h b/quic/qbone/platform/tcp_packet.h
index cf33f03..bb1364b 100644
--- a/quic/qbone/platform/tcp_packet.h
+++ b/quic/qbone/platform/tcp_packet.h
@@ -11,14 +11,15 @@
 #include <functional>
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_ip_address.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
 // Creates an TCPv6 RST packet, returning a packed string representation of the
 // packet to |cb|.
-void CreateTcpResetPacket(quic::QuicStringPiece original_packet,
-                          const std::function<void(quic::QuicStringPiece)>& cb);
+void CreateTcpResetPacket(
+    quiche::QuicheStringPiece original_packet,
+    const std::function<void(quiche::QuicheStringPiece)>& cb);
 
 }  // namespace quic
 
diff --git a/quic/qbone/platform/tcp_packet_test.cc b/quic/qbone/platform/tcp_packet_test.cc
index 53a2c3f..84645c8 100644
--- a/quic/qbone/platform/tcp_packet_test.cc
+++ b/quic/qbone/platform/tcp_packet_test.cc
@@ -9,7 +9,8 @@
 #include <cstdint>
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_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 {
 namespace {
@@ -101,16 +102,17 @@
 }  // namespace
 
 TEST(TcpPacketTest, CreatedPacketMatchesReference) {
-  QuicStringPiece syn =
-      QuicStringPiece(reinterpret_cast<const char*>(kReferenceTCPSYNPacket),
-                      sizeof(kReferenceTCPSYNPacket));
-  QuicStringPiece expected_packet =
-      QuicStringPiece(reinterpret_cast<const char*>(kReferenceTCPRSTPacket),
-                      sizeof(kReferenceTCPRSTPacket));
-  CreateTcpResetPacket(syn, [&expected_packet](QuicStringPiece packet) {
-    QUIC_LOG(INFO) << QuicTextUtils::HexDump(packet);
-    ASSERT_EQ(packet, expected_packet);
-  });
+  quiche::QuicheStringPiece syn = quiche::QuicheStringPiece(
+      reinterpret_cast<const char*>(kReferenceTCPSYNPacket),
+      sizeof(kReferenceTCPSYNPacket));
+  quiche::QuicheStringPiece expected_packet = quiche::QuicheStringPiece(
+      reinterpret_cast<const char*>(kReferenceTCPRSTPacket),
+      sizeof(kReferenceTCPRSTPacket));
+  CreateTcpResetPacket(
+      syn, [&expected_packet](quiche::QuicheStringPiece packet) {
+        QUIC_LOG(INFO) << quiche::QuicheTextUtils::HexDump(packet);
+        ASSERT_EQ(packet, expected_packet);
+      });
 }
 
 }  // namespace quic
diff --git a/quic/qbone/qbone_client.cc b/quic/qbone/qbone_client.cc
index 73869d8..2b1f7e4 100644
--- a/quic/qbone/qbone_client.cc
+++ b/quic/qbone/qbone_client.cc
@@ -11,6 +11,7 @@
 #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 {
@@ -57,7 +58,7 @@
   return static_cast<QboneClientSession*>(QuicClientBase::session());
 }
 
-void QboneClient::ProcessPacketFromNetwork(QuicStringPiece packet) {
+void QboneClient::ProcessPacketFromNetwork(quiche::QuicheStringPiece packet) {
   qbone_session()->ProcessPacketFromNetwork(packet);
 }
 
diff --git a/quic/qbone/qbone_client.h b/quic/qbone/qbone_client.h
index a0fe4fc..2a27ddc 100644
--- a/quic/qbone/qbone_client.h
+++ b/quic/qbone/qbone_client.h
@@ -10,6 +10,7 @@
 #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
@@ -33,7 +34,7 @@
 
   // From QboneClientInterface. Accepts a given packet from the network and
   // sends the packet down to the QBONE connection.
-  void ProcessPacketFromNetwork(QuicStringPiece packet) override;
+  void ProcessPacketFromNetwork(quiche::QuicheStringPiece packet) override;
 
  protected:
   int GetNumSentClientHellosFromSession() override;
diff --git a/quic/qbone/qbone_client_interface.h b/quic/qbone/qbone_client_interface.h
index 28d88ac..aec3a8f 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/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.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(QuicStringPiece packet) = 0;
+  virtual void ProcessPacketFromNetwork(quiche::QuicheStringPiece packet) = 0;
 };
 
 }  // namespace quic
diff --git a/quic/qbone/qbone_client_session.cc b/quic/qbone/qbone_client_session.cc
index e59596d..024cb4a 100644
--- a/quic/qbone/qbone_client_session.cc
+++ b/quic/qbone/qbone_client_session.cc
@@ -8,6 +8,7 @@
 
 #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 {
 
@@ -65,11 +66,13 @@
   return control_stream_->SendRequest(request);
 }
 
-void QboneClientSession::ProcessPacketFromNetwork(QuicStringPiece packet) {
+void QboneClientSession::ProcessPacketFromNetwork(
+    quiche::QuicheStringPiece packet) {
   SendPacketToPeer(packet);
 }
 
-void QboneClientSession::ProcessPacketFromPeer(QuicStringPiece packet) {
+void QboneClientSession::ProcessPacketFromPeer(
+    quiche::QuicheStringPiece packet) {
   writer_->WritePacketToNetwork(packet.data(), packet.size());
 }
 
diff --git a/quic/qbone/qbone_client_session.h b/quic/qbone/qbone_client_session.h
index 5dcf2ac..c3dabe9 100644
--- a/quic/qbone/qbone_client_session.h
+++ b/quic/qbone/qbone_client_session.h
@@ -11,6 +11,7 @@
 #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 {
 
@@ -41,8 +42,8 @@
 
   bool SendServerRequest(const QboneServerRequest& request);
 
-  void ProcessPacketFromNetwork(QuicStringPiece packet) override;
-  void ProcessPacketFromPeer(QuicStringPiece packet) override;
+  void ProcessPacketFromNetwork(quiche::QuicheStringPiece packet) override;
+  void ProcessPacketFromPeer(quiche::QuicheStringPiece 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 cb197a2..e24c3c2 100644
--- a/quic/qbone/qbone_client_test.cc
+++ b/quic/qbone/qbone_client_test.cc
@@ -26,6 +26,7 @@
 #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 {
@@ -108,7 +109,7 @@
   QuicSession* CreateQuicSession(
       QuicConnectionId id,
       const QuicSocketAddress& client,
-      QuicStringPiece alpn,
+      quiche::QuicheStringPiece alpn,
       const quic::ParsedQuicVersion& version) override {
     CHECK_EQ(alpn, "qbone");
     QuicConnection* connection =
diff --git a/quic/qbone/qbone_control_stream.cc b/quic/qbone/qbone_control_stream.cc
index 02b1cb8..225d02f 100644
--- a/quic/qbone/qbone_control_stream.cc
+++ b/quic/qbone/qbone_control_stream.cc
@@ -7,6 +7,7 @@
 #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 {
 
@@ -58,8 +59,8 @@
   uint16_t size = tmp.size();
   char size_str[kRequestSizeBytes];
   memcpy(size_str, &size, kRequestSizeBytes);
-  WriteOrBufferData(QuicStringPiece(size_str, kRequestSizeBytes), false,
-                    nullptr);
+  WriteOrBufferData(quiche::QuicheStringPiece(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 3bfb97a..9475e27 100644
--- a/quic/qbone/qbone_packet_processor.cc
+++ b/quic/qbone/qbone_packet_processor.cc
@@ -12,6 +12,7 @@
 #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 {
 
@@ -50,11 +51,12 @@
 QbonePacketProcessor::Filter::~Filter() {}
 
 QbonePacketProcessor::ProcessingResult
-QbonePacketProcessor::Filter::FilterPacket(Direction direction,
-                                           QuicStringPiece full_packet,
-                                           QuicStringPiece payload,
-                                           icmp6_hdr* icmp_header,
-                                           OutputInterface* output) {
+QbonePacketProcessor::Filter::FilterPacket(
+    Direction direction,
+    quiche::QuicheStringPiece full_packet,
+    quiche::QuicheStringPiece payload,
+    icmp6_hdr* icmp_header,
+    OutputInterface* output) {
   return ProcessingResult::OK;
 }
 
@@ -125,7 +127,8 @@
 
     result = filter_->FilterPacket(
         direction, *packet,
-        QuicStringPiece(*transport_data, packet->size() - header_size),
+        quiche::QuicheStringPiece(*transport_data,
+                                  packet->size() - header_size),
         icmp_header, output_);
   }
 
@@ -233,29 +236,32 @@
   return ProcessingResult::OK;
 }
 
-void QbonePacketProcessor::SendIcmpResponse(icmp6_hdr* icmp_header,
-                                            QuicStringPiece original_packet,
-                                            Direction original_direction) {
+void QbonePacketProcessor::SendIcmpResponse(
+    icmp6_hdr* icmp_header,
+    quiche::QuicheStringPiece 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](QuicStringPiece packet) {
-                     SendResponse(original_direction, packet);
-                   });
+  CreateIcmpPacket(
+      self_ip_, dst, *icmp_header, original_packet,
+      [this, original_direction](quiche::QuicheStringPiece packet) {
+        SendResponse(original_direction, packet);
+      });
 }
 
-void QbonePacketProcessor::SendTcpReset(QuicStringPiece original_packet,
-                                        Direction original_direction) {
-  CreateTcpResetPacket(original_packet,
-                       [this, original_direction](QuicStringPiece 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::SendResponse(Direction original_direction,
-                                        QuicStringPiece packet) {
+                                        quiche::QuicheStringPiece 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 04b7412..e163566 100644
--- a/quic/qbone/qbone_packet_processor.h
+++ b/quic/qbone/qbone_packet_processor.h
@@ -10,7 +10,7 @@
 
 #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/quic/platform/api/quic_string_piece.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(QuicStringPiece packet) = 0;
-    virtual void SendPacketToNetwork(QuicStringPiece packet) = 0;
+    virtual void SendPacketToClient(quiche::QuicheStringPiece packet) = 0;
+    virtual void SendPacketToNetwork(quiche::QuicheStringPiece 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,
-                                          QuicStringPiece full_packet,
-                                          QuicStringPiece payload,
+                                          quiche::QuicheStringPiece full_packet,
+                                          quiche::QuicheStringPiece payload,
                                           icmp6_hdr* icmp_header,
                                           OutputInterface* output);
 
@@ -104,16 +104,19 @@
     // 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(QuicStringPiece ipv6_header) {
+    inline uint8_t TransportProtocolFromHeader(
+        quiche::QuicheStringPiece ipv6_header) {
       return ipv6_header[6];
     }
-    inline QuicIpAddress SourceIpFromHeader(QuicStringPiece ipv6_header) {
+    inline QuicIpAddress SourceIpFromHeader(
+        quiche::QuicheStringPiece ipv6_header) {
       QuicIpAddress address;
       address.FromPackedString(&ipv6_header[8],
                                QuicIpAddress::kIPv6AddressSize);
       return address;
     }
-    inline QuicIpAddress DestinationIpFromHeader(QuicStringPiece ipv6_header) {
+    inline QuicIpAddress DestinationIpFromHeader(
+        quiche::QuicheStringPiece ipv6_header) {
       QuicIpAddress address;
       address.FromPackedString(&ipv6_header[24],
                                QuicIpAddress::kIPv6AddressSize);
@@ -164,10 +167,10 @@
                                               icmp6_hdr* icmp_header);
 
   void SendIcmpResponse(icmp6_hdr* icmp_header,
-                        QuicStringPiece original_packet,
+                        quiche::QuicheStringPiece original_packet,
                         Direction original_direction);
 
-  void SendTcpReset(QuicStringPiece original_packet,
+  void SendTcpReset(quiche::QuicheStringPiece original_packet,
                     Direction original_direction);
 
   inline bool IsValid() const { return client_ip_ != kInvalidIpAddress; }
@@ -191,7 +194,8 @@
                                      char** transport_data,
                                      icmp6_hdr* icmp_header);
 
-  void SendResponse(Direction original_direction, QuicStringPiece packet);
+  void SendResponse(Direction original_direction,
+                    quiche::QuicheStringPiece packet);
 };
 
 }  // namespace quic
diff --git a/quic/qbone/qbone_packet_processor_test.cc b/quic/qbone/qbone_packet_processor_test.cc
index a2b0201..8258917 100644
--- a/quic/qbone/qbone_packet_processor_test.cc
+++ b/quic/qbone/qbone_packet_processor_test.cc
@@ -8,6 +8,7 @@
 
 #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 {
@@ -100,15 +101,15 @@
 
 // clang-format on
 
-static const QuicStringPiece kReferenceClientPacket(
+static const quiche::QuicheStringPiece kReferenceClientPacket(
     kReferenceClientPacketData,
     arraysize(kReferenceClientPacketData));
 
-static const QuicStringPiece kReferenceNetworkPacket(
+static const quiche::QuicheStringPiece kReferenceNetworkPacket(
     kReferenceNetworkPacketData,
     arraysize(kReferenceNetworkPacketData));
 
-static const QuicStringPiece kReferenceClientSubnetPacket(
+static const quiche::QuicheStringPiece kReferenceClientSubnetPacket(
     kReferenceClientSubnetPacketData,
     arraysize(kReferenceClientSubnetPacketData));
 
@@ -126,8 +127,8 @@
  public:
   MOCK_METHOD5(FilterPacket,
                ProcessingResult(Direction,
-                                QuicStringPiece,
-                                QuicStringPiece,
+                                quiche::QuicheStringPiece,
+                                quiche::QuicheStringPiece,
                                 icmp6_hdr*,
                                 OutputInterface*));
 };
@@ -144,12 +145,12 @@
         &stats_);
   }
 
-  void SendPacketFromClient(QuicStringPiece packet) {
+  void SendPacketFromClient(quiche::QuicheStringPiece packet) {
     string packet_buffer(packet.data(), packet.size());
     processor_->ProcessPacket(&packet_buffer, Direction::FROM_OFF_NETWORK);
   }
 
-  void SendPacketFromNetwork(QuicStringPiece packet) {
+  void SendPacketFromNetwork(quiche::QuicheStringPiece packet) {
     string packet_buffer(packet.data(), packet.size());
     processor_->ProcessPacket(&packet_buffer, Direction::FROM_NETWORK);
   }
@@ -246,8 +247,8 @@
   TestFilter(QuicIpAddress client_ip, QuicIpAddress network_ip)
       : client_ip_(client_ip), network_ip_(network_ip) {}
   ProcessingResult FilterPacket(Direction direction,
-                                QuicStringPiece full_packet,
-                                QuicStringPiece payload,
+                                quiche::QuicheStringPiece full_packet,
+                                quiche::QuicheStringPiece 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 646dc42..78dd92d 100644
--- a/quic/qbone/qbone_packet_processor_test_tools.h
+++ b/quic/qbone/qbone_packet_processor_test_tools.h
@@ -7,6 +7,7 @@
 
 #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 {
 
@@ -14,8 +15,8 @@
  public:
   MockPacketProcessorOutput() {}
 
-  MOCK_METHOD1(SendPacketToClient, void(QuicStringPiece));
-  MOCK_METHOD1(SendPacketToNetwork, void(QuicStringPiece));
+  MOCK_METHOD1(SendPacketToClient, void(quiche::QuicheStringPiece));
+  MOCK_METHOD1(SendPacketToNetwork, void(quiche::QuicheStringPiece));
 };
 
 class MockPacketProcessorStats : public QbonePacketProcessor::StatsInterface {
diff --git a/quic/qbone/qbone_server_session.cc b/quic/qbone/qbone_server_session.cc
index 1360e6d..c5456bf 100644
--- a/quic/qbone/qbone_server_session.cc
+++ b/quic/qbone/qbone_server_session.cc
@@ -10,6 +10,7 @@
 #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 {
 
@@ -71,23 +72,25 @@
   return control_stream_->SendRequest(request);
 }
 
-void QboneServerSession::ProcessPacketFromNetwork(QuicStringPiece packet) {
+void QboneServerSession::ProcessPacketFromNetwork(
+    quiche::QuicheStringPiece packet) {
   string buffer = string(packet);
   processor_.ProcessPacket(&buffer,
                            QbonePacketProcessor::Direction::FROM_NETWORK);
 }
 
-void QboneServerSession::ProcessPacketFromPeer(QuicStringPiece packet) {
+void QboneServerSession::ProcessPacketFromPeer(
+    quiche::QuicheStringPiece packet) {
   string buffer = string(packet);
   processor_.ProcessPacket(&buffer,
                            QbonePacketProcessor::Direction::FROM_OFF_NETWORK);
 }
 
-void QboneServerSession::SendPacketToClient(QuicStringPiece packet) {
+void QboneServerSession::SendPacketToClient(quiche::QuicheStringPiece packet) {
   SendPacketToPeer(packet);
 }
 
-void QboneServerSession::SendPacketToNetwork(QuicStringPiece packet) {
+void QboneServerSession::SendPacketToNetwork(quiche::QuicheStringPiece 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 9536f87..db3381f 100644
--- a/quic/qbone/qbone_server_session.h
+++ b/quic/qbone/qbone_server_session.h
@@ -13,6 +13,7 @@
 #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 {
 
@@ -51,12 +52,12 @@
 
   virtual bool SendClientRequest(const QboneClientRequest& request);
 
-  void ProcessPacketFromNetwork(QuicStringPiece packet) override;
-  void ProcessPacketFromPeer(QuicStringPiece packet) override;
+  void ProcessPacketFromNetwork(quiche::QuicheStringPiece packet) override;
+  void ProcessPacketFromPeer(quiche::QuicheStringPiece packet) override;
 
   // QbonePacketProcessor::OutputInterface implementation.
-  void SendPacketToClient(QuicStringPiece packet) override;
-  void SendPacketToNetwork(QuicStringPiece packet) override;
+  void SendPacketToClient(quiche::QuicheStringPiece packet) override;
+  void SendPacketToNetwork(quiche::QuicheStringPiece 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 c3e7731..e3fbb6e 100644
--- a/quic/qbone/qbone_session_base.cc
+++ b/quic/qbone/qbone_session_base.cc
@@ -14,6 +14,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_exported_stats.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"
 
 namespace quic {
 
@@ -79,14 +80,14 @@
   if (frame.offset == 0 && frame.fin && frame.data_length > 0) {
     ++num_ephemeral_packets_;
     ProcessPacketFromPeer(
-        QuicStringPiece(frame.data_buffer, frame.data_length));
+        quiche::QuicheStringPiece(frame.data_buffer, frame.data_length));
     flow_controller()->AddBytesConsumed(frame.data_length);
     return;
   }
   QuicSession::OnStreamFrame(frame);
 }
 
-void QboneSessionBase::OnMessageReceived(QuicStringPiece message) {
+void QboneSessionBase::OnMessageReceived(quiche::QuicheStringPiece message) {
   ++num_message_packets_;
   ProcessPacketFromPeer(message);
 }
@@ -131,7 +132,7 @@
   return raw;
 }
 
-void QboneSessionBase::SendPacketToPeer(QuicStringPiece packet) {
+void QboneSessionBase::SendPacketToPeer(quiche::QuicheStringPiece packet) {
   if (crypto_stream_ == nullptr) {
     QUIC_BUG << "Attempting to send packet before encryption established";
     return;
@@ -156,7 +157,7 @@
             connection()->GetGuaranteedLargestMessagePayload();
 
         CreateIcmpPacket(header->ip6_dst, header->ip6_src, icmp_header, packet,
-                         [this](QuicStringPiece icmp_packet) {
+                         [this](quiche::QuicheStringPiece 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 41afc6b..84498e6 100644
--- a/quic/qbone/qbone_session_base.h
+++ b/quic/qbone/qbone_session_base.h
@@ -13,6 +13,7 @@
 #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 {
 
@@ -36,10 +37,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(QuicStringPiece message) override;
+  void OnMessageReceived(quiche::QuicheStringPiece message) override;
 
-  virtual void ProcessPacketFromNetwork(QuicStringPiece packet) = 0;
-  virtual void ProcessPacketFromPeer(QuicStringPiece packet) = 0;
+  virtual void ProcessPacketFromNetwork(quiche::QuicheStringPiece packet) = 0;
+  virtual void ProcessPacketFromPeer(quiche::QuicheStringPiece packet) = 0;
 
   // Returns the number of qbone network packets that were received
   // that fit into a single QuicStreamFrame and elided the creation of
@@ -88,7 +89,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(QuicStringPiece packet);
+  void SendPacketToPeer(quiche::QuicheStringPiece packet);
 
   QbonePacketWriter* writer_;
 
diff --git a/quic/qbone/qbone_session_test.cc b/quic/qbone/qbone_session_test.cc
index 19ecd2c..0497ace 100644
--- a/quic/qbone/qbone_session_test.cc
+++ b/quic/qbone/qbone_session_test.cc
@@ -11,7 +11,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_port_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test_loopback.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
 #include "net/third_party/quiche/src/quic/qbone/platform/icmp_packet.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_client_session.h"
 #include "net/third_party/quiche/src/quic/qbone/qbone_constants.h"
@@ -22,6 +21,8 @@
 #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 {
 namespace test {
@@ -54,7 +55,7 @@
                 const string& hostname,
                 const string& server_config,
                 QuicTransportVersion transport_version,
-                QuicStringPiece chlo_hash,
+                quiche::QuicheStringPiece chlo_hash,
                 std::unique_ptr<Callback> callback) override {
     QuicReferenceCountedPointer<ProofSource::Chain> chain =
         GetCertChain(server_address, hostname);
@@ -82,7 +83,7 @@
       const QuicSocketAddress& server_address,
       const string& hostname,
       uint16_t signature_algorithm,
-      QuicStringPiece in,
+      quiche::QuicheStringPiece in,
       std::unique_ptr<SignatureCallback> callback) override {
     callback->Run(true, "Signature");
   }
@@ -104,7 +105,7 @@
       const uint16_t port,
       const string& server_config,
       QuicTransportVersion transport_version,
-      QuicStringPiece chlo_hash,
+      quiche::QuicheStringPiece chlo_hash,
       const std::vector<string>& certs,
       const string& cert_sct,
       const string& signature,
@@ -364,7 +365,7 @@
 
     string expected;
     CreateIcmpPacket(header->ip6_dst, header->ip6_src, icmp_header, packet,
-                     [&expected](QuicStringPiece icmp_packet) {
+                     [&expected](quiche::QuicheStringPiece icmp_packet) {
                        expected = string(icmp_packet);
                      });
 
diff --git a/quic/qbone/qbone_stream.cc b/quic/qbone/qbone_stream.cc
index b7ac007..dd9b48c 100644
--- a/quic/qbone/qbone_stream.cc
+++ b/quic/qbone/qbone_stream.cc
@@ -7,10 +7,9 @@
 #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/platform/api/quic_string_piece.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.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"
 
 namespace quic {
 
@@ -22,7 +21,8 @@
   MaybeSetTtl(QuicTime::Delta::FromSeconds(10));
 }
 
-void QboneWriteOnlyStream::WritePacketToQuicStream(QuicStringPiece packet) {
+void QboneWriteOnlyStream::WritePacketToQuicStream(
+    quiche::QuicheStringPiece 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 7368005..6a86e4d 100644
--- a/quic/qbone/qbone_stream.h
+++ b/quic/qbone/qbone_stream.h
@@ -8,6 +8,7 @@
 #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 {
 
@@ -25,7 +26,7 @@
   void OnDataAvailable() override {}
 
   // Write a network packet over the quic stream.
-  void WritePacketToQuicStream(QuicStringPiece packet);
+  void WritePacketToQuicStream(quiche::QuicheStringPiece 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 bb9195b..71f4260 100644
--- a/quic/qbone/qbone_stream_test.cc
+++ b/quic/qbone/qbone_stream_test.cc
@@ -16,6 +16,7 @@
 #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 {
@@ -84,8 +85,8 @@
     return nullptr;
   }
 
-  MOCK_METHOD1(ProcessPacketFromPeer, void(QuicStringPiece));
-  MOCK_METHOD1(ProcessPacketFromNetwork, void(QuicStringPiece));
+  MOCK_METHOD1(ProcessPacketFromPeer, void(quiche::QuicheStringPiece));
+  MOCK_METHOD1(ProcessPacketFromNetwork, void(quiche::QuicheStringPiece));
 
  private:
   // Whether data is written to write_buffer_.