diff --git a/quic/test_tools/crypto_test_utils.cc b/quic/test_tools/crypto_test_utils.cc
index 6716dec..7197427 100644
--- a/quic/test_tools/crypto_test_utils.cc
+++ b/quic/test_tools/crypto_test_utils.cc
@@ -32,12 +32,13 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_framer_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_stream_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/simple_quic_framer.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 namespace quic {
 namespace test {
@@ -175,15 +176,15 @@
     EXPECT_THAT(rej->tag(), testing::Eq(kREJ));
 
     QUIC_VLOG(1) << "Extract valid STK and SCID from\n" << rej->DebugString();
-    QuicStringPiece srct;
+    quiche::QuicheStringPiece srct;
     ASSERT_TRUE(rej->GetStringPiece(kSourceAddressTokenTag, &srct));
 
-    QuicStringPiece scfg;
+    quiche::QuicheStringPiece scfg;
     ASSERT_TRUE(rej->GetStringPiece(kSCFG, &scfg));
     std::unique_ptr<CryptoHandshakeMessage> server_config(
         CryptoFramer::ParseMessage(scfg));
 
-    QuicStringPiece scid;
+    quiche::QuicheStringPiece scid;
     ASSERT_TRUE(server_config->GetStringPiece(kSCID, &scid));
 
     *out_ = result_->client_hello;
@@ -246,9 +247,10 @@
   EXPECT_CALL(*server_conn, OnCanWrite()).Times(testing::AnyNumber());
   EXPECT_CALL(*client_conn, OnCanWrite()).Times(testing::AnyNumber());
   EXPECT_CALL(server_session, SelectAlpn(_))
-      .WillRepeatedly([alpn](const std::vector<QuicStringPiece>& alpns) {
-        return std::find(alpns.cbegin(), alpns.cend(), alpn);
-      });
+      .WillRepeatedly(
+          [alpn](const std::vector<quiche::QuicheStringPiece>& alpns) {
+            return std::find(alpns.cbegin(), alpns.cend(), alpn);
+          });
 
   // The client's handshake must have been started already.
   CHECK_NE(0u, client_conn->encrypted_packets_.size());
@@ -437,23 +439,26 @@
 
 class MockCommonCertSets : public CommonCertSets {
  public:
-  MockCommonCertSets(QuicStringPiece cert, uint64_t hash, uint32_t index)
+  MockCommonCertSets(quiche::QuicheStringPiece cert,
+                     uint64_t hash,
+                     uint32_t index)
       : cert_(cert), hash_(hash), index_(index) {}
 
-  QuicStringPiece GetCommonHashes() const override {
+  quiche::QuicheStringPiece GetCommonHashes() const override {
     QUIC_BUG << "not implemented";
-    return QuicStringPiece();
+    return quiche::QuicheStringPiece();
   }
 
-  QuicStringPiece GetCert(uint64_t hash, uint32_t index) const override {
+  quiche::QuicheStringPiece GetCert(uint64_t hash,
+                                    uint32_t index) const override {
     if (hash == hash_ && index == index_) {
       return cert_;
     }
-    return QuicStringPiece();
+    return quiche::QuicheStringPiece();
   }
 
-  bool MatchCert(QuicStringPiece cert,
-                 QuicStringPiece common_set_hashes,
+  bool MatchCert(quiche::QuicheStringPiece cert,
+                 quiche::QuicheStringPiece common_set_hashes,
                  uint64_t* out_hash,
                  uint32_t* out_index) const override {
     if (cert != cert_) {
@@ -488,7 +493,7 @@
   const uint32_t index_;
 };
 
-CommonCertSets* MockCommonCertSets(QuicStringPiece cert,
+CommonCertSets* MockCommonCertSets(quiche::QuicheStringPiece cert,
                                    uint64_t hash,
                                    uint32_t index) {
   return new class MockCommonCertSets(cert, hash, index);
@@ -549,10 +554,10 @@
                   << decrypter;
     return;
   }
-  QuicStringPiece encrypter_key = encrypter->GetKey();
-  QuicStringPiece encrypter_iv = encrypter->GetNoncePrefix();
-  QuicStringPiece decrypter_key = decrypter->GetKey();
-  QuicStringPiece decrypter_iv = decrypter->GetNoncePrefix();
+  quiche::QuicheStringPiece encrypter_key = encrypter->GetKey();
+  quiche::QuicheStringPiece encrypter_iv = encrypter->GetNoncePrefix();
+  quiche::QuicheStringPiece decrypter_key = decrypter->GetKey();
+  quiche::QuicheStringPiece decrypter_iv = decrypter->GetNoncePrefix();
   CompareCharArraysWithHexError(label + " key", encrypter_key.data(),
                                 encrypter_key.length(), decrypter_key.data(),
                                 decrypter_key.length());
@@ -592,9 +597,9 @@
     }
   }
 
-  QuicStringPiece client_subkey_secret =
+  quiche::QuicheStringPiece client_subkey_secret =
       client->crypto_negotiated_params().subkey_secret;
-  QuicStringPiece server_subkey_secret =
+  quiche::QuicheStringPiece server_subkey_secret =
       server->crypto_negotiated_params().subkey_secret;
   CompareCharArraysWithHexError("subkey secret", client_subkey_secret.data(),
                                 client_subkey_secret.length(),
@@ -674,8 +679,8 @@
     size_t value_len = value.length();
     if (value_len > 0 && value[0] == '#') {
       // This is ascii encoded hex.
-      std::string hex_value =
-          QuicTextUtils::HexDecode(QuicStringPiece(&value[1]));
+      std::string hex_value = quiche::QuicheTextUtils::HexDecode(
+          quiche::QuicheStringPiece(&value[1]));
       msg.SetStringPiece(quic_tag, hex_value);
       continue;
     }
@@ -759,7 +764,8 @@
   }
   *inout_packet_index = index;
 
-  QuicConnectionPeer::SetCurrentPacket(dest_conn, QuicStringPiece(nullptr, 0));
+  QuicConnectionPeer::SetCurrentPacket(dest_conn,
+                                       quiche::QuicheStringPiece(nullptr, 0));
 }
 
 CryptoHandshakeMessage GenerateDefaultInchoateCHLO(
@@ -791,18 +797,19 @@
   primary_config.set_primary_time(clock->WallNow().ToUNIXSeconds());
   std::unique_ptr<CryptoHandshakeMessage> msg =
       crypto_config->AddConfig(primary_config, clock->WallNow());
-  QuicStringPiece orbit;
+  quiche::QuicheStringPiece orbit;
   CHECK(msg->GetStringPiece(kORBT, &orbit));
   std::string nonce;
   CryptoUtils::GenerateNonce(clock->WallNow(), QuicRandom::GetInstance(), orbit,
                              &nonce);
-  return ("#" + QuicTextUtils::HexEncode(nonce));
+  return ("#" + quiche::QuicheTextUtils::HexEncode(nonce));
 }
 
 std::string GenerateClientPublicValuesHex() {
   char public_value[32];
   memset(public_value, 42, sizeof(public_value));
-  return ("#" + QuicTextUtils::HexEncode(public_value, sizeof(public_value)));
+  return ("#" + quiche::QuicheTextUtils::HexEncode(public_value,
+                                                   sizeof(public_value)));
 }
 
 void GenerateFullCHLO(const CryptoHandshakeMessage& inchoate_chlo,
diff --git a/quic/test_tools/crypto_test_utils.h b/quic/test_tools/crypto_test_utils.h
index 327eb67..616018f 100644
--- a/quic/test_tools/crypto_test_utils.h
+++ b/quic/test_tools/crypto_test_utils.h
@@ -15,8 +15,8 @@
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_framer.h"
 #include "net/third_party/quiche/src/quic/core/quic_framer.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -132,7 +132,7 @@
 
 // MockCommonCertSets returns a CommonCertSets that contains a single set with
 // hash |hash|, consisting of the certificate |cert| at index |index|.
-CommonCertSets* MockCommonCertSets(QuicStringPiece cert,
+CommonCertSets* MockCommonCertSets(quiche::QuicheStringPiece cert,
                                    uint64_t hash,
                                    uint32_t index);
 
diff --git a/quic/test_tools/crypto_test_utils_test.cc b/quic/test_tools/crypto_test_utils_test.cc
index 6565497..62cafe6 100644
--- a/quic/test_tools/crypto_test_utils_test.cc
+++ b/quic/test_tools/crypto_test_utils_test.cc
@@ -9,8 +9,9 @@
 #include "net/third_party/quiche/src/quic/core/proto/crypto_server_config_proto.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/mock_clock.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 namespace quic {
 namespace test {
@@ -129,17 +130,17 @@
   primary_config.set_primary_time(clock.WallNow().ToUNIXSeconds());
   std::unique_ptr<CryptoHandshakeMessage> msg =
       crypto_config.AddConfig(primary_config, clock.WallNow());
-  QuicStringPiece orbit;
+  quiche::QuicheStringPiece orbit;
   ASSERT_TRUE(msg->GetStringPiece(kORBT, &orbit));
   std::string nonce;
   CryptoUtils::GenerateNonce(clock.WallNow(), QuicRandom::GetInstance(), orbit,
                              &nonce);
-  std::string nonce_hex = "#" + QuicTextUtils::HexEncode(nonce);
+  std::string nonce_hex = "#" + quiche::QuicheTextUtils::HexEncode(nonce);
 
   char public_value[32];
   memset(public_value, 42, sizeof(public_value));
-  std::string pub_hex =
-      "#" + QuicTextUtils::HexEncode(public_value, sizeof(public_value));
+  std::string pub_hex = "#" + quiche::QuicheTextUtils::HexEncode(
+                                  public_value, sizeof(public_value));
 
   QuicTransportVersion version(AllSupportedTransportVersions().front());
   CryptoHandshakeMessage inchoate_chlo = crypto_test_utils::CreateCHLO(
diff --git a/quic/test_tools/failing_proof_source.cc b/quic/test_tools/failing_proof_source.cc
index 60b6a95..b71c6fd 100644
--- a/quic/test_tools/failing_proof_source.cc
+++ b/quic/test_tools/failing_proof_source.cc
@@ -4,6 +4,8 @@
 
 #include "net/third_party/quiche/src/quic/test_tools/failing_proof_source.h"
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+
 namespace quic {
 namespace test {
 
@@ -11,7 +13,7 @@
                                   const std::string& /*hostname*/,
                                   const std::string& /*server_config*/,
                                   QuicTransportVersion /*transport_version*/,
-                                  QuicStringPiece /*chlo_hash*/,
+                                  quiche::QuicheStringPiece /*chlo_hash*/,
                                   std::unique_ptr<Callback> callback) {
   callback->Run(false, nullptr, QuicCryptoProof(), nullptr);
 }
@@ -26,7 +28,7 @@
     const QuicSocketAddress& /*server_address*/,
     const std::string& /*hostname*/,
     uint16_t /*signature_algorithm*/,
-    QuicStringPiece /*in*/,
+    quiche::QuicheStringPiece /*in*/,
     std::unique_ptr<SignatureCallback> callback) {
   callback->Run(false, "");
 }
diff --git a/quic/test_tools/failing_proof_source.h b/quic/test_tools/failing_proof_source.h
index 10f9971..36e2398 100644
--- a/quic/test_tools/failing_proof_source.h
+++ b/quic/test_tools/failing_proof_source.h
@@ -6,7 +6,7 @@
 #define QUICHE_QUIC_TEST_TOOLS_FAILING_PROOF_SOURCE_H_
 
 #include "net/third_party/quiche/src/quic/core/crypto/proof_source.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 {
 namespace test {
@@ -17,7 +17,7 @@
                 const std::string& hostname,
                 const std::string& server_config,
                 QuicTransportVersion transport_version,
-                QuicStringPiece chlo_hash,
+                quiche::QuicheStringPiece chlo_hash,
                 std::unique_ptr<Callback> callback) override;
 
   QuicReferenceCountedPointer<Chain> GetCertChain(
@@ -28,7 +28,7 @@
       const QuicSocketAddress& server_address,
       const std::string& hostname,
       uint16_t signature_algorithm,
-      QuicStringPiece in,
+      quiche::QuicheStringPiece in,
       std::unique_ptr<SignatureCallback> callback) override;
 };
 
diff --git a/quic/test_tools/fake_proof_source.cc b/quic/test_tools/fake_proof_source.cc
index 784ced4..0d85b5d 100644
--- a/quic/test_tools/fake_proof_source.cc
+++ b/quic/test_tools/fake_proof_source.cc
@@ -8,6 +8,7 @@
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -47,7 +48,7 @@
     const QuicSocketAddress& server_address,
     std::string hostname,
     uint16_t sig_alg,
-    QuicStringPiece in,
+    quiche::QuicheStringPiece in,
     std::unique_ptr<ProofSource::SignatureCallback> callback,
     ProofSource* delegate)
     : server_address_(server_address),
@@ -73,7 +74,7 @@
     const std::string& hostname,
     const std::string& server_config,
     QuicTransportVersion transport_version,
-    QuicStringPiece chlo_hash,
+    quiche::QuicheStringPiece chlo_hash,
     std::unique_ptr<ProofSource::Callback> callback) {
   if (!active_) {
     delegate_->GetProof(server_address, hostname, server_config,
@@ -96,7 +97,7 @@
     const QuicSocketAddress& server_address,
     const std::string& hostname,
     uint16_t signature_algorithm,
-    QuicStringPiece in,
+    quiche::QuicheStringPiece in,
     std::unique_ptr<ProofSource::SignatureCallback> callback) {
   QUIC_LOG(INFO) << "FakeProofSource::ComputeTlsSignature";
   if (!active_) {
diff --git a/quic/test_tools/fake_proof_source.h b/quic/test_tools/fake_proof_source.h
index 62c3b29..41b761a 100644
--- a/quic/test_tools/fake_proof_source.h
+++ b/quic/test_tools/fake_proof_source.h
@@ -10,7 +10,7 @@
 #include <vector>
 
 #include "net/third_party/quiche/src/quic/core/crypto/proof_source.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 {
 namespace test {
@@ -35,7 +35,7 @@
                 const std::string& hostname,
                 const std::string& server_config,
                 QuicTransportVersion transport_version,
-                QuicStringPiece chlo_hash,
+                quiche::QuicheStringPiece chlo_hash,
                 std::unique_ptr<ProofSource::Callback> callback) override;
   QuicReferenceCountedPointer<Chain> GetCertChain(
       const QuicSocketAddress& server_address,
@@ -44,7 +44,7 @@
       const QuicSocketAddress& server_address,
       const std::string& hostname,
       uint16_t signature_algorithm,
-      QuicStringPiece in,
+      quiche::QuicheStringPiece in,
       std::unique_ptr<ProofSource::SignatureCallback> callback) override;
 
   // Get the number of callbacks which are pending
@@ -92,7 +92,7 @@
     ComputeSignatureOp(const QuicSocketAddress& server_address,
                        std::string hostname,
                        uint16_t sig_alg,
-                       QuicStringPiece in,
+                       quiche::QuicheStringPiece in,
                        std::unique_ptr<ProofSource::SignatureCallback> callback,
                        ProofSource* delegate);
     ~ComputeSignatureOp() override;
diff --git a/quic/test_tools/fuzzing/quic_framer_fuzzer.cc b/quic/test_tools/fuzzing/quic_framer_fuzzer.cc
index c536590..a63f963 100644
--- a/quic/test_tools/fuzzing/quic_framer_fuzzer.cc
+++ b/quic/test_tools/fuzzing/quic_framer_fuzzer.cc
@@ -6,8 +6,8 @@
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake_message.h"
 #include "net/third_party/quiche/src/quic/core/quic_framer.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.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"
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   quic::QuicFramer framer(quic::AllSupportedVersions(), quic::QuicTime::Zero(),
@@ -16,7 +16,7 @@
   const char* const packet_bytes = reinterpret_cast<const char*>(data);
 
   // Test the CryptoFramer.
-  quic::QuicStringPiece crypto_input(packet_bytes, size);
+  quiche::QuicheStringPiece crypto_input(packet_bytes, size);
   std::unique_ptr<quic::CryptoHandshakeMessage> handshake_message(
       quic::CryptoFramer::ParseMessage(crypto_input));
 
diff --git a/quic/test_tools/qpack/qpack_decoder_test_utils.cc b/quic/test_tools/qpack/qpack_decoder_test_utils.cc
index 2b835ae..4189290 100644
--- a/quic/test_tools/qpack/qpack_decoder_test_utils.cc
+++ b/quic/test_tools/qpack/qpack_decoder_test_utils.cc
@@ -9,18 +9,19 @@
 #include <utility>
 
 #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(
-    QuicStringPiece /*error_message*/) {}
+    quiche::QuicheStringPiece /*error_message*/) {}
 
 TestHeadersHandler::TestHeadersHandler()
     : decoding_completed_(false), decoding_error_detected_(false) {}
 
-void TestHeadersHandler::OnHeaderDecoded(QuicStringPiece name,
-                                         QuicStringPiece value) {
+void TestHeadersHandler::OnHeaderDecoded(quiche::QuicheStringPiece name,
+                                         quiche::QuicheStringPiece value) {
   ASSERT_FALSE(decoding_completed_);
   ASSERT_FALSE(decoding_error_detected_);
 
@@ -35,7 +36,7 @@
 }
 
 void TestHeadersHandler::OnDecodingErrorDetected(
-    QuicStringPiece error_message) {
+    quiche::QuicheStringPiece error_message) {
   ASSERT_FALSE(decoding_completed_);
   ASSERT_FALSE(decoding_error_detected_);
 
@@ -70,7 +71,7 @@
     QpackStreamSenderDelegate* decoder_stream_sender_delegate,
     QpackProgressiveDecoder::HeadersHandlerInterface* handler,
     const FragmentSizeGenerator& fragment_size_generator,
-    QuicStringPiece data) {
+    quiche::QuicheStringPiece 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 213aded..2bd80ef 100644
--- a/quic/test_tools/qpack/qpack_decoder_test_utils.h
+++ b/quic/test_tools/qpack/qpack_decoder_test_utils.h
@@ -9,9 +9,9 @@
 
 #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_string_piece.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(QuicStringPiece error_message) override;
+  void OnEncoderStreamError(quiche::QuicheStringPiece error_message) override;
 };
 
 // Mock QpackDecoder::EncoderStreamErrorDelegate implementation.
@@ -32,7 +32,8 @@
  public:
   ~MockEncoderStreamErrorDelegate() override = default;
 
-  MOCK_METHOD1(OnEncoderStreamError, void(QuicStringPiece error_message));
+  MOCK_METHOD1(OnEncoderStreamError,
+               void(quiche::QuicheStringPiece error_message));
 };
 
 // HeadersHandlerInterface implementation that collects decoded headers
@@ -44,9 +45,11 @@
   ~TestHeadersHandler() override = default;
 
   // HeadersHandlerInterface implementation:
-  void OnHeaderDecoded(QuicStringPiece name, QuicStringPiece value) override;
+  void OnHeaderDecoded(quiche::QuicheStringPiece name,
+                       quiche::QuicheStringPiece value) override;
   void OnDecodingCompleted() override;
-  void OnDecodingErrorDetected(QuicStringPiece error_message) override;
+  void OnDecodingErrorDetected(
+      quiche::QuicheStringPiece error_message) override;
 
   // Release decoded header list.  Must only be called if decoding is complete
   // and no errors have been detected.
@@ -72,9 +75,11 @@
   ~MockHeadersHandler() override = default;
 
   MOCK_METHOD2(OnHeaderDecoded,
-               void(QuicStringPiece name, QuicStringPiece value));
+               void(quiche::QuicheStringPiece name,
+                    quiche::QuicheStringPiece value));
   MOCK_METHOD0(OnDecodingCompleted, void());
-  MOCK_METHOD1(OnDecodingErrorDetected, void(QuicStringPiece error_message));
+  MOCK_METHOD1(OnDecodingErrorDetected,
+               void(quiche::QuicheStringPiece error_message));
 };
 
 class NoOpHeadersHandler
@@ -82,10 +87,11 @@
  public:
   ~NoOpHeadersHandler() override = default;
 
-  void OnHeaderDecoded(QuicStringPiece /*name*/,
-                       QuicStringPiece /*value*/) override {}
+  void OnHeaderDecoded(quiche::QuicheStringPiece /*name*/,
+                       quiche::QuicheStringPiece /*value*/) override {}
   void OnDecodingCompleted() override {}
-  void OnDecodingErrorDetected(QuicStringPiece /*error_message*/) override {}
+  void OnDecodingErrorDetected(
+      quiche::QuicheStringPiece /*error_message*/) override {}
 };
 
 void QpackDecode(
@@ -95,7 +101,7 @@
     QpackStreamSenderDelegate* decoder_stream_sender_delegate,
     QpackProgressiveDecoder::HeadersHandlerInterface* handler,
     const FragmentSizeGenerator& fragment_size_generator,
-    QuicStringPiece data);
+    quiche::QuicheStringPiece 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 dbdd369..1303511 100644
--- a/quic/test_tools/qpack/qpack_encoder_test_utils.cc
+++ b/quic/test_tools/qpack/qpack_encoder_test_utils.cc
@@ -4,13 +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 "net/third_party/quiche/src/spdy/core/hpack/hpack_encoder.h"
 
 namespace quic {
 namespace test {
 
 void NoopDecoderStreamErrorDelegate::OnDecoderStreamError(
-    QuicStringPiece /*error_message*/) {}
+    quiche::QuicheStringPiece /*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 5fa2292..0ea978f 100644
--- a/quic/test_tools/qpack/qpack_encoder_test_utils.h
+++ b/quic/test_tools/qpack/qpack_encoder_test_utils.h
@@ -8,9 +8,9 @@
 #include <string>
 
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_encoder.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.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(QuicStringPiece error_message) override;
+  void OnDecoderStreamError(quiche::QuicheStringPiece error_message) override;
 };
 
 // Mock QpackEncoder::DecoderStreamErrorDelegate implementation.
@@ -31,7 +31,8 @@
  public:
   ~MockDecoderStreamErrorDelegate() override = default;
 
-  MOCK_METHOD1(OnDecoderStreamError, void(QuicStringPiece error_message));
+  MOCK_METHOD1(OnDecoderStreamError,
+               void(quiche::QuicheStringPiece error_message));
 };
 
 }  // namespace test
diff --git a/quic/test_tools/qpack/qpack_offline_decoder.cc b/quic/test_tools/qpack/qpack_offline_decoder.cc
index a5a74aa..a7ba9e4 100644
--- a/quic/test_tools/qpack/qpack_offline_decoder.cc
+++ b/quic/test_tools/qpack/qpack_offline_decoder.cc
@@ -33,9 +33,10 @@
 #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/platform/api/quic_text_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_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 {
 
@@ -43,8 +44,8 @@
     : encoder_stream_error_detected_(false) {}
 
 bool QpackOfflineDecoder::DecodeAndVerifyOfflineData(
-    QuicStringPiece input_filename,
-    QuicStringPiece expected_headers_filename) {
+    quiche::QuicheStringPiece input_filename,
+    quiche::QuicheStringPiece expected_headers_filename) {
   if (!ParseInputFilename(input_filename)) {
     QUIC_LOG(ERROR) << "Error parsing input filename " << input_filename;
     return false;
@@ -65,13 +66,15 @@
   return true;
 }
 
-void QpackOfflineDecoder::OnEncoderStreamError(QuicStringPiece error_message) {
+void QpackOfflineDecoder::OnEncoderStreamError(
+    quiche::QuicheStringPiece error_message) {
   QUIC_LOG(ERROR) << "Encoder stream error: " << error_message;
   encoder_stream_error_detected_ = true;
 }
 
-bool QpackOfflineDecoder::ParseInputFilename(QuicStringPiece input_filename) {
-  auto pieces = QuicTextUtils::Split(input_filename, '.');
+bool QpackOfflineDecoder::ParseInputFilename(
+    quiche::QuicheStringPiece input_filename) {
+  auto pieces = quiche::QuicheTextUtils::Split(input_filename, '.');
 
   if (pieces.size() < 3) {
     QUIC_LOG(ERROR) << "Not enough fields in input filename " << input_filename;
@@ -97,7 +100,8 @@
 
   // Maximum allowed number of blocked streams.
   uint64_t max_blocked_streams = 0;
-  if (!QuicTextUtils::StringToUint64(*piece_it, &max_blocked_streams)) {
+  if (!quiche::QuicheTextUtils::StringToUint64(*piece_it,
+                                               &max_blocked_streams)) {
     QUIC_LOG(ERROR) << "Error parsing part of input filename \"" << *piece_it
                     << "\" as an integer.";
     return false;
@@ -107,8 +111,8 @@
 
   // Maximum Dynamic Table Capacity in bytes
   uint64_t maximum_dynamic_table_capacity = 0;
-  if (!QuicTextUtils::StringToUint64(*piece_it,
-                                     &maximum_dynamic_table_capacity)) {
+  if (!quiche::QuicheTextUtils::StringToUint64(
+          *piece_it, &maximum_dynamic_table_capacity)) {
     QUIC_LOG(ERROR) << "Error parsing part of input filename \"" << *piece_it
                     << "\" as an integer.";
     return false;
@@ -128,12 +132,12 @@
 }
 
 bool QpackOfflineDecoder::DecodeHeaderBlocksFromFile(
-    QuicStringPiece input_filename) {
-  // Store data in |input_data_storage|; use a QuicStringPiece to efficiently
-  // keep track of remaining portion yet to be decoded.
+    quiche::QuicheStringPiece input_filename) {
+  // Store data in |input_data_storage|; use a quiche::QuicheStringPiece to
+  // efficiently keep track of remaining portion yet to be decoded.
   std::string input_data_storage;
   ReadFileContents(input_filename, &input_data_storage);
-  QuicStringPiece input_data(input_data_storage);
+  quiche::QuicheStringPiece input_data(input_data_storage);
 
   while (!input_data.empty()) {
     // Parse stream_id and length.
@@ -156,7 +160,7 @@
     }
 
     // Parse data.
-    QuicStringPiece data = input_data.substr(0, length);
+    quiche::QuicheStringPiece data = input_data.substr(0, length);
     input_data = input_data.substr(length);
 
     // Process data.
@@ -224,12 +228,14 @@
 }
 
 bool QpackOfflineDecoder::VerifyDecodedHeaderLists(
-    QuicStringPiece expected_headers_filename) {
-  // Store data in |expected_headers_data_storage|; use a QuicStringPiece to
-  // efficiently keep track of remaining portion yet to be decoded.
+    quiche::QuicheStringPiece expected_headers_filename) {
+  // Store data in |expected_headers_data_storage|; use a
+  // quiche::QuicheStringPiece 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);
-  QuicStringPiece expected_headers_data(expected_headers_data_storage);
+  quiche::QuicheStringPiece expected_headers_data(
+      expected_headers_data_storage);
 
   while (!decoded_header_lists_.empty()) {
     spdy::SpdyHeaderBlock decoded_header_list =
@@ -262,13 +268,14 @@
 }
 
 bool QpackOfflineDecoder::ReadNextExpectedHeaderList(
-    QuicStringPiece* expected_headers_data,
+    quiche::QuicheStringPiece* expected_headers_data,
     spdy::SpdyHeaderBlock* expected_header_list) {
   while (true) {
-    QuicStringPiece::size_type endline = expected_headers_data->find('\n');
+    quiche::QuicheStringPiece::size_type endline =
+        expected_headers_data->find('\n');
 
     // Even last header list must be followed by an empty line.
-    if (endline == QuicStringPiece::npos) {
+    if (endline == quiche::QuicheStringPiece::npos) {
       QUIC_LOG(ERROR) << "Unexpected end of expected header list file.";
       return false;
     }
@@ -279,8 +286,9 @@
       return true;
     }
 
-    QuicStringPiece header_field = expected_headers_data->substr(0, endline);
-    auto pieces = QuicTextUtils::Split(header_field, '\t');
+    quiche::QuicheStringPiece header_field =
+        expected_headers_data->substr(0, endline);
+    auto pieces = quiche::QuicheTextUtils::Split(header_field, '\t');
 
     if (pieces.size() != 2) {
       QUIC_LOG(ERROR) << "Header key and value must be separated by TAB.";
@@ -308,9 +316,9 @@
   const char* kPseudoHeaderPrefix = ":";
   for (spdy::SpdyHeaderBlock::iterator decoded_it = decoded_header_list.begin();
        decoded_it != decoded_header_list.end();) {
-    const QuicStringPiece key = decoded_it->first;
+    const quiche::QuicheStringPiece key = decoded_it->first;
     if (key != kContentLength &&
-        !QuicTextUtils::StartsWith(key, kPseudoHeaderPrefix)) {
+        !quiche::QuicheTextUtils::StartsWith(key, kPseudoHeaderPrefix)) {
       ++decoded_it;
       continue;
     }
diff --git a/quic/test_tools/qpack/qpack_offline_decoder.h b/quic/test_tools/qpack/qpack_offline_decoder.h
index cb7dedd..f90b2c7 100644
--- a/quic/test_tools/qpack/qpack_offline_decoder.h
+++ b/quic/test_tools/qpack/qpack_offline_decoder.h
@@ -8,9 +8,9 @@
 #include <list>
 
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_decoder.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.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,11 +29,12 @@
   // |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(QuicStringPiece input_filename,
-                                  QuicStringPiece expected_headers_filename);
+  bool DecodeAndVerifyOfflineData(
+      quiche::QuicheStringPiece input_filename,
+      quiche::QuicheStringPiece expected_headers_filename);
 
   // QpackDecoder::EncoderStreamErrorDelegate implementation:
-  void OnEncoderStreamError(QuicStringPiece error_message) override;
+  void OnEncoderStreamError(quiche::QuicheStringPiece error_message) override;
 
  private:
   // Data structure to hold TestHeadersHandler and QpackProgressiveDecoder until
@@ -47,22 +48,24 @@
 
   // Parse decoder parameters from |input_filename| and set up |qpack_decoder_|
   // accordingly.
-  bool ParseInputFilename(QuicStringPiece input_filename);
+  bool ParseInputFilename(quiche::QuicheStringPiece 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(QuicStringPiece input_filename);
+  bool DecodeHeaderBlocksFromFile(quiche::QuicheStringPiece input_filename);
 
   // Read expected header lists from |expected_headers_filename| and verify
   // decoded header lists in |decoded_header_lists_| against them.
-  bool VerifyDecodedHeaderLists(QuicStringPiece expected_headers_filename);
+  bool VerifyDecodedHeaderLists(
+      quiche::QuicheStringPiece 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(QuicStringPiece* expected_headers_data,
-                                  spdy::SpdyHeaderBlock* expected_header_list);
+  bool ReadNextExpectedHeaderList(
+      quiche::QuicheStringPiece* 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 08cab4e..0740950 100644
--- a/quic/test_tools/qpack/qpack_test_utils.h
+++ b/quic/test_tools/qpack/qpack_test_utils.h
@@ -10,6 +10,7 @@
 
 #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 {
@@ -31,14 +32,14 @@
  public:
   ~MockQpackStreamSenderDelegate() override = default;
 
-  MOCK_METHOD1(WriteStreamData, void(QuicStringPiece data));
+  MOCK_METHOD1(WriteStreamData, void(quiche::QuicheStringPiece data));
 };
 
 class NoopQpackStreamSenderDelegate : public QpackStreamSenderDelegate {
  public:
   ~NoopQpackStreamSenderDelegate() override = default;
 
-  void WriteStreamData(QuicStringPiece /*data*/) override {}
+  void WriteStreamData(quiche::QuicheStringPiece /*data*/) override {}
 };
 
 }  // namespace test
diff --git a/quic/test_tools/quic_connection_peer.cc b/quic/test_tools/quic_connection_peer.cc
index 7b9264c..b38b64e 100644
--- a/quic/test_tools/quic_connection_peer.cc
+++ b/quic/test_tools/quic_connection_peer.cc
@@ -10,6 +10,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_framer_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_sent_packet_manager_peer.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -99,8 +100,9 @@
 }
 
 // static
-void QuicConnectionPeer::SetCurrentPacket(QuicConnection* connection,
-                                          QuicStringPiece current_packet) {
+void QuicConnectionPeer::SetCurrentPacket(
+    QuicConnection* connection,
+    quiche::QuicheStringPiece current_packet) {
   connection->current_packet_data_ = current_packet.data();
   connection->last_size_ = current_packet.size();
 }
diff --git a/quic/test_tools/quic_connection_peer.h b/quic/test_tools/quic_connection_peer.h
index b7140de..e0a97b8 100644
--- a/quic/test_tools/quic_connection_peer.h
+++ b/quic/test_tools/quic_connection_peer.h
@@ -9,7 +9,7 @@
 #include "net/third_party/quiche/src/quic/core/quic_connection_stats.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -69,7 +69,7 @@
   static void SwapCrypters(QuicConnection* connection, QuicFramer* framer);
 
   static void SetCurrentPacket(QuicConnection* connection,
-                               QuicStringPiece current_packet);
+                               quiche::QuicheStringPiece current_packet);
 
   static QuicConnectionHelperInterface* GetHelper(QuicConnection* connection);
 
diff --git a/quic/test_tools/quic_crypto_server_config_peer.cc b/quic/test_tools/quic_crypto_server_config_peer.cc
index be2d338..3893448 100644
--- a/quic/test_tools/quic_crypto_server_config_peer.cc
+++ b/quic/test_tools/quic_crypto_server_config_peer.cc
@@ -7,6 +7,7 @@
 #include "net/third_party/quiche/src/quic/test_tools/mock_clock.h"
 #include "net/third_party/quiche/src/quic/test_tools/mock_random.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -52,7 +53,7 @@
 
 HandshakeFailureReason QuicCryptoServerConfigPeer::ValidateSourceAddressTokens(
     std::string config_id,
-    QuicStringPiece srct,
+    quiche::QuicheStringPiece srct,
     const QuicIpAddress& ip,
     QuicWallTime now,
     CachedNetworkParameters* cached_network_params) {
@@ -69,7 +70,7 @@
 
 HandshakeFailureReason
 QuicCryptoServerConfigPeer::ValidateSingleSourceAddressToken(
-    QuicStringPiece token,
+    quiche::QuicheStringPiece token,
     const QuicIpAddress& ip,
     QuicWallTime now) {
   SourceAddressTokens tokens;
diff --git a/quic/test_tools/quic_crypto_server_config_peer.h b/quic/test_tools/quic_crypto_server_config_peer.h
index baaa9b8..270321f 100644
--- a/quic/test_tools/quic_crypto_server_config_peer.h
+++ b/quic/test_tools/quic_crypto_server_config_peer.h
@@ -6,7 +6,7 @@
 #define QUICHE_QUIC_TEST_TOOLS_QUIC_CRYPTO_SERVER_CONFIG_PEER_H_
 
 #include "net/third_party/quiche/src/quic/core/crypto/quic_crypto_server_config.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 {
 namespace test {
@@ -43,14 +43,14 @@
   // Attempts to validate the tokens in |tokens|.
   HandshakeFailureReason ValidateSourceAddressTokens(
       std::string config_id,
-      QuicStringPiece tokens,
+      quiche::QuicheStringPiece tokens,
       const QuicIpAddress& ip,
       QuicWallTime now,
       CachedNetworkParameters* cached_network_params);
 
   // Attempts to validate the single source address token in |token|.
   HandshakeFailureReason ValidateSingleSourceAddressToken(
-      QuicStringPiece token,
+      quiche::QuicheStringPiece token,
       const QuicIpAddress& ip,
       QuicWallTime now);
 
diff --git a/quic/test_tools/quic_spdy_stream_peer.h b/quic/test_tools/quic_spdy_stream_peer.h
index 6656df0..9a21671 100644
--- a/quic/test_tools/quic_spdy_stream_peer.h
+++ b/quic/test_tools/quic_spdy_stream_peer.h
@@ -8,7 +8,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_ack_listener_interface.h"
 #include "net/third_party/quiche/src/quic/core/quic_interval_set.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
 
 namespace quic {
 
diff --git a/quic/test_tools/quic_stream_peer.h b/quic/test_tools/quic_stream_peer.h
index 9142348..f4b1de3 100644
--- a/quic/test_tools/quic_stream_peer.h
+++ b/quic/test_tools/quic_stream_peer.h
@@ -10,7 +10,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
 #include "net/third_party/quiche/src/quic/core/quic_stream_send_buffer.h"
 #include "net/third_party/quiche/src/quic/core/quic_stream_sequencer.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
 
 namespace quic {
 
diff --git a/quic/test_tools/quic_test_client.cc b/quic/test_tools/quic_test_client.cc
index ca5e95a..77d87ea 100644
--- a/quic/test_tools/quic_test_client.cc
+++ b/quic/test_tools/quic_test_client.cc
@@ -20,7 +20,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_stack_trace.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_client_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h"
@@ -28,6 +27,8 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_spdy_stream_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 #include "net/third_party/quiche/src/quic/tools/quic_url.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 namespace quic {
 namespace test {
@@ -48,7 +49,7 @@
       const uint16_t port,
       const std::string& server_config,
       QuicTransportVersion transport_version,
-      QuicStringPiece chlo_hash,
+      quiche::QuicheStringPiece chlo_hash,
       const std::vector<std::string>& certs,
       const std::string& cert_sct,
       const std::string& signature,
@@ -399,7 +400,7 @@
 
 ssize_t QuicTestClient::GetOrCreateStreamAndSendRequest(
     const spdy::SpdyHeaderBlock* headers,
-    QuicStringPiece body,
+    quiche::QuicheStringPiece body,
     bool fin,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   if (headers) {
@@ -443,18 +444,18 @@
 }
 
 ssize_t QuicTestClient::SendMessage(const spdy::SpdyHeaderBlock& headers,
-                                    QuicStringPiece body) {
+                                    quiche::QuicheStringPiece body) {
   return SendMessage(headers, body, /*fin=*/true);
 }
 
 ssize_t QuicTestClient::SendMessage(const spdy::SpdyHeaderBlock& headers,
-                                    QuicStringPiece body,
+                                    quiche::QuicheStringPiece body,
                                     bool fin) {
   return SendMessage(headers, body, fin, /*flush=*/true);
 }
 
 ssize_t QuicTestClient::SendMessage(const spdy::SpdyHeaderBlock& headers,
-                                    QuicStringPiece body,
+                                    quiche::QuicheStringPiece body,
                                     bool fin,
                                     bool flush) {
   // Always force creation of a stream for SendMessage.
@@ -476,7 +477,8 @@
     const std::string& data,
     bool last_data,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
-  return GetOrCreateStreamAndSendRequest(nullptr, QuicStringPiece(data),
+  return GetOrCreateStreamAndSendRequest(nullptr,
+                                         quiche::QuicheStringPiece(data),
                                          last_data, std::move(ack_listener));
 }
 
@@ -845,7 +847,7 @@
 
 QuicTestClient::TestClientDataToResend::TestClientDataToResend(
     std::unique_ptr<spdy::SpdyHeaderBlock> headers,
-    QuicStringPiece body,
+    quiche::QuicheStringPiece body,
     bool fin,
     QuicTestClient* test_client,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener)
@@ -901,8 +903,8 @@
     const std::string& uri,
     spdy::SpdyHeaderBlock* headers) {
   std::string url;
-  if (QuicTextUtils::StartsWith(uri, "https://") ||
-      QuicTextUtils::StartsWith(uri, "http://")) {
+  if (quiche::QuicheTextUtils::StartsWith(uri, "https://") ||
+      quiche::QuicheTextUtils::StartsWith(uri, "http://")) {
     url = uri;
   } else if (uri[0] == '/') {
     url = "https://" + client_->server_id().host() + uri;
diff --git a/quic/test_tools/quic_test_client.h b/quic/test_tools/quic_test_client.h
index cd5b09f..91273b1 100644
--- a/quic/test_tools/quic_test_client.h
+++ b/quic/test_tools/quic_test_client.h
@@ -16,9 +16,9 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_epoll.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/tools/quic_client.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -127,19 +127,19 @@
   // Sends a request containing |headers| and |body| and returns the number of
   // bytes sent (the size of the serialized request headers and body).
   ssize_t SendMessage(const spdy::SpdyHeaderBlock& headers,
-                      QuicStringPiece body);
+                      quiche::QuicheStringPiece body);
   // Sends a request containing |headers| and |body| with the fin bit set to
   // |fin| and returns the number of bytes sent (the size of the serialized
   // request headers and body).
   ssize_t SendMessage(const spdy::SpdyHeaderBlock& headers,
-                      QuicStringPiece body,
+                      quiche::QuicheStringPiece body,
                       bool fin);
   // Sends a request containing |headers| and |body| with the fin bit set to
   // |fin| and returns the number of bytes sent (the size of the serialized
   // request headers and body). If |flush| is true, will wait for the message to
   // be flushed before returning.
   ssize_t SendMessage(const spdy::SpdyHeaderBlock& headers,
-                      QuicStringPiece body,
+                      quiche::QuicheStringPiece body,
                       bool fin,
                       bool flush);
   // Sends a request containing |headers| and |body|, waits for the response,
@@ -249,7 +249,7 @@
   // null, only the body will be sent on the stream.
   ssize_t GetOrCreateStreamAndSendRequest(
       const spdy::SpdyHeaderBlock* headers,
-      QuicStringPiece body,
+      quiche::QuicheStringPiece body,
       bool fin,
       QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
 
@@ -324,7 +324,7 @@
    public:
     TestClientDataToResend(
         std::unique_ptr<spdy::SpdyHeaderBlock> headers,
-        QuicStringPiece body,
+        quiche::QuicheStringPiece body,
         bool fin,
         QuicTestClient* test_client,
         QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
diff --git a/quic/test_tools/quic_test_server.cc b/quic/test_tools/quic_test_server.cc
index 81b54d4..3e255b4 100644
--- a/quic/test_tools/quic_test_server.cc
+++ b/quic/test_tools/quic_test_server.cc
@@ -12,6 +12,7 @@
 #include "net/third_party/quiche/src/quic/tools/quic_simple_crypto_server_stream_helper.h"
 #include "net/third_party/quiche/src/quic/tools/quic_simple_dispatcher.h"
 #include "net/third_party/quiche/src/quic/tools/quic_simple_server_session.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -95,7 +96,7 @@
   QuicServerSessionBase* CreateQuicSession(
       QuicConnectionId id,
       const QuicSocketAddress& client,
-      QuicStringPiece alpn,
+      quiche::QuicheStringPiece alpn,
       const ParsedQuicVersion& version) override {
     QuicReaderMutexLock lock(&factory_lock_);
     if (session_factory_ == nullptr && stream_factory_ == nullptr &&
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index 156d00e..cf2569f 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -28,6 +28,7 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_endian.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_frame_builder.h"
 
 using testing::_;
@@ -160,7 +161,7 @@
       header.length_length);
 }
 
-std::string Sha1Hash(QuicStringPiece data) {
+std::string Sha1Hash(quiche::QuicheStringPiece data) {
   char buffer[SHA_DIGEST_LENGTH];
   SHA1(reinterpret_cast<const uint8_t*>(data.data()), data.size(),
        reinterpret_cast<uint8_t*>(buffer));
@@ -955,7 +956,7 @@
   if (!QuicVersionUsesCryptoFrames(version.transport_version)) {
     QuicFrame frame(
         QuicStreamFrame(QuicUtils::GetCryptoStreamId(version.transport_version),
-                        false, 0, QuicStringPiece(data)));
+                        false, 0, quiche::QuicheStringPiece(data)));
     frames.push_back(frame);
   } else {
     QuicFrame frame(new QuicCryptoFrame(level, 0, data));
@@ -1023,7 +1024,8 @@
     header.retry_token_length_length = VARIABLE_LENGTH_INTEGER_LENGTH_1;
     header.length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
   }
-  QuicFrame frame(QuicStreamFrame(1, false, 0, QuicStringPiece(data)));
+  QuicFrame frame(
+      QuicStreamFrame(1, false, 0, quiche::QuicheStringPiece(data)));
   QuicFrames frames;
   frames.push_back(frame);
   QuicFramer framer({version}, QuicTime::Zero(), perspective,
@@ -1249,7 +1251,7 @@
 }
 
 QuicMemSliceSpan MakeSpan(QuicBufferAllocator* allocator,
-                          QuicStringPiece message_data,
+                          quiche::QuicheStringPiece message_data,
                           QuicMemSliceStorage* storage) {
   if (message_data.length() == 0) {
     *storage =
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index d8fbc78..c9197f3 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -23,12 +23,12 @@
 #include "net/third_party/quiche/src/quic/core/quic_sent_packet_manager.h"
 #include "net/third_party/quiche/src/quic/core/quic_simple_buffer_allocator.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_mem_slice_storage.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/mock_clock.h"
 #include "net/third_party/quiche/src/quic/test_tools/mock_quic_session_visitor.h"
 #include "net/third_party/quiche/src/quic/test_tools/mock_random.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 {
 
@@ -228,7 +228,7 @@
     size_t packet_size);
 
 // Compute SHA-1 hash of the supplied std::string.
-std::string Sha1Hash(QuicStringPiece data);
+std::string Sha1Hash(quiche::QuicheStringPiece data);
 
 // Delete |frame| and return true.
 bool ClearControlFrame(const QuicFrame& frame);
@@ -274,7 +274,7 @@
   MOCK_METHOD3(OnRetryPacket,
                void(QuicConnectionId original_connection_id,
                     QuicConnectionId new_connection_id,
-                    QuicStringPiece retry_token));
+                    quiche::QuicheStringPiece retry_token));
   // The constructor sets this up to return true by default.
   MOCK_METHOD1(OnUnauthenticatedHeader, bool(const QuicPacketHeader& header));
   // The constructor sets this up to return true by default.
@@ -333,7 +333,7 @@
       const QuicVersionNegotiationPacket& /*packet*/) override {}
   void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
                      QuicConnectionId /*new_connection_id*/,
-                     QuicStringPiece /*retry_token*/) override {}
+                     quiche::QuicheStringPiece /*retry_token*/) override {}
   bool OnProtocolVersionMismatch(ParsedQuicVersion version) override;
   bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override;
   bool OnUnauthenticatedPublicHeader(const QuicPacketHeader& header) override;
@@ -389,7 +389,7 @@
   MOCK_METHOD1(OnBlockedFrame, void(const QuicBlockedFrame& frame));
   MOCK_METHOD1(OnRstStream, void(const QuicRstStreamFrame& frame));
   MOCK_METHOD1(OnGoAway, void(const QuicGoAwayFrame& frame));
-  MOCK_METHOD1(OnMessageReceived, void(QuicStringPiece message));
+  MOCK_METHOD1(OnMessageReceived, void(quiche::QuicheStringPiece message));
   MOCK_METHOD2(OnConnectionClosed,
                void(const QuicConnectionCloseFrame& frame,
                     ConnectionCloseSource source));
@@ -648,7 +648,8 @@
                     QuicStreamOffset bytes_written));
 
   MOCK_METHOD2(OnStreamHeaders,
-               void(QuicStreamId stream_id, QuicStringPiece headers_data));
+               void(QuicStreamId stream_id,
+                    quiche::QuicheStringPiece headers_data));
   MOCK_METHOD2(OnStreamHeadersPriority,
                void(QuicStreamId stream_id, spdy::SpdyPriority priority));
   MOCK_METHOD3(OnStreamHeadersComplete,
@@ -658,9 +659,9 @@
   MOCK_METHOD1(OnCryptoHandshakeEvent, void(QuicSession::CryptoHandshakeEvent));
   MOCK_CONST_METHOD0(GetAlpnsToOffer, std::vector<std::string>());
   MOCK_CONST_METHOD1(SelectAlpn,
-                     std::vector<QuicStringPiece>::const_iterator(
-                         const std::vector<QuicStringPiece>&));
-  MOCK_METHOD1(OnAlpnSelected, void(QuicStringPiece));
+                     std::vector<quiche::QuicheStringPiece>::const_iterator(
+                         const std::vector<quiche::QuicheStringPiece>&));
+  MOCK_METHOD1(OnAlpnSelected, void(quiche::QuicheStringPiece));
 
   using QuicSession::ActivateStream;
 
@@ -744,7 +745,8 @@
                     QuicStreamOffset bytes_written));
 
   MOCK_METHOD2(OnStreamHeaders,
-               void(QuicStreamId stream_id, QuicStringPiece headers_data));
+               void(QuicStreamId stream_id,
+                    quiche::QuicheStringPiece headers_data));
   MOCK_METHOD2(OnStreamHeadersPriority,
                void(QuicStreamId stream_id,
                     const spdy::SpdyStreamPrecedence& precedence));
@@ -756,7 +758,8 @@
                     size_t frame_len,
                     const QuicHeaderList& header_list));
   MOCK_METHOD2(OnPromiseHeaders,
-               void(QuicStreamId stream_id, QuicStringPiece headers_data));
+               void(QuicStreamId stream_id,
+                    quiche::QuicheStringPiece headers_data));
   MOCK_METHOD3(OnPromiseHeadersComplete,
                void(QuicStreamId stream_id,
                     QuicStreamId promised_stream_id,
@@ -799,8 +802,8 @@
   MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicSpdyStream*());
   MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicSpdyStream*());
   MOCK_CONST_METHOD1(SelectAlpn,
-                     std::vector<QuicStringPiece>::const_iterator(
-                         const std::vector<QuicStringPiece>&));
+                     std::vector<quiche::QuicheStringPiece>::const_iterator(
+                         const std::vector<quiche::QuicheStringPiece>&));
   QuicCryptoServerStreamBase* CreateQuicCryptoServerStream(
       const QuicCryptoServerConfig* crypto_config,
       QuicCompressedCertsCache* compressed_certs_cache) override;
@@ -1075,7 +1078,9 @@
                void(const QuicVersionNegotiationPacket&));
 
   MOCK_METHOD3(OnRetryPacket,
-               void(QuicConnectionId, QuicConnectionId, QuicStringPiece));
+               void(QuicConnectionId,
+                    QuicConnectionId,
+                    quiche::QuicheStringPiece));
 };
 
 class MockReceivedPacketManager : public QuicReceivedPacketManager {
@@ -1213,7 +1218,7 @@
 }
 
 // Utility function that stores |str|'s data in |iov|.
-inline void MakeIOVector(QuicStringPiece str, struct iovec* iov) {
+inline void MakeIOVector(quiche::QuicheStringPiece str, struct iovec* iov) {
   iov->iov_base = const_cast<char*>(str.data());
   iov->iov_len = static_cast<size_t>(str.size());
 }
@@ -1243,7 +1248,7 @@
 // Utility function that stores message_data in |storage| and returns a
 // QuicMemSliceSpan.
 QuicMemSliceSpan MakeSpan(QuicBufferAllocator* allocator,
-                          QuicStringPiece message_data,
+                          quiche::QuicheStringPiece message_data,
                           QuicMemSliceStorage* storage);
 
 // Used to compare ReceivedPacketInfo.
@@ -1264,8 +1269,8 @@
 // EXPECT_THAT(stream_->connection_error()), IsError(QUIC_INTERNAL_ERROR));
 MATCHER_P(IsError,
           expected,
-          QuicStrCat(negation ? "isn't equal to " : "is equal to ",
-                     QuicErrorCodeToString(expected))) {
+          quiche::QuicheStrCat(negation ? "isn't equal to " : "is equal to ",
+                               QuicErrorCodeToString(expected))) {
   *result_listener << QuicErrorCodeToString(arg);
   return arg == expected;
 }
@@ -1273,8 +1278,8 @@
 // Shorthand for IsError(QUIC_NO_ERROR).
 // Example usage: EXPECT_THAT(stream_->connection_error(), IsQuicNoError());
 MATCHER(IsQuicNoError,
-        QuicStrCat(negation ? "isn't equal to " : "is equal to ",
-                   QuicErrorCodeToString(QUIC_NO_ERROR))) {
+        quiche::QuicheStrCat(negation ? "isn't equal to " : "is equal to ",
+                             QuicErrorCodeToString(QUIC_NO_ERROR))) {
   *result_listener << QuicErrorCodeToString(arg);
   return arg == QUIC_NO_ERROR;
 }
@@ -1284,8 +1289,8 @@
 // EXPECT_THAT(stream_->stream_error(), IsStreamError(QUIC_INTERNAL_ERROR));
 MATCHER_P(IsStreamError,
           expected,
-          QuicStrCat(negation ? "isn't equal to " : "is equal to ",
-                     QuicRstStreamErrorCodeToString(expected))) {
+          quiche::QuicheStrCat(negation ? "isn't equal to " : "is equal to ",
+                               QuicRstStreamErrorCodeToString(expected))) {
   *result_listener << QuicRstStreamErrorCodeToString(arg);
   return arg == expected;
 }
@@ -1293,8 +1298,9 @@
 // Shorthand for IsStreamError(QUIC_STREAM_NO_ERROR).  Example usage:
 // EXPECT_THAT(stream_->stream_error(), IsQuicStreamNoError());
 MATCHER(IsQuicStreamNoError,
-        QuicStrCat(negation ? "isn't equal to " : "is equal to ",
-                   QuicRstStreamErrorCodeToString(QUIC_STREAM_NO_ERROR))) {
+        quiche::QuicheStrCat(
+            negation ? "isn't equal to " : "is equal to ",
+            QuicRstStreamErrorCodeToString(QUIC_STREAM_NO_ERROR))) {
   *result_listener << QuicRstStreamErrorCodeToString(arg);
   return arg == QUIC_STREAM_NO_ERROR;
 }
diff --git a/quic/test_tools/send_algorithm_test_utils.cc b/quic/test_tools/send_algorithm_test_utils.cc
index 122d6e5..f5ca6ee 100644
--- a/quic/test_tools/send_algorithm_test_utils.cc
+++ b/quic/test_tools/send_algorithm_test_utils.cc
@@ -5,9 +5,9 @@
 #include "net/third_party/quiche/src/quic/test_tools/send_algorithm_test_utils.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/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test_output.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
 
 namespace quic {
 namespace test {
@@ -49,8 +49,9 @@
       test_info->type_param() ? test_info->type_param() : "";
   const std::string value_param =
       test_info->value_param() ? test_info->value_param() : "";
-  return QuicStrCat(test_info->test_suite_name(), ".", test_info->name(), "_",
-                    type_param, "_", value_param);
+  return quiche::QuicheStrCat(test_info->test_suite_name(), ".",
+                              test_info->name(), "_", type_param, "_",
+                              value_param);
 }
 
 std::string GetSendAlgorithmTestResultFilename() {
diff --git a/quic/test_tools/simple_data_producer.cc b/quic/test_tools/simple_data_producer.cc
index ad8b2c3..0d5fa5b 100644
--- a/quic/test_tools/simple_data_producer.cc
+++ b/quic/test_tools/simple_data_producer.cc
@@ -10,6 +10,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -35,7 +36,7 @@
 
 void SimpleDataProducer::SaveCryptoData(EncryptionLevel level,
                                         QuicStreamOffset offset,
-                                        QuicStringPiece data) {
+                                        quiche::QuicheStringPiece data) {
   auto key = std::make_pair(level, offset);
   crypto_buffer_map_[key] = data;
 }
@@ -64,7 +65,7 @@
     return false;
   }
   return writer->WriteStringPiece(
-      QuicStringPiece(it->second.data(), data_length));
+      quiche::QuicheStringPiece(it->second.data(), data_length));
 }
 
 }  // namespace test
diff --git a/quic/test_tools/simple_data_producer.h b/quic/test_tools/simple_data_producer.h
index d51ec69..be0d846 100644
--- a/quic/test_tools/simple_data_producer.h
+++ b/quic/test_tools/simple_data_producer.h
@@ -9,6 +9,7 @@
 #include "net/third_party/quiche/src/quic/core/quic_stream_frame_data_producer.h"
 #include "net/third_party/quiche/src/quic/core/quic_stream_send_buffer.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -35,7 +36,7 @@
 
   void SaveCryptoData(EncryptionLevel level,
                       QuicStreamOffset offset,
-                      QuicStringPiece data);
+                      quiche::QuicheStringPiece data);
 
   // QuicStreamFrameDataProducer
   WriteStreamDataResult WriteStreamData(QuicStreamId id,
@@ -62,7 +63,7 @@
 
   using CryptoBufferMap =
       QuicUnorderedMap<std::pair<EncryptionLevel, QuicStreamOffset>,
-                       QuicStringPiece,
+                       quiche::QuicheStringPiece,
                        PairHash>;
 
   SimpleBufferAllocator allocator_;
diff --git a/quic/test_tools/simple_quic_framer.cc b/quic/test_tools/simple_quic_framer.cc
index 588f3b6..4dc4510 100644
--- a/quic/test_tools/simple_quic_framer.cc
+++ b/quic/test_tools/simple_quic_framer.cc
@@ -10,7 +10,7 @@
 #include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
 #include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -41,7 +41,7 @@
 
   void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
                      QuicConnectionId /*new_connection_id*/,
-                     QuicStringPiece /*retry_token*/) override {}
+                     quiche::QuicheStringPiece /*retry_token*/) override {}
 
   bool OnUnauthenticatedPublicHeader(
       const QuicPacketHeader& /*header*/) override {
@@ -75,7 +75,7 @@
     // TODO(ianswett): A pointer isn't necessary with emplace_back.
     stream_frames_.push_back(std::make_unique<QuicStreamFrame>(
         frame.stream_id, frame.fin, frame.offset,
-        QuicStringPiece(*string_data)));
+        quiche::QuicheStringPiece(*string_data)));
     return true;
   }
 
@@ -85,7 +85,7 @@
         new std::string(frame.data_buffer, frame.data_length);
     crypto_data_.push_back(QuicWrapUnique(string_data));
     crypto_frames_.push_back(std::make_unique<QuicCryptoFrame>(
-        frame.level, frame.offset, QuicStringPiece(*string_data)));
+        frame.level, frame.offset, quiche::QuicheStringPiece(*string_data)));
     return true;
   }
 
diff --git a/quic/test_tools/simulator/alarm_factory.cc b/quic/test_tools/simulator/alarm_factory.cc
index e748da5..723605f 100644
--- a/quic/test_tools/simulator/alarm_factory.cc
+++ b/quic/test_tools/simulator/alarm_factory.cc
@@ -5,7 +5,7 @@
 #include "net/third_party/quiche/src/quic/test_tools/simulator/alarm_factory.h"
 
 #include "net/third_party/quiche/src/quic/core/quic_alarm.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 {
 namespace simulator {
@@ -58,7 +58,7 @@
 
 std::string AlarmFactory::GetNewAlarmName() {
   ++counter_;
-  return QuicStringPrintf("%s (alarm %i)", name_.c_str(), counter_);
+  return quiche::QuicheStringPrintf("%s (alarm %i)", name_.c_str(), counter_);
 }
 
 QuicAlarm* AlarmFactory::CreateAlarm(QuicAlarm::Delegate* delegate) {
diff --git a/quic/test_tools/simulator/link.cc b/quic/test_tools/simulator/link.cc
index 110933e..b10024a 100644
--- a/quic/test_tools/simulator/link.cc
+++ b/quic/test_tools/simulator/link.cc
@@ -4,8 +4,8 @@
 
 #include "net/third_party/quiche/src/quic/test_tools/simulator/link.h"
 
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
 #include "net/third_party/quiche/src/quic/test_tools/simulator/simulator.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
 
 namespace quic {
 namespace simulator {
@@ -96,12 +96,12 @@
                              QuicBandwidth bandwidth,
                              QuicTime::Delta propagation_delay)
     : a_to_b_link_(simulator,
-                   QuicStringPrintf("%s (A-to-B)", name.c_str()),
+                   quiche::QuicheStringPrintf("%s (A-to-B)", name.c_str()),
                    sink_b,
                    bandwidth,
                    propagation_delay),
       b_to_a_link_(simulator,
-                   QuicStringPrintf("%s (B-to-A)", name.c_str()),
+                   quiche::QuicheStringPrintf("%s (B-to-A)", name.c_str()),
                    sink_a,
                    bandwidth,
                    propagation_delay) {}
@@ -111,9 +111,9 @@
                              QuicBandwidth bandwidth,
                              QuicTime::Delta propagation_delay)
     : SymmetricLink(endpoint_a->simulator(),
-                    QuicStringPrintf("Link [%s]<->[%s]",
-                                     endpoint_a->name().c_str(),
-                                     endpoint_b->name().c_str()),
+                    quiche::QuicheStringPrintf("Link [%s]<->[%s]",
+                                               endpoint_a->name().c_str(),
+                                               endpoint_b->name().c_str()),
                     endpoint_a->GetRxPort(),
                     endpoint_b->GetRxPort(),
                     bandwidth,
diff --git a/quic/test_tools/simulator/quic_endpoint.cc b/quic/test_tools/simulator/quic_endpoint.cc
index 9f50435..626cc64 100644
--- a/quic/test_tools/simulator/quic_endpoint.cc
+++ b/quic/test_tools/simulator/quic_endpoint.cc
@@ -10,9 +10,7 @@
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake_message.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
 #include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test_output.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/simulator/simulator.h"
diff --git a/quic/test_tools/simulator/quic_endpoint.h b/quic/test_tools/simulator/quic_endpoint.h
index c2d24ac..06c90c4 100644
--- a/quic/test_tools/simulator/quic_endpoint.h
+++ b/quic/test_tools/simulator/quic_endpoint.h
@@ -17,6 +17,7 @@
 #include "net/third_party/quiche/src/quic/test_tools/simulator/link.h"
 #include "net/third_party/quiche/src/quic/test_tools/simulator/queue.h"
 #include "net/third_party/quiche/src/quic/test_tools/simulator/quic_endpoint_base.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace simulator {
@@ -58,7 +59,7 @@
   void OnBlockedFrame(const QuicBlockedFrame& /*frame*/) override {}
   void OnRstStream(const QuicRstStreamFrame& /*frame*/) override {}
   void OnGoAway(const QuicGoAwayFrame& /*frame*/) override {}
-  void OnMessageReceived(QuicStringPiece /*message*/) override {}
+  void OnMessageReceived(quiche::QuicheStringPiece /*message*/) override {}
   void OnConnectionClosed(const QuicConnectionCloseFrame& /*frame*/,
                           ConnectionCloseSource /*source*/) override {}
   void OnWriteBlocked() override {}
diff --git a/quic/test_tools/simulator/quic_endpoint_base.cc b/quic/test_tools/simulator/quic_endpoint_base.cc
index 54c3b57..21815d8 100644
--- a/quic/test_tools/simulator/quic_endpoint_base.cc
+++ b/quic/test_tools/simulator/quic_endpoint_base.cc
@@ -11,12 +11,11 @@
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection.h"
 #include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test_output.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/simulator/simulator.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
 
 namespace quic {
 namespace simulator {
@@ -61,7 +60,7 @@
       peer_name_(peer_name),
       writer_(this),
       nic_tx_queue_(simulator,
-                    QuicStringPrintf("%s (TX Queue)", name.c_str()),
+                    quiche::QuicheStringPrintf("%s (TX Queue)", name.c_str()),
                     kMaxOutgoingPacketSize * kTxQueueSize),
       connection_(nullptr),
       write_blocked_count_(0),
@@ -74,8 +73,8 @@
     const char* perspective_prefix =
         connection_->perspective() == Perspective::IS_CLIENT ? "C" : "S";
 
-    std::string identifier =
-        QuicStrCat(perspective_prefix, connection_->connection_id().ToString());
+    std::string identifier = quiche::QuicheStrCat(
+        perspective_prefix, connection_->connection_id().ToString());
     QuicRecordTrace(identifier, trace_visitor_->trace()->SerializeAsString());
   }
 }
diff --git a/quic/test_tools/simulator/switch.cc b/quic/test_tools/simulator/switch.cc
index e9b57ec..dcfc2d8 100644
--- a/quic/test_tools/simulator/switch.cc
+++ b/quic/test_tools/simulator/switch.cc
@@ -5,8 +5,8 @@
 #include <cinttypes>
 #include <utility>
 
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
 #include "net/third_party/quiche/src/quic/test_tools/simulator/switch.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
 
 namespace quic {
 namespace simulator {
@@ -17,8 +17,8 @@
                QuicByteCount queue_capacity) {
   for (size_t port_number = 1; port_number <= port_count; port_number++) {
     ports_.emplace_back(simulator,
-                        QuicStrCat(name, " (port ", port_number, ")"), this,
-                        port_number, queue_capacity);
+                        quiche::QuicheStrCat(name, " (port ", port_number, ")"),
+                        this, port_number, queue_capacity);
   }
 }
 
@@ -34,7 +34,7 @@
       port_number_(port_number),
       connected_(false),
       queue_(simulator,
-             QuicStringPrintf("%s (queue)", name.c_str()),
+             quiche::QuicheStringPrintf("%s (queue)", name.c_str()),
              queue_capacity) {}
 
 void Switch::Port::AcceptPacket(std::unique_ptr<Packet> packet) {