diff --git a/quic/tools/fake_proof_verifier.h b/quic/tools/fake_proof_verifier.h
index ffeb6e9..a605e07 100644
--- a/quic/tools/fake_proof_verifier.h
+++ b/quic/tools/fake_proof_verifier.h
@@ -6,6 +6,7 @@
 #define QUICHE_QUIC_TOOLS_FAKE_PROOF_VERIFIER_H_
 
 #include "net/third_party/quiche/src/quic/core/crypto/proof_verifier.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -18,7 +19,7 @@
       const uint16_t /*port*/,
       const std::string& /*server_config*/,
       QuicTransportVersion /*quic_version*/,
-      QuicStringPiece /*chlo_hash*/,
+      quiche::QuicheStringPiece /*chlo_hash*/,
       const std::vector<std::string>& /*certs*/,
       const std::string& /*cert_sct*/,
       const std::string& /*signature*/,
diff --git a/quic/tools/quic_backend_response.h b/quic/tools/quic_backend_response.h
index f0b7b89..6537987 100644
--- a/quic/tools/quic_backend_response.h
+++ b/quic/tools/quic_backend_response.h
@@ -6,6 +6,7 @@
 #define QUICHE_QUIC_TOOLS_QUIC_BACKEND_RESPONSE_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/spdy/core/spdy_protocol.h"
 
 namespace quic {
@@ -55,7 +56,9 @@
   SpecialResponseType response_type() const { return response_type_; }
   const spdy::SpdyHeaderBlock& headers() const { return headers_; }
   const spdy::SpdyHeaderBlock& trailers() const { return trailers_; }
-  const QuicStringPiece body() const { return QuicStringPiece(body_); }
+  const quiche::QuicheStringPiece body() const {
+    return quiche::QuicheStringPiece(body_);
+  }
 
   void set_response_type(SpecialResponseType response_type) {
     response_type_ = response_type;
@@ -67,7 +70,7 @@
   void set_trailers(spdy::SpdyHeaderBlock trailers) {
     trailers_ = std::move(trailers);
   }
-  void set_body(QuicStringPiece body) {
+  void set_body(quiche::QuicheStringPiece body) {
     body_.assign(body.data(), body.size());
   }
   uint16_t stop_sending_code() const { return stop_sending_code_; }
diff --git a/quic/tools/quic_client_base.cc b/quic/tools/quic_client_base.cc
index b6c3375..b291463 100644
--- a/quic/tools/quic_client_base.cc
+++ b/quic/tools/quic_client_base.cc
@@ -10,7 +10,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.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"
 
 namespace quic {
 
diff --git a/quic/tools/quic_client_base.h b/quic/tools/quic_client_base.h
index 8cb639b..3160b74 100644
--- a/quic/tools/quic_client_base.h
+++ b/quic/tools/quic_client_base.h
@@ -17,7 +17,7 @@
 #include "net/third_party/quiche/src/quic/core/quic_config.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_macros.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 {
 
@@ -209,7 +209,7 @@
 
   bool initialized() const { return initialized_; }
 
-  void SetPreSharedKey(QuicStringPiece key) {
+  void SetPreSharedKey(quiche::QuicheStringPiece key) {
     crypto_config_.set_pre_shared_key(key);
   }
 
diff --git a/quic/tools/quic_client_interop_test_bin.cc b/quic/tools/quic_client_interop_test_bin.cc
index 8c9f6d1..bea0127 100644
--- a/quic/tools/quic_client_interop_test_bin.cc
+++ b/quic/tools/quic_client_interop_test_bin.cc
@@ -18,6 +18,7 @@
 #include "net/third_party/quiche/src/quic/tools/fake_proof_verifier.h"
 #include "net/third_party/quiche/src/quic/tools/quic_client.h"
 #include "net/third_party/quiche/src/quic/tools/quic_url.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
 
 DEFINE_QUIC_COMMAND_LINE_FLAG(std::string,
                               host,
@@ -252,13 +253,14 @@
   QuicEnableVersion(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99));
 
   // Build the client, and try to connect.
-  QuicSocketAddress addr = tools::LookupAddress(host, QuicStrCat(port));
+  QuicSocketAddress addr =
+      tools::LookupAddress(host, quiche::QuicheStrCat(port));
   if (!addr.IsInitialized()) {
     QUIC_LOG(ERROR) << "Failed to resolve " << host;
     return std::set<Feature>();
   }
   QuicServerId server_id(host, port, false);
-  std::string authority = QuicStrCat(host, ":", port);
+  std::string authority = quiche::QuicheStrCat(host, ":", port);
 
   return AttemptRequest(addr, authority, server_id,
                         /*test_version_negotiation=*/true,
diff --git a/quic/tools/quic_client_test.cc b/quic/tools/quic_client_test.cc
index e460de4..b1923b6 100644
--- a/quic/tools/quic_client_test.cc
+++ b/quic/tools/quic_client_test.cc
@@ -12,12 +12,12 @@
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_epoll.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_port_utils.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/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/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/common/platform/api/quiche_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 namespace quic {
 namespace test {
@@ -40,13 +40,13 @@
   std::unique_ptr<DIR, int (*)(DIR*)> fd_directory(opendir(kPathToFds),
                                                    closedir);
   while ((file = readdir(fd_directory.get())) != nullptr) {
-    QuicStringPiece name(file->d_name);
+    quiche::QuicheStringPiece name(file->d_name);
     if (name == "." || name == "..") {
       continue;
     }
 
-    std::string fd_path = ReadLink(QuicStrCat(kPathToFds, "/", name));
-    if (QuicTextUtils::StartsWith(fd_path, "socket:")) {
+    std::string fd_path = ReadLink(quiche::QuicheStrCat(kPathToFds, "/", name));
+    if (quiche::QuicheTextUtils::StartsWith(fd_path, "socket:")) {
       socket_count++;
     }
   }
diff --git a/quic/tools/quic_epoll_client_factory.cc b/quic/tools/quic_epoll_client_factory.cc
index 113958f..1751f41 100644
--- a/quic/tools/quic_epoll_client_factory.cc
+++ b/quic/tools/quic_epoll_client_factory.cc
@@ -13,6 +13,7 @@
 #include "net/third_party/quiche/src/quic/core/quic_server_id.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
 #include "net/third_party/quiche/src/quic/tools/quic_client.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
 
 namespace quic {
 
@@ -23,7 +24,7 @@
     ParsedQuicVersionVector versions,
     std::unique_ptr<ProofVerifier> verifier) {
   QuicSocketAddress addr =
-      tools::LookupAddress(host_for_lookup, QuicStrCat(port));
+      tools::LookupAddress(host_for_lookup, quiche::QuicheStrCat(port));
   if (!addr.IsInitialized()) {
     QUIC_LOG(ERROR) << "Unable to resolve address: " << host_for_lookup;
     return nullptr;
diff --git a/quic/tools/quic_memory_cache_backend.cc b/quic/tools/quic_memory_cache_backend.cc
index 38d25e5..a769259 100644
--- a/quic/tools/quic_memory_cache_backend.cc
+++ b/quic/tools/quic_memory_cache_backend.cc
@@ -11,7 +11,8 @@
 #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_map_util.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"
 
 using spdy::kV3LowestPriority;
 using spdy::SpdyHeaderBlock;
@@ -39,7 +40,7 @@
     if (file_contents_[pos - 1] == '\r') {
       len -= 1;
     }
-    QuicStringPiece line(file_contents_.data() + start, len);
+    quiche::QuicheStringPiece line(file_contents_.data() + start, len);
     start = pos + 1;
     // Headers end with an empty line.
     if (line.empty()) {
@@ -63,7 +64,8 @@
       return;
     }
     spdy_headers_.AppendValueOrAddHeader(
-        QuicTextUtils::ToLower(line.substr(0, pos)), line.substr(pos + 2));
+        quiche::QuicheTextUtils::ToLower(line.substr(0, pos)),
+        line.substr(pos + 2));
   }
 
   // The connection header is prohibited in HTTP/2.
@@ -81,26 +83,27 @@
   // stuff as described in https://w3c.github.io/preload/.
   it = spdy_headers_.find("x-push-url");
   if (it != spdy_headers_.end()) {
-    QuicStringPiece push_urls = it->second;
+    quiche::QuicheStringPiece push_urls = it->second;
     size_t start = 0;
     while (start < push_urls.length()) {
       size_t pos = push_urls.find('\0', start);
       if (pos == std::string::npos) {
-        push_urls_.push_back(QuicStringPiece(push_urls.data() + start,
-                                             push_urls.length() - start));
+        push_urls_.push_back(quiche::QuicheStringPiece(
+            push_urls.data() + start, push_urls.length() - start));
         break;
       }
-      push_urls_.push_back(QuicStringPiece(push_urls.data() + start, pos));
+      push_urls_.push_back(
+          quiche::QuicheStringPiece(push_urls.data() + start, pos));
       start += pos + 1;
     }
   }
 
-  body_ = QuicStringPiece(file_contents_.data() + start,
-                          file_contents_.size() - start);
+  body_ = quiche::QuicheStringPiece(file_contents_.data() + start,
+                                    file_contents_.size() - start);
 }
 
 void QuicMemoryCacheBackend::ResourceFile::SetHostPathFromBase(
-    QuicStringPiece base) {
+    quiche::QuicheStringPiece base) {
   size_t path_start = base.find_first_of('/');
   DCHECK_LT(0UL, path_start);
   host_ = base.substr(0, path_start);
@@ -112,34 +115,35 @@
   }
 }
 
-QuicStringPiece QuicMemoryCacheBackend::ResourceFile::RemoveScheme(
-    QuicStringPiece url) {
-  if (QuicTextUtils::StartsWith(url, "https://")) {
+quiche::QuicheStringPiece QuicMemoryCacheBackend::ResourceFile::RemoveScheme(
+    quiche::QuicheStringPiece url) {
+  if (quiche::QuicheTextUtils::StartsWith(url, "https://")) {
     url.remove_prefix(8);
-  } else if (QuicTextUtils::StartsWith(url, "http://")) {
+  } else if (quiche::QuicheTextUtils::StartsWith(url, "http://")) {
     url.remove_prefix(7);
   }
   return url;
 }
 
 void QuicMemoryCacheBackend::ResourceFile::HandleXOriginalUrl() {
-  QuicStringPiece url(x_original_url_);
+  quiche::QuicheStringPiece url(x_original_url_);
   // Remove the protocol so we can add it below.
   url = RemoveScheme(url);
   SetHostPathFromBase(url);
 }
 
 const QuicBackendResponse* QuicMemoryCacheBackend::GetResponse(
-    QuicStringPiece host,
-    QuicStringPiece path) const {
+    quiche::QuicheStringPiece host,
+    quiche::QuicheStringPiece path) const {
   QuicWriterMutexLock lock(&response_mutex_);
 
   auto it = responses_.find(GetKey(host, path));
   if (it == responses_.end()) {
     uint64_t ignored = 0;
     if (generate_bytes_response_) {
-      if (QuicTextUtils::StringToUint64(
-              QuicStringPiece(path.data() + 1, path.size() - 1), &ignored)) {
+      if (quiche::QuicheTextUtils::StringToUint64(
+              quiche::QuicheStringPiece(path.data() + 1, path.size() - 1),
+              &ignored)) {
         // The actual parsed length is ignored here and will be recomputed
         // by the caller.
         return generate_bytes_response_.get();
@@ -158,22 +162,23 @@
 typedef QuicBackendResponse::ServerPushInfo ServerPushInfo;
 typedef QuicBackendResponse::SpecialResponseType SpecialResponseType;
 
-void QuicMemoryCacheBackend::AddSimpleResponse(QuicStringPiece host,
-                                               QuicStringPiece path,
+void QuicMemoryCacheBackend::AddSimpleResponse(quiche::QuicheStringPiece host,
+                                               quiche::QuicheStringPiece path,
                                                int response_code,
-                                               QuicStringPiece body) {
+                                               quiche::QuicheStringPiece body) {
   SpdyHeaderBlock response_headers;
-  response_headers[":status"] = QuicTextUtils::Uint64ToString(response_code);
+  response_headers[":status"] =
+      quiche::QuicheTextUtils::Uint64ToString(response_code);
   response_headers["content-length"] =
-      QuicTextUtils::Uint64ToString(body.length());
+      quiche::QuicheTextUtils::Uint64ToString(body.length());
   AddResponse(host, path, std::move(response_headers), body);
 }
 
 void QuicMemoryCacheBackend::AddSimpleResponseWithServerPushResources(
-    QuicStringPiece host,
-    QuicStringPiece path,
+    quiche::QuicheStringPiece host,
+    quiche::QuicheStringPiece path,
     int response_code,
-    QuicStringPiece body,
+    quiche::QuicheStringPiece body,
     std::list<ServerPushInfo> push_resources) {
   AddSimpleResponse(host, path, response_code, body);
   MaybeAddServerPushResources(host, path, push_resources);
@@ -184,48 +189,50 @@
   default_response_.reset(response);
 }
 
-void QuicMemoryCacheBackend::AddResponse(QuicStringPiece host,
-                                         QuicStringPiece path,
-                                         SpdyHeaderBlock response_headers,
-                                         QuicStringPiece response_body) {
+void QuicMemoryCacheBackend::AddResponse(
+    quiche::QuicheStringPiece host,
+    quiche::QuicheStringPiece path,
+    SpdyHeaderBlock response_headers,
+    quiche::QuicheStringPiece response_body) {
   AddResponseImpl(host, path, QuicBackendResponse::REGULAR_RESPONSE,
                   std::move(response_headers), response_body, SpdyHeaderBlock(),
                   0);
 }
 
-void QuicMemoryCacheBackend::AddResponse(QuicStringPiece host,
-                                         QuicStringPiece path,
-                                         SpdyHeaderBlock response_headers,
-                                         QuicStringPiece response_body,
-                                         SpdyHeaderBlock response_trailers) {
+void QuicMemoryCacheBackend::AddResponse(
+    quiche::QuicheStringPiece host,
+    quiche::QuicheStringPiece path,
+    SpdyHeaderBlock response_headers,
+    quiche::QuicheStringPiece response_body,
+    SpdyHeaderBlock response_trailers) {
   AddResponseImpl(host, path, QuicBackendResponse::REGULAR_RESPONSE,
                   std::move(response_headers), response_body,
                   std::move(response_trailers), 0);
 }
 
 void QuicMemoryCacheBackend::AddSpecialResponse(
-    QuicStringPiece host,
-    QuicStringPiece path,
+    quiche::QuicheStringPiece host,
+    quiche::QuicheStringPiece path,
     SpecialResponseType response_type) {
   AddResponseImpl(host, path, response_type, SpdyHeaderBlock(), "",
                   SpdyHeaderBlock(), 0);
 }
 
 void QuicMemoryCacheBackend::AddSpecialResponse(
-    QuicStringPiece host,
-    QuicStringPiece path,
+    quiche::QuicheStringPiece host,
+    quiche::QuicheStringPiece path,
     spdy::SpdyHeaderBlock response_headers,
-    QuicStringPiece response_body,
+    quiche::QuicheStringPiece response_body,
     SpecialResponseType response_type) {
   AddResponseImpl(host, path, response_type, std::move(response_headers),
                   response_body, SpdyHeaderBlock(), 0);
 }
 
 void QuicMemoryCacheBackend::AddStopSendingResponse(
-    QuicStringPiece host,
-    QuicStringPiece path,
+    quiche::QuicheStringPiece host,
+    quiche::QuicheStringPiece path,
     spdy::SpdyHeaderBlock response_headers,
-    QuicStringPiece response_body,
+    quiche::QuicheStringPiece response_body,
     uint16_t stop_sending_code) {
   AddResponseImpl(host, path, SpecialResponseType::STOP_SENDING,
                   std::move(response_headers), response_body, SpdyHeaderBlock(),
@@ -249,7 +256,7 @@
     std::unique_ptr<ResourceFile> resource_file(new ResourceFile(filename));
 
     // Tease apart filename into host and path.
-    QuicStringPiece base(resource_file->file_name());
+    quiche::QuicheStringPiece base(resource_file->file_name());
     base.remove_prefix(cache_directory.length());
     if (base[0] == '/') {
       base.remove_prefix(1);
@@ -346,13 +353,14 @@
   }
 }
 
-void QuicMemoryCacheBackend::AddResponseImpl(QuicStringPiece host,
-                                             QuicStringPiece path,
-                                             SpecialResponseType response_type,
-                                             SpdyHeaderBlock response_headers,
-                                             QuicStringPiece response_body,
-                                             SpdyHeaderBlock response_trailers,
-                                             uint16_t stop_sending_code) {
+void QuicMemoryCacheBackend::AddResponseImpl(
+    quiche::QuicheStringPiece host,
+    quiche::QuicheStringPiece path,
+    SpecialResponseType response_type,
+    SpdyHeaderBlock response_headers,
+    quiche::QuicheStringPiece response_body,
+    SpdyHeaderBlock response_trailers,
+    uint16_t stop_sending_code) {
   QuicWriterMutexLock lock(&response_mutex_);
 
   DCHECK(!host.empty()) << "Host must be populated, e.g. \"www.google.com\"";
@@ -371,8 +379,9 @@
   responses_[key] = std::move(new_response);
 }
 
-std::string QuicMemoryCacheBackend::GetKey(QuicStringPiece host,
-                                           QuicStringPiece path) const {
+std::string QuicMemoryCacheBackend::GetKey(
+    quiche::QuicheStringPiece host,
+    quiche::QuicheStringPiece path) const {
   std::string host_string = std::string(host);
   size_t port = host_string.find(':');
   if (port != std::string::npos)
@@ -381,8 +390,8 @@
 }
 
 void QuicMemoryCacheBackend::MaybeAddServerPushResources(
-    QuicStringPiece request_host,
-    QuicStringPiece request_path,
+    quiche::QuicheStringPiece request_host,
+    quiche::QuicheStringPiece request_path,
     std::list<ServerPushInfo> push_resources) {
   std::string request_url = GetKey(request_host, request_path);
 
@@ -412,7 +421,7 @@
     }
     if (!found_existing_response) {
       // Add a server push response to responses map, if it is not in the map.
-      QuicStringPiece body = push_resource.body;
+      quiche::QuicheStringPiece body = push_resource.body;
       QUIC_DVLOG(1) << "Add response for push resource: host " << host
                     << " path " << path;
       AddResponse(host, path, push_resource.headers.Clone(), body);
diff --git a/quic/tools/quic_memory_cache_backend.h b/quic/tools/quic_memory_cache_backend.h
index f88d458..48a5c59 100644
--- a/quic/tools/quic_memory_cache_backend.h
+++ b/quic/tools/quic_memory_cache_backend.h
@@ -13,10 +13,10 @@
 #include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_containers.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/tools/quic_backend_response.h"
 #include "net/third_party/quiche/src/quic/tools/quic_simple_server_backend.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/spdy/core/spdy_framer.h"
 
 namespace quic {
@@ -40,34 +40,36 @@
     void Read();
 
     // |base| is |file_name_| with |cache_directory| prefix stripped.
-    void SetHostPathFromBase(QuicStringPiece base);
+    void SetHostPathFromBase(quiche::QuicheStringPiece base);
 
     const std::string& file_name() { return file_name_; }
 
-    QuicStringPiece host() { return host_; }
+    quiche::QuicheStringPiece host() { return host_; }
 
-    QuicStringPiece path() { return path_; }
+    quiche::QuicheStringPiece path() { return path_; }
 
     const spdy::SpdyHeaderBlock& spdy_headers() { return spdy_headers_; }
 
-    QuicStringPiece body() { return body_; }
+    quiche::QuicheStringPiece body() { return body_; }
 
-    const std::vector<QuicStringPiece>& push_urls() { return push_urls_; }
+    const std::vector<quiche::QuicheStringPiece>& push_urls() {
+      return push_urls_;
+    }
 
    protected:
     void HandleXOriginalUrl();
-    QuicStringPiece RemoveScheme(QuicStringPiece url);
+    quiche::QuicheStringPiece RemoveScheme(quiche::QuicheStringPiece url);
 
     std::string file_name_;
     std::string file_contents_;
-    QuicStringPiece body_;
+    quiche::QuicheStringPiece body_;
     spdy::SpdyHeaderBlock spdy_headers_;
-    QuicStringPiece x_original_url_;
-    std::vector<QuicStringPiece> push_urls_;
+    quiche::QuicheStringPiece x_original_url_;
+    std::vector<quiche::QuicheStringPiece> push_urls_;
 
    private:
-    QuicStringPiece host_;
-    QuicStringPiece path_;
+    quiche::QuicheStringPiece host_;
+    quiche::QuicheStringPiece path_;
   };
 
   QuicMemoryCacheBackend();
@@ -77,57 +79,57 @@
 
   // Retrieve a response from this cache for a given host and path..
   // If no appropriate response exists, nullptr is returned.
-  const QuicBackendResponse* GetResponse(QuicStringPiece host,
-                                         QuicStringPiece path) const;
+  const QuicBackendResponse* GetResponse(quiche::QuicheStringPiece host,
+                                         quiche::QuicheStringPiece path) const;
 
   // Adds a simple response to the cache.  The response headers will
   // only contain the "content-length" header with the length of |body|.
-  void AddSimpleResponse(QuicStringPiece host,
-                         QuicStringPiece path,
+  void AddSimpleResponse(quiche::QuicheStringPiece host,
+                         quiche::QuicheStringPiece path,
                          int response_code,
-                         QuicStringPiece body);
+                         quiche::QuicheStringPiece body);
 
   // Add a simple response to the cache as AddSimpleResponse() does, and add
   // some server push resources(resource path, corresponding response status and
   // path) associated with it.
   // Push resource implicitly come from the same host.
   void AddSimpleResponseWithServerPushResources(
-      QuicStringPiece host,
-      QuicStringPiece path,
+      quiche::QuicheStringPiece host,
+      quiche::QuicheStringPiece path,
       int response_code,
-      QuicStringPiece body,
+      quiche::QuicheStringPiece body,
       std::list<QuicBackendResponse::ServerPushInfo> push_resources);
 
   // Add a response to the cache.
-  void AddResponse(QuicStringPiece host,
-                   QuicStringPiece path,
+  void AddResponse(quiche::QuicheStringPiece host,
+                   quiche::QuicheStringPiece path,
                    spdy::SpdyHeaderBlock response_headers,
-                   QuicStringPiece response_body);
+                   quiche::QuicheStringPiece response_body);
 
   // Add a response, with trailers, to the cache.
-  void AddResponse(QuicStringPiece host,
-                   QuicStringPiece path,
+  void AddResponse(quiche::QuicheStringPiece host,
+                   quiche::QuicheStringPiece path,
                    spdy::SpdyHeaderBlock response_headers,
-                   QuicStringPiece response_body,
+                   quiche::QuicheStringPiece response_body,
                    spdy::SpdyHeaderBlock response_trailers);
 
   // Simulate a special behavior at a particular path.
   void AddSpecialResponse(
-      QuicStringPiece host,
-      QuicStringPiece path,
+      quiche::QuicheStringPiece host,
+      quiche::QuicheStringPiece path,
       QuicBackendResponse::SpecialResponseType response_type);
 
   void AddSpecialResponse(
-      QuicStringPiece host,
-      QuicStringPiece path,
+      quiche::QuicheStringPiece host,
+      quiche::QuicheStringPiece path,
       spdy::SpdyHeaderBlock response_headers,
-      QuicStringPiece response_body,
+      quiche::QuicheStringPiece response_body,
       QuicBackendResponse::SpecialResponseType response_type);
 
-  void AddStopSendingResponse(QuicStringPiece host,
-                              QuicStringPiece path,
+  void AddStopSendingResponse(quiche::QuicheStringPiece host,
+                              quiche::QuicheStringPiece path,
                               spdy::SpdyHeaderBlock response_headers,
-                              QuicStringPiece response_body,
+                              quiche::QuicheStringPiece response_body,
                               uint16_t stop_sending_code);
 
   // Sets a default response in case of cache misses.  Takes ownership of
@@ -154,21 +156,22 @@
       QuicSimpleServerBackend::RequestHandler* quic_server_stream) override;
 
  private:
-  void AddResponseImpl(QuicStringPiece host,
-                       QuicStringPiece path,
+  void AddResponseImpl(quiche::QuicheStringPiece host,
+                       quiche::QuicheStringPiece path,
                        QuicBackendResponse::SpecialResponseType response_type,
                        spdy::SpdyHeaderBlock response_headers,
-                       QuicStringPiece response_body,
+                       quiche::QuicheStringPiece response_body,
                        spdy::SpdyHeaderBlock response_trailers,
                        uint16_t stop_sending_code);
 
-  std::string GetKey(QuicStringPiece host, QuicStringPiece path) const;
+  std::string GetKey(quiche::QuicheStringPiece host,
+                     quiche::QuicheStringPiece path) const;
 
   // Add some server push urls with given responses for specified
   // request if these push resources are not associated with this request yet.
   void MaybeAddServerPushResources(
-      QuicStringPiece request_host,
-      QuicStringPiece request_path,
+      quiche::QuicheStringPiece request_host,
+      quiche::QuicheStringPiece request_path,
       std::list<QuicBackendResponse::ServerPushInfo> push_resources);
 
   // Check if push resource(push_host/push_path) associated with given request
diff --git a/quic/tools/quic_memory_cache_backend_test.cc b/quic/tools/quic_memory_cache_backend_test.cc
index 01ac334..c028e41 100644
--- a/quic/tools/quic_memory_cache_backend_test.cc
+++ b/quic/tools/quic_memory_cache_backend_test.cc
@@ -5,10 +5,10 @@
 #include "net/third_party/quiche/src/quic/tools/quic_memory_cache_backend.h"
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.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_text_utils.h"
 #include "net/third_party/quiche/src/quic/tools/quic_backend_response.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 namespace quic {
 namespace test {
@@ -61,7 +61,7 @@
   spdy::SpdyHeaderBlock response_headers;
   response_headers[":status"] = "200";
   response_headers["content-length"] =
-      QuicTextUtils::Uint64ToString(kResponseBody.size());
+      quiche::QuicheTextUtils::Uint64ToString(kResponseBody.size());
 
   spdy::SpdyHeaderBlock response_trailers;
   response_trailers["key-1"] = "value-1";
@@ -156,15 +156,16 @@
   std::list<ServerPushInfo> push_resources;
   std::string scheme = "http";
   for (int i = 0; i < NumResources; ++i) {
-    std::string path = "/server_push_src" + QuicTextUtils::Uint64ToString(i);
+    std::string path =
+        "/server_push_src" + quiche::QuicheTextUtils::Uint64ToString(i);
     std::string url = scheme + "://" + request_host + path;
     QuicUrl resource_url(url);
     std::string body =
-        QuicStrCat("This is server push response body for ", path);
+        quiche::QuicheStrCat("This is server push response body for ", path);
     spdy::SpdyHeaderBlock response_headers;
     response_headers[":status"] = "200";
     response_headers["content-length"] =
-        QuicTextUtils::Uint64ToString(body.size());
+        quiche::QuicheTextUtils::Uint64ToString(body.size());
     push_resources.push_back(
         ServerPushInfo(resource_url, response_headers.Clone(), i, body));
   }
@@ -195,14 +196,15 @@
                                                      "404"};
   std::list<ServerPushInfo> push_resources;
   for (int i = 0; i < NumResources; ++i) {
-    std::string path = "/server_push_src" + QuicTextUtils::Uint64ToString(i);
+    std::string path =
+        "/server_push_src" + quiche::QuicheTextUtils::Uint64ToString(i);
     std::string url = scheme + "://" + request_host + path;
     QuicUrl resource_url(url);
     std::string body = "This is server push response body for " + path;
     spdy::SpdyHeaderBlock response_headers;
     response_headers[":status"] = push_response_status[i];
     response_headers["content-length"] =
-        QuicTextUtils::Uint64ToString(body.size());
+        quiche::QuicheTextUtils::Uint64ToString(body.size());
     push_resources.push_back(
         ServerPushInfo(resource_url, response_headers.Clone(), i, body));
   }
diff --git a/quic/tools/quic_packet_printer_bin.cc b/quic/tools/quic_packet_printer_bin.cc
index 7738ea7..20f4cf8 100644
--- a/quic/tools/quic_packet_printer_bin.cc
+++ b/quic/tools/quic_packet_printer_bin.cc
@@ -31,7 +31,8 @@
 #include "net/third_party/quiche/src/quic/core/quic_framer.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 DEFINE_QUIC_COMMAND_LINE_FLAG(std::string,
                               quic_version,
@@ -64,7 +65,7 @@
   }
   void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
                      QuicConnectionId /*new_connection_id*/,
-                     QuicStringPiece /*retry_token*/) override {
+                     quiche::QuicheStringPiece /*retry_token*/) override {
     std::cerr << "OnRetryPacket\n";
   }
   bool OnUnauthenticatedPublicHeader(
@@ -96,14 +97,16 @@
   bool OnStreamFrame(const QuicStreamFrame& frame) override {
     std::cerr << "OnStreamFrame: " << frame;
     std::cerr << "         data: { "
-              << QuicTextUtils::HexEncode(frame.data_buffer, frame.data_length)
+              << quiche::QuicheTextUtils::HexEncode(frame.data_buffer,
+                                                    frame.data_length)
               << " }\n";
     return true;
   }
   bool OnCryptoFrame(const QuicCryptoFrame& frame) override {
     std::cerr << "OnCryptoFrame: " << frame;
     std::cerr << "         data: { "
-              << QuicTextUtils::HexEncode(frame.data_buffer, frame.data_length)
+              << quiche::QuicheTextUtils::HexEncode(frame.data_buffer,
+                                                    frame.data_length)
               << " }\n";
     return true;
   }
@@ -235,7 +238,7 @@
     quic::QuicPrintCommandLineFlagHelp(usage);
     return 1;
   }
-  std::string hex = quic::QuicTextUtils::HexDecode(args[1]);
+  std::string hex = quiche::QuicheTextUtils::HexDecode(args[1]);
   quic::ParsedQuicVersionVector versions = quic::AllSupportedVersions();
   // Fake a time since we're not actually generating acks.
   quic::QuicTime start(quic::QuicTime::Zero());
diff --git a/quic/tools/quic_reject_reason_decoder_bin.cc b/quic/tools/quic_reject_reason_decoder_bin.cc
index de66774..f7e3b75 100644
--- a/quic/tools/quic_reject_reason_decoder_bin.cc
+++ b/quic/tools/quic_reject_reason_decoder_bin.cc
@@ -10,7 +10,7 @@
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_handshake.h"
 #include "net/third_party/quiche/src/quic/core/crypto/crypto_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 using quic::CryptoUtils;
 using quic::HandshakeFailureReason;
@@ -27,7 +27,7 @@
   }
 
   uint32_t packed_error = 0;
-  if (!quic::QuicTextUtils::StringToUint32(args[0], &packed_error)) {
+  if (!quiche::QuicheTextUtils::StringToUint32(args[0], &packed_error)) {
     std::cerr << "Unable to parse: " << args[0] << "\n";
     return 2;
   }
diff --git a/quic/tools/quic_server.h b/quic/tools/quic_server.h
index 0b11be3..d2d9782 100644
--- a/quic/tools/quic_server.h
+++ b/quic/tools/quic_server.h
@@ -23,6 +23,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
 #include "net/third_party/quiche/src/quic/tools/quic_simple_server_backend.h"
 #include "net/third_party/quiche/src/quic/tools/quic_spdy_server_base.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -79,7 +80,7 @@
     crypto_config_.set_chlo_multiplier(multiplier);
   }
 
-  void SetPreSharedKey(QuicStringPiece key) {
+  void SetPreSharedKey(quiche::QuicheStringPiece key) {
     crypto_config_.set_pre_shared_key(key);
   }
 
diff --git a/quic/tools/quic_simple_dispatcher.cc b/quic/tools/quic_simple_dispatcher.cc
index 0f4d447..f5f5a6c 100644
--- a/quic/tools/quic_simple_dispatcher.cc
+++ b/quic/tools/quic_simple_dispatcher.cc
@@ -5,6 +5,7 @@
 #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 {
 
@@ -50,7 +51,7 @@
 QuicServerSessionBase* QuicSimpleDispatcher::CreateQuicSession(
     QuicConnectionId connection_id,
     const QuicSocketAddress& client_address,
-    QuicStringPiece /*alpn*/,
+    quiche::QuicheStringPiece /*alpn*/,
     const ParsedQuicVersion& version) {
   // The QuicServerSessionBase takes ownership of |connection| below.
   QuicConnection* connection = new QuicConnection(
diff --git a/quic/tools/quic_simple_dispatcher.h b/quic/tools/quic_simple_dispatcher.h
index 8a6cf85..4d04400 100644
--- a/quic/tools/quic_simple_dispatcher.h
+++ b/quic/tools/quic_simple_dispatcher.h
@@ -8,6 +8,7 @@
 #include "net/third_party/quiche/src/quic/core/http/quic_server_session_base.h"
 #include "net/third_party/quiche/src/quic/core/quic_dispatcher.h"
 #include "net/third_party/quiche/src/quic/tools/quic_simple_server_backend.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -33,7 +34,7 @@
   QuicServerSessionBase* CreateQuicSession(
       QuicConnectionId connection_id,
       const QuicSocketAddress& client_address,
-      QuicStringPiece alpn,
+      quiche::QuicheStringPiece alpn,
       const ParsedQuicVersion& version) override;
 
   QuicSimpleServerBackend* server_backend() {
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index 0af12e2..96cb3ac 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -20,9 +20,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.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/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/crypto_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/mock_quic_session_visitor.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
@@ -36,6 +34,8 @@
 #include "net/third_party/quiche/src/quic/tools/quic_backend_response.h"
 #include "net/third_party/quiche/src/quic/tools/quic_memory_cache_backend.h"
 #include "net/third_party/quiche/src/quic/tools/quic_simple_server_stream.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"
 
 using testing::_;
 using testing::AtLeast;
@@ -297,7 +297,7 @@
   // Open a stream, then reset it.
   // Send two bytes of payload to open it.
   QuicStreamFrame data1(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                        QuicStringPiece("HT"));
+                        quiche::QuicheStringPiece("HT"));
   session_->OnStreamFrame(data1);
   EXPECT_EQ(1u, session_->GetNumOpenIncomingStreams());
 
@@ -353,7 +353,7 @@
 
   // Send two bytes of payload.
   QuicStreamFrame data1(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                        QuicStringPiece("HT"));
+                        quiche::QuicheStringPiece("HT"));
   session_->OnStreamFrame(data1);
 
   // The stream should never be opened, now that the reset is received.
@@ -364,9 +364,9 @@
 TEST_P(QuicSimpleServerSessionTest, AcceptClosedStream) {
   // Send (empty) compressed headers followed by two bytes of data.
   QuicStreamFrame frame1(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                         QuicStringPiece("\1\0\0\0\0\0\0\0HT"));
+                         quiche::QuicheStringPiece("\1\0\0\0\0\0\0\0HT"));
   QuicStreamFrame frame2(GetNthClientInitiatedBidirectionalId(1), false, 0,
-                         QuicStringPiece("\2\0\0\0\0\0\0\0HT"));
+                         quiche::QuicheStringPiece("\2\0\0\0\0\0\0\0HT"));
   session_->OnStreamFrame(frame1);
   session_->OnStreamFrame(frame2);
   EXPECT_EQ(2u, session_->GetNumOpenIncomingStreams());
@@ -394,9 +394,9 @@
   // past the reset point of stream 3.  As it's a closed stream we just drop the
   // data on the floor, but accept the packet because it has data for stream 5.
   QuicStreamFrame frame3(GetNthClientInitiatedBidirectionalId(0), false, 2,
-                         QuicStringPiece("TP"));
+                         quiche::QuicheStringPiece("TP"));
   QuicStreamFrame frame4(GetNthClientInitiatedBidirectionalId(1), false, 2,
-                         QuicStringPiece("TP"));
+                         quiche::QuicheStringPiece("TP"));
   session_->OnStreamFrame(frame3);
   session_->OnStreamFrame(frame4);
   // The stream should never be opened, now that the reset is received.
@@ -478,7 +478,7 @@
   // Receive some data to initiate a incoming stream which should not effect
   // creating outgoing streams.
   QuicStreamFrame data1(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                        QuicStringPiece("HT"));
+                        quiche::QuicheStringPiece("HT"));
   session_->OnStreamFrame(data1);
   EXPECT_EQ(1u, session_->GetNumOpenIncomingStreams());
   EXPECT_EQ(0u, session_->GetNumOpenOutgoingStreams());
@@ -524,14 +524,14 @@
 
   // Create peer initiated stream should have no problem.
   QuicStreamFrame data2(GetNthClientInitiatedBidirectionalId(1), false, 0,
-                        QuicStringPiece("HT"));
+                        quiche::QuicheStringPiece("HT"));
   session_->OnStreamFrame(data2);
   EXPECT_EQ(2u, session_->GetNumOpenIncomingStreams());
 }
 
 TEST_P(QuicSimpleServerSessionTest, OnStreamFrameWithEvenStreamId) {
   QuicStreamFrame frame(GetNthServerInitiatedUnidirectionalId(0), false, 0,
-                        QuicStringPiece());
+                        quiche::QuicheStringPiece());
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_INVALID_STREAM_ID,
                               "Client sent data on server push stream", _));
@@ -651,8 +651,8 @@
       } else {
         stream_id = GetNthServerInitiatedUnidirectionalId(i - 1);
       }
-      std::string path =
-          partial_push_resource_path + QuicTextUtils::Uint64ToString(i);
+      std::string path = partial_push_resource_path +
+                         quiche::QuicheTextUtils::Uint64ToString(i);
       std::string url = scheme + "://" + resource_host + path;
       QuicUrl resource_url = QuicUrl(url);
       std::string body(body_size, 'a');
diff --git a/quic/tools/quic_simple_server_stream.cc b/quic/tools/quic_simple_server_stream.cc
index f821a5d..05a7310 100644
--- a/quic/tools/quic_simple_server_stream.cc
+++ b/quic/tools/quic_simple_server_stream.cc
@@ -14,8 +14,9 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.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"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
 
 using spdy::SpdyHeaderBlock;
@@ -265,14 +266,15 @@
   if (response->response_type() == QuicBackendResponse::GENERATE_BYTES) {
     QUIC_DVLOG(1) << "Stream " << id() << " sending a generate bytes response.";
     std::string path = request_headers_[":path"].as_string().substr(1);
-    if (!QuicTextUtils::StringToUint64(path, &generate_bytes_length_)) {
+    if (!quiche::QuicheTextUtils::StringToUint64(path,
+                                                 &generate_bytes_length_)) {
       QUIC_LOG(ERROR) << "Path is not a number.";
       SendNotFoundResponse();
       return;
     }
     SpdyHeaderBlock headers = response->headers().Clone();
     headers["content-length"] =
-        QuicTextUtils::Uint64ToString(generate_bytes_length_);
+        quiche::QuicheTextUtils::Uint64ToString(generate_bytes_length_);
 
     WriteHeaders(std::move(headers), false, nullptr);
 
@@ -307,7 +309,7 @@
   SpdyHeaderBlock headers;
   headers[":status"] = "404";
   headers["content-length"] =
-      QuicTextUtils::Uint64ToString(strlen(kNotFoundResponseBody));
+      quiche::QuicheTextUtils::Uint64ToString(strlen(kNotFoundResponseBody));
   SendHeadersAndBody(std::move(headers), kNotFoundResponseBody);
 }
 
@@ -321,16 +323,16 @@
   if (resp_code <= 0) {
     headers[":status"] = "500";
   } else {
-    headers[":status"] = QuicTextUtils::Uint64ToString(resp_code);
+    headers[":status"] = quiche::QuicheTextUtils::Uint64ToString(resp_code);
   }
   headers["content-length"] =
-      QuicTextUtils::Uint64ToString(strlen(kErrorResponseBody));
+      quiche::QuicheTextUtils::Uint64ToString(strlen(kErrorResponseBody));
   SendHeadersAndBody(std::move(headers), kErrorResponseBody);
 }
 
 void QuicSimpleServerStream::SendIncompleteResponse(
     SpdyHeaderBlock response_headers,
-    QuicStringPiece body) {
+    quiche::QuicheStringPiece body) {
   QUIC_DLOG(INFO) << "Stream " << id() << " writing headers (fin = false) : "
                   << response_headers.DebugString();
   WriteHeaders(std::move(response_headers), /*fin=*/false, nullptr);
@@ -344,14 +346,14 @@
 
 void QuicSimpleServerStream::SendHeadersAndBody(
     SpdyHeaderBlock response_headers,
-    QuicStringPiece body) {
+    quiche::QuicheStringPiece body) {
   SendHeadersAndBodyAndTrailers(std::move(response_headers), body,
                                 SpdyHeaderBlock());
 }
 
 void QuicSimpleServerStream::SendHeadersAndBodyAndTrailers(
     SpdyHeaderBlock response_headers,
-    QuicStringPiece body,
+    quiche::QuicheStringPiece body,
     SpdyHeaderBlock response_trailers) {
   // Send the headers, with a FIN if there's nothing else to send.
   bool send_fin = (body.empty() && response_trailers.empty());
diff --git a/quic/tools/quic_simple_server_stream.h b/quic/tools/quic_simple_server_stream.h
index 594ca02..add4a12 100644
--- a/quic/tools/quic_simple_server_stream.h
+++ b/quic/tools/quic_simple_server_stream.h
@@ -7,9 +7,9 @@
 
 #include "net/third_party/quiche/src/quic/core/http/quic_spdy_server_stream_base.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/tools/quic_backend_response.h"
 #include "net/third_party/quiche/src/quic/tools/quic_simple_server_backend.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_framer.h"
 
 namespace quic {
@@ -77,12 +77,12 @@
 
   // Sends the response header and body, but not the fin.
   void SendIncompleteResponse(spdy::SpdyHeaderBlock response_headers,
-                              QuicStringPiece body);
+                              quiche::QuicheStringPiece body);
 
   void SendHeadersAndBody(spdy::SpdyHeaderBlock response_headers,
-                          QuicStringPiece body);
+                          quiche::QuicheStringPiece body);
   void SendHeadersAndBodyAndTrailers(spdy::SpdyHeaderBlock response_headers,
-                                     QuicStringPiece body,
+                                     quiche::QuicheStringPiece body,
                                      spdy::SpdyHeaderBlock response_trailers);
 
   spdy::SpdyHeaderBlock* request_headers() { return &request_headers_; }
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index 50ca84f..b06b752 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -25,6 +25,7 @@
 #include "net/third_party/quiche/src/quic/tools/quic_backend_response.h"
 #include "net/third_party/quiche/src/quic/tools/quic_memory_cache_backend.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"
 
 using testing::_;
 using testing::AnyNumber;
@@ -71,7 +72,7 @@
   const std::string& body() const { return body_; }
   int content_length() const { return content_length_; }
 
-  QuicStringPiece GetHeader(QuicStringPiece key) const {
+  quiche::QuicheStringPiece GetHeader(quiche::QuicheStringPiece key) const {
     auto it = request_headers_.find(key);
     DCHECK(it != request_headers_.end());
     return it->second;
@@ -585,7 +586,8 @@
 
   spdy::SpdyHeaderBlock request_headers;
   // \000 is a way to write the null byte when followed by a literal digit.
-  header_list_.OnHeader("content-length", QuicStringPiece("11\00012", 5));
+  header_list_.OnHeader("content-length",
+                        quiche::QuicheStringPiece("11\00012", 5));
 
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
   EXPECT_CALL(session_, WritevData(_, _, _, _, _))
@@ -602,7 +604,8 @@
 
   spdy::SpdyHeaderBlock request_headers;
   // \000 is a way to write the null byte when followed by a literal digit.
-  header_list_.OnHeader("content-length", QuicStringPiece("\00012", 3));
+  header_list_.OnHeader("content-length",
+                        quiche::QuicheStringPiece("\00012", 3));
 
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
   EXPECT_CALL(session_, WritevData(_, _, _, _, _))
@@ -617,7 +620,8 @@
 TEST_P(QuicSimpleServerStreamTest, ValidMultipleContentLength) {
   spdy::SpdyHeaderBlock request_headers;
   // \000 is a way to write the null byte when followed by a literal digit.
-  header_list_.OnHeader("content-length", QuicStringPiece("11\00011", 5));
+  header_list_.OnHeader("content-length",
+                        quiche::QuicheStringPiece("11\00011", 5));
 
   stream_->OnStreamHeaderList(false, kFakeFrameLen, header_list_);
 
@@ -681,7 +685,7 @@
       0x54, 0x54, 0x50, 0x2f,  // TTP/
       0x31, 0x2e, 0x31,        // 1.1
   };
-  QuicStringPiece data(arr, QUIC_ARRAYSIZE(arr));
+  quiche::QuicheStringPiece data(arr, QUIC_ARRAYSIZE(arr));
   QuicStreamFrame frame(stream_->id(), true, 0, data);
   // Verify that we don't crash when we get a invalid headers in stream frame.
   stream_->OnStreamFrame(frame);
diff --git a/quic/tools/quic_spdy_client_base.cc b/quic/tools/quic_spdy_client_base.cc
index 6b4cc8d..a0d7342 100644
--- a/quic/tools/quic_spdy_client_base.cc
+++ b/quic/tools/quic_spdy_client_base.cc
@@ -11,7 +11,8 @@
 #include "net/third_party/quiche/src/quic/core/quic_server_id.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.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/common/platform/api/quiche_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 using spdy::SpdyHeaderBlock;
 
@@ -24,7 +25,7 @@
 
 QuicSpdyClientBase::QuicDataToResend::QuicDataToResend(
     std::unique_ptr<SpdyHeaderBlock> headers,
-    QuicStringPiece body,
+    quiche::QuicheStringPiece body,
     bool fin)
     : headers_(std::move(headers)), body_(body), fin_(fin) {}
 
@@ -90,8 +91,8 @@
     auto status = response_headers.find(":status");
     if (status == response_headers.end()) {
       QUIC_LOG(ERROR) << "Missing :status response header";
-    } else if (!QuicTextUtils::StringToInt(status->second,
-                                           &latest_response_code_)) {
+    } else if (!quiche::QuicheTextUtils::StringToInt(status->second,
+                                                     &latest_response_code_)) {
       QUIC_LOG(ERROR) << "Invalid :status response header: " << status->second;
     }
     latest_response_headers_ = response_headers.DebugString();
@@ -113,13 +114,13 @@
 }
 
 void QuicSpdyClientBase::SendRequest(const SpdyHeaderBlock& headers,
-                                     QuicStringPiece body,
+                                     quiche::QuicheStringPiece body,
                                      bool fin) {
   if (GetQuicFlag(FLAGS_quic_client_convert_http_header_name_to_lowercase)) {
     QUIC_CODE_COUNT(quic_client_convert_http_header_name_to_lowercase);
     SpdyHeaderBlock sanitized_headers;
     for (const auto& p : headers) {
-      sanitized_headers[QuicTextUtils::ToLower(p.first)] = p.second;
+      sanitized_headers[quiche::QuicheTextUtils::ToLower(p.first)] = p.second;
     }
 
     SendRequestInternal(std::move(sanitized_headers), body, fin);
@@ -129,7 +130,7 @@
 }
 
 void QuicSpdyClientBase::SendRequestInternal(SpdyHeaderBlock sanitized_headers,
-                                             QuicStringPiece body,
+                                             quiche::QuicheStringPiece body,
                                              bool fin) {
   QuicClientPushPromiseIndex::TryHandle* handle;
   QuicAsyncStatus rv =
@@ -153,7 +154,7 @@
 
 void QuicSpdyClientBase::SendRequestAndWaitForResponse(
     const SpdyHeaderBlock& headers,
-    QuicStringPiece body,
+    quiche::QuicheStringPiece body,
     bool fin) {
   SendRequest(headers, body, fin);
   while (WaitForEvents()) {
@@ -217,7 +218,7 @@
 }
 
 void QuicSpdyClientBase::AddPromiseDataToResend(const SpdyHeaderBlock& headers,
-                                                QuicStringPiece body,
+                                                quiche::QuicheStringPiece body,
                                                 bool fin) {
   std::unique_ptr<SpdyHeaderBlock> new_headers(
       new SpdyHeaderBlock(headers.Clone()));
diff --git a/quic/tools/quic_spdy_client_base.h b/quic/tools/quic_spdy_client_base.h
index d953038..09785f3 100644
--- a/quic/tools/quic_spdy_client_base.h
+++ b/quic/tools/quic_spdy_client_base.h
@@ -16,8 +16,8 @@
 #include "net/third_party/quiche/src/quic/core/http/quic_spdy_client_stream.h"
 #include "net/third_party/quiche/src/quic/core/quic_config.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/quic/tools/quic_client_base.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -47,7 +47,7 @@
    public:
     // |headers| may be null, since it's possible to send data without headers.
     QuicDataToResend(std::unique_ptr<spdy::SpdyHeaderBlock> headers,
-                     QuicStringPiece body,
+                     quiche::QuicheStringPiece body,
                      bool fin);
     QuicDataToResend(const QuicDataToResend&) = delete;
     QuicDataToResend& operator=(const QuicDataToResend&) = delete;
@@ -60,7 +60,7 @@
 
    protected:
     std::unique_ptr<spdy::SpdyHeaderBlock> headers_;
-    QuicStringPiece body_;
+    quiche::QuicheStringPiece body_;
     bool fin_;
   };
 
@@ -86,12 +86,12 @@
 
   // Sends an HTTP request and does not wait for response before returning.
   void SendRequest(const spdy::SpdyHeaderBlock& headers,
-                   QuicStringPiece body,
+                   quiche::QuicheStringPiece body,
                    bool fin);
 
   // Sends an HTTP request and waits for response before returning.
   void SendRequestAndWaitForResponse(const spdy::SpdyHeaderBlock& headers,
-                                     QuicStringPiece body,
+                                     quiche::QuicheStringPiece body,
                                      bool fin);
 
   // Sends a request simple GET for each URL in |url_list|, and then waits for
@@ -159,7 +159,7 @@
   void ResendSavedData() override;
 
   void AddPromiseDataToResend(const spdy::SpdyHeaderBlock& headers,
-                              QuicStringPiece body,
+                              quiche::QuicheStringPiece body,
                               bool fin);
   bool HasActiveRequests() override;
 
@@ -168,7 +168,7 @@
   class ClientQuicDataToResend : public QuicDataToResend {
    public:
     ClientQuicDataToResend(std::unique_ptr<spdy::SpdyHeaderBlock> headers,
-                           QuicStringPiece body,
+                           quiche::QuicheStringPiece body,
                            bool fin,
                            QuicSpdyClientBase* client)
         : QuicDataToResend(std::move(headers), body, fin), client_(client) {
@@ -187,7 +187,7 @@
   };
 
   void SendRequestInternal(spdy::SpdyHeaderBlock sanitized_headers,
-                           QuicStringPiece body,
+                           quiche::QuicheStringPiece body,
                            bool fin);
 
   // Index of pending promised streams. Must outlive |session_|.
diff --git a/quic/tools/quic_toy_client.cc b/quic/tools/quic_toy_client.cc
index 30018c2..e790b54 100644
--- a/quic/tools/quic_toy_client.cc
+++ b/quic/tools/quic_toy_client.cc
@@ -54,18 +54,17 @@
 #include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_default_proof_providers.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.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_system_event_loop.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
 #include "net/third_party/quiche/src/quic/tools/fake_proof_verifier.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 {
 
-using quic::QuicStringPiece;
-using quic::QuicTextUtils;
 using quic::QuicUrl;
+using quiche::QuicheStringPiece;
+using quiche::QuicheTextUtils;
 
 }  // namespace
 
@@ -253,7 +252,7 @@
   if (!GetQuicFlag(FLAGS_body_hex).empty()) {
     DCHECK(GetQuicFlag(FLAGS_body).empty())
         << "Only set one of --body and --body_hex.";
-    body = QuicTextUtils::HexDecode(GetQuicFlag(FLAGS_body_hex));
+    body = QuicheTextUtils::HexDecode(GetQuicFlag(FLAGS_body_hex));
   }
 
   // Construct a GET or POST request for supplied URL.
@@ -265,14 +264,14 @@
 
   // Append any additional headers supplied on the command line.
   const std::string headers = GetQuicFlag(FLAGS_headers);
-  for (QuicStringPiece sp : QuicTextUtils::Split(headers, ';')) {
-    QuicTextUtils::RemoveLeadingAndTrailingWhitespace(&sp);
+  for (QuicheStringPiece sp : QuicheTextUtils::Split(headers, ';')) {
+    QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(&sp);
     if (sp.empty()) {
       continue;
     }
-    std::vector<QuicStringPiece> kv = QuicTextUtils::Split(sp, ':');
-    QuicTextUtils::RemoveLeadingAndTrailingWhitespace(&kv[0]);
-    QuicTextUtils::RemoveLeadingAndTrailingWhitespace(&kv[1]);
+    std::vector<QuicheStringPiece> kv = QuicheTextUtils::Split(sp, ':');
+    QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(&kv[0]);
+    QuicheTextUtils::RemoveLeadingAndTrailingWhitespace(&kv[1]);
     header_block[kv[0]] = kv[1];
   }
 
@@ -290,8 +289,8 @@
       if (!GetQuicFlag(FLAGS_body_hex).empty()) {
         // Print the user provided hex, rather than binary body.
         std::cout << "body:\n"
-                  << QuicTextUtils::HexDump(
-                         QuicTextUtils::HexDecode(GetQuicFlag(FLAGS_body_hex)))
+                  << QuicheTextUtils::HexDump(QuicheTextUtils::HexDecode(
+                         GetQuicFlag(FLAGS_body_hex)))
                   << std::endl;
       } else {
         std::cout << "body: " << body << std::endl;
@@ -311,7 +310,7 @@
       if (!GetQuicFlag(FLAGS_body_hex).empty()) {
         // Assume response is binary data.
         std::cout << "body:\n"
-                  << QuicTextUtils::HexDump(response_body) << std::endl;
+                  << QuicheTextUtils::HexDump(response_body) << std::endl;
       } else {
         std::cout << "body: " << response_body << std::endl;
       }
diff --git a/quic/tools/quic_transport_simple_server_dispatcher.cc b/quic/tools/quic_transport_simple_server_dispatcher.cc
index 2302b67..59c14d2 100644
--- a/quic/tools/quic_transport_simple_server_dispatcher.cc
+++ b/quic/tools/quic_transport_simple_server_dispatcher.cc
@@ -11,6 +11,7 @@
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/tools/quic_transport_simple_server_session.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -35,7 +36,7 @@
 QuicSession* QuicTransportSimpleServerDispatcher::CreateQuicSession(
     QuicConnectionId server_connection_id,
     const QuicSocketAddress& peer_address,
-    QuicStringPiece /*alpn*/,
+    quiche::QuicheStringPiece /*alpn*/,
     const ParsedQuicVersion& version) {
   auto connection = std::make_unique<QuicConnection>(
       server_connection_id, peer_address, helper(), alarm_factory(), writer(),
diff --git a/quic/tools/quic_transport_simple_server_dispatcher.h b/quic/tools/quic_transport_simple_server_dispatcher.h
index f3e1b47..4c134ad 100644
--- a/quic/tools/quic_transport_simple_server_dispatcher.h
+++ b/quic/tools/quic_transport_simple_server_dispatcher.h
@@ -8,6 +8,7 @@
 #include "url/origin.h"
 #include "net/third_party/quiche/src/quic/core/quic_dispatcher.h"
 #include "net/third_party/quiche/src/quic/tools/quic_transport_simple_server_session.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -28,7 +29,7 @@
  protected:
   QuicSession* CreateQuicSession(QuicConnectionId server_connection_id,
                                  const QuicSocketAddress& peer_address,
-                                 QuicStringPiece alpn,
+                                 quiche::QuicheStringPiece alpn,
                                  const ParsedQuicVersion& version) override;
 
   std::vector<url::Origin> accepted_origins_;
diff --git a/quic/tools/quic_transport_simple_server_session.cc b/quic/tools/quic_transport_simple_server_session.cc
index b1221ae..9fe3dfd 100644
--- a/quic/tools/quic_transport_simple_server_session.cc
+++ b/quic/tools/quic_transport_simple_server_session.cc
@@ -12,8 +12,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.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/quic_transport/quic_transport_protocol.h"
 #include "net/third_party/quiche/src/quic/quic_transport/quic_transport_stream.h"
 
diff --git a/quic/tools/quic_transport_simple_server_session.h b/quic/tools/quic_transport_simple_server_session.h
index a7bc28d..a2dd6be 100644
--- a/quic/tools/quic_transport_simple_server_session.h
+++ b/quic/tools/quic_transport_simple_server_session.h
@@ -13,7 +13,6 @@
 #include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
 #include "net/third_party/quiche/src/quic/quic_transport/quic_transport_server_session.h"
 #include "net/third_party/quiche/src/quic/quic_transport/quic_transport_stream.h"
 
diff --git a/quic/tools/quic_url.cc b/quic/tools/quic_url.cc
index 4094ffe..438847c 100644
--- a/quic/tools/quic_url.cc
+++ b/quic/tools/quic_url.cc
@@ -4,22 +4,24 @@
 
 #include "net/third_party/quiche/src/quic/tools/quic_url.h"
 
-#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.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 {
 
 static constexpr size_t kMaxHostNameLength = 256;
 
-QuicUrl::QuicUrl(QuicStringPiece url) : url_(static_cast<std::string>(url)) {}
+QuicUrl::QuicUrl(quiche::QuicheStringPiece url)
+    : url_(static_cast<std::string>(url)) {}
 
-QuicUrl::QuicUrl(QuicStringPiece url, QuicStringPiece default_scheme)
+QuicUrl::QuicUrl(quiche::QuicheStringPiece url,
+                 quiche::QuicheStringPiece default_scheme)
     : QuicUrl(url) {
   if (url_.has_scheme()) {
     return;
   }
 
-  url_ = GURL(QuicStrCat(default_scheme, "://", url));
+  url_ = GURL(quiche::QuicheStrCat(default_scheme, "://", url));
 }
 
 std::string QuicUrl::ToString() const {
@@ -51,7 +53,7 @@
   if (port == url::PORT_UNSPECIFIED) {
     return host;
   }
-  return QuicStrCat(host, ":", port);
+  return quiche::QuicheStrCat(host, ":", port);
 }
 
 std::string QuicUrl::PathParamsQuery() const {
diff --git a/quic/tools/quic_url.h b/quic/tools/quic_url.h
index da1b69d..4b057db 100644
--- a/quic/tools/quic_url.h
+++ b/quic/tools/quic_url.h
@@ -9,7 +9,7 @@
 
 #include "url/gurl.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.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 {
 
@@ -24,11 +24,12 @@
   // NOTE: If |url| doesn't have a scheme, it will have an empty scheme
   // field. If that's not what you want, use the QuicUrlImpl(url,
   // default_scheme) form below.
-  explicit QuicUrl(QuicStringPiece url);
+  explicit QuicUrl(quiche::QuicheStringPiece url);
 
   // Constructs a QuicUrlImpl from |url|, assuming that the scheme for the URL
   // is |default_scheme| if there is no scheme specified in |url|.
-  QuicUrl(QuicStringPiece url, QuicStringPiece default_scheme);
+  QuicUrl(quiche::QuicheStringPiece url,
+          quiche::QuicheStringPiece default_scheme);
 
   // Returns false if the URL is not valid.
   bool IsValid() const;
diff --git a/quic/tools/quic_url_test.cc b/quic/tools/quic_url_test.cc
index 608fdb1..8ffee25 100644
--- a/quic/tools/quic_url_test.cc
+++ b/quic/tools/quic_url_test.cc
@@ -6,7 +6,6 @@
 
 #include <string>
 
-#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"
 
 namespace quic {