diff --git a/quic/platform/api/quic_cert_utils.h b/quic/platform/api/quic_cert_utils.h
index 8e21fcb..a680dd6 100644
--- a/quic/platform/api/quic_cert_utils.h
+++ b/quic/platform/api/quic_cert_utils.h
@@ -6,15 +6,16 @@
 #define QUICHE_QUIC_PLATFORM_API_QUIC_CERT_UTILS_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/quic/platform/impl/quic_cert_utils_impl.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
 class QUIC_EXPORT_PRIVATE QuicCertUtils {
  public:
-  static bool ExtractSubjectNameFromDERCert(QuicStringPiece cert,
-                                            QuicStringPiece* subject_out) {
+  static bool ExtractSubjectNameFromDERCert(
+      quiche::QuicheStringPiece cert,
+      quiche::QuicheStringPiece* subject_out) {
     return QuicCertUtilsImpl::ExtractSubjectNameFromDERCert(cert, subject_out);
   }
 };
diff --git a/quic/platform/api/quic_file_utils.cc b/quic/platform/api/quic_file_utils.cc
index 29ec416..40dea3e 100644
--- a/quic/platform/api/quic_file_utils.cc
+++ b/quic/platform/api/quic_file_utils.cc
@@ -5,6 +5,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_file_utils.h"
 
 #include "net/quic/platform/impl/quic_file_utils_impl.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -15,7 +16,8 @@
 }
 
 // Reads the contents of |filename| as a string into |contents|.
-void ReadFileContents(QuicStringPiece filename, std::string* contents) {
+void ReadFileContents(quiche::QuicheStringPiece filename,
+                      std::string* contents) {
   ReadFileContentsImpl(filename, contents);
 }
 
diff --git a/quic/platform/api/quic_file_utils.h b/quic/platform/api/quic_file_utils.h
index 7558786..8191e0a 100644
--- a/quic/platform/api/quic_file_utils.h
+++ b/quic/platform/api/quic_file_utils.h
@@ -9,7 +9,7 @@
 #include <vector>
 
 #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 {
 
@@ -18,7 +18,7 @@
     const std::string& dirname);
 
 // Reads the contents of |filename| as a string into |contents|.
-QUIC_EXPORT_PRIVATE void ReadFileContents(QuicStringPiece filename,
+QUIC_EXPORT_PRIVATE void ReadFileContents(quiche::QuicheStringPiece filename,
                                           std::string* contents);
 
 }  // namespace quic
diff --git a/quic/platform/api/quic_hostname_utils.cc b/quic/platform/api/quic_hostname_utils.cc
index b7e4642..5a0ccc0 100644
--- a/quic/platform/api/quic_hostname_utils.cc
+++ b/quic/platform/api/quic_hostname_utils.cc
@@ -3,16 +3,18 @@
 // found in the LICENSE file.
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_hostname_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
 // static
-bool QuicHostnameUtils::IsValidSNI(QuicStringPiece sni) {
+bool QuicHostnameUtils::IsValidSNI(quiche::QuicheStringPiece sni) {
   return QuicHostnameUtilsImpl::IsValidSNI(sni);
 }
 
 // static
-std::string QuicHostnameUtils::NormalizeHostname(QuicStringPiece hostname) {
+std::string QuicHostnameUtils::NormalizeHostname(
+    quiche::QuicheStringPiece hostname) {
   return QuicHostnameUtilsImpl::NormalizeHostname(hostname);
 }
 
diff --git a/quic/platform/api/quic_hostname_utils.h b/quic/platform/api/quic_hostname_utils.h
index 672847c..6a04044 100644
--- a/quic/platform/api/quic_hostname_utils.h
+++ b/quic/platform/api/quic_hostname_utils.h
@@ -8,8 +8,8 @@
 #include <string>
 
 #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/quic/platform/impl/quic_hostname_utils_impl.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -21,12 +21,12 @@
   //  (1) disallow IP addresses;
   //  (2) check that the hostname contains valid characters only; and
   //  (3) contains at least one dot.
-  static bool IsValidSNI(QuicStringPiece sni);
+  static bool IsValidSNI(quiche::QuicheStringPiece sni);
 
   // Canonicalizes the specified hostname.  This involves a wide variety of
   // transformations, including lowercasing, removing trailing dots and IDNA
   // conversion.
-  static std::string NormalizeHostname(QuicStringPiece hostname);
+  static std::string NormalizeHostname(quiche::QuicheStringPiece hostname);
 };
 
 }  // namespace quic
diff --git a/quic/platform/api/quic_mem_slice_span.h b/quic/platform/api/quic_mem_slice_span.h
index 62cec48..a1e0bd0 100644
--- a/quic/platform/api/quic_mem_slice_span.h
+++ b/quic/platform/api/quic_mem_slice_span.h
@@ -7,6 +7,7 @@
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/quic/platform/impl/quic_mem_slice_span_impl.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -37,8 +38,9 @@
     return impl_.ConsumeAll(consume);
   }
 
-  // Return data of the span at |index| by the form of a QuicStringPiece.
-  QuicStringPiece GetData(int index) { return impl_.GetData(index); }
+  // Return data of the span at |index| by the form of a
+  // quiche::QuicheStringPiece.
+  quiche::QuicheStringPiece GetData(int index) { return impl_.GetData(index); }
 
   // Return the total length of the data inside the span.
   QuicByteCount total_length() { return impl_.total_length(); }
diff --git a/quic/platform/api/quic_socket_address.cc b/quic/platform/api/quic_socket_address.cc
index c53b746..72debb9 100644
--- a/quic/platform/api/quic_socket_address.cc
+++ b/quic/platform/api/quic_socket_address.cc
@@ -10,7 +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_ip_address.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_ip_address_family.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 {
 
@@ -69,9 +69,9 @@
 std::string QuicSocketAddress::ToString() const {
   switch (host_.address_family()) {
     case IpAddressFamily::IP_V4:
-      return QuicStrCat(host_.ToString(), ":", port_);
+      return quiche::QuicheStrCat(host_.ToString(), ":", port_);
     case IpAddressFamily::IP_V6:
-      return QuicStrCat("[", host_.ToString(), "]:", port_);
+      return quiche::QuicheStrCat("[", host_.ToString(), "]:", port_);
     default:
       return "";
   }
diff --git a/quic/platform/api/quic_string_utils.h b/quic/platform/api/quic_string_utils.h
index a30833e..e069948 100644
--- a/quic/platform/api/quic_string_utils.h
+++ b/quic/platform/api/quic_string_utils.h
@@ -8,7 +8,6 @@
 #include <string>
 #include <utility>
 
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
 #include "net/quic/platform/impl/quic_string_utils_impl.h"
 
 namespace quic {
diff --git a/quic/platform/api/quic_string_utils_test.cc b/quic/platform/api/quic_string_utils_test.cc
index 39f675f..4f65b7d 100644
--- a/quic/platform/api/quic_string_utils_test.cc
+++ b/quic/platform/api/quic_string_utils_test.cc
@@ -6,69 +6,70 @@
 
 #include <cstdint>
 
-#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/common/platform/api/quiche_str_cat.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
 namespace {
 
-TEST(QuicStringUtilsTest, QuicStrCat) {
+TEST(QuicStringUtilsTest, QuicheStrCat) {
   // No arguments.
-  EXPECT_EQ("", QuicStrCat());
+  EXPECT_EQ("", quiche::QuicheStrCat());
 
   // Single string-like argument.
   const char kFoo[] = "foo";
   const std::string string_foo(kFoo);
-  const QuicStringPiece stringpiece_foo(string_foo);
-  EXPECT_EQ("foo", QuicStrCat(kFoo));
-  EXPECT_EQ("foo", QuicStrCat(string_foo));
-  EXPECT_EQ("foo", QuicStrCat(stringpiece_foo));
+  const quiche::QuicheStringPiece stringpiece_foo(string_foo);
+  EXPECT_EQ("foo", quiche::QuicheStrCat(kFoo));
+  EXPECT_EQ("foo", quiche::QuicheStrCat(string_foo));
+  EXPECT_EQ("foo", quiche::QuicheStrCat(stringpiece_foo));
 
   // Two string-like arguments.
   const char kBar[] = "bar";
-  const QuicStringPiece stringpiece_bar(kBar);
+  const quiche::QuicheStringPiece stringpiece_bar(kBar);
   const std::string string_bar(kBar);
-  EXPECT_EQ("foobar", QuicStrCat(kFoo, kBar));
-  EXPECT_EQ("foobar", QuicStrCat(kFoo, string_bar));
-  EXPECT_EQ("foobar", QuicStrCat(kFoo, stringpiece_bar));
-  EXPECT_EQ("foobar", QuicStrCat(string_foo, kBar));
-  EXPECT_EQ("foobar", QuicStrCat(string_foo, string_bar));
-  EXPECT_EQ("foobar", QuicStrCat(string_foo, stringpiece_bar));
-  EXPECT_EQ("foobar", QuicStrCat(stringpiece_foo, kBar));
-  EXPECT_EQ("foobar", QuicStrCat(stringpiece_foo, string_bar));
-  EXPECT_EQ("foobar", QuicStrCat(stringpiece_foo, stringpiece_bar));
+  EXPECT_EQ("foobar", quiche::QuicheStrCat(kFoo, kBar));
+  EXPECT_EQ("foobar", quiche::QuicheStrCat(kFoo, string_bar));
+  EXPECT_EQ("foobar", quiche::QuicheStrCat(kFoo, stringpiece_bar));
+  EXPECT_EQ("foobar", quiche::QuicheStrCat(string_foo, kBar));
+  EXPECT_EQ("foobar", quiche::QuicheStrCat(string_foo, string_bar));
+  EXPECT_EQ("foobar", quiche::QuicheStrCat(string_foo, stringpiece_bar));
+  EXPECT_EQ("foobar", quiche::QuicheStrCat(stringpiece_foo, kBar));
+  EXPECT_EQ("foobar", quiche::QuicheStrCat(stringpiece_foo, string_bar));
+  EXPECT_EQ("foobar", quiche::QuicheStrCat(stringpiece_foo, stringpiece_bar));
 
   // Many-many arguments.
-  EXPECT_EQ(
-      "foobarbazquxquuxquuzcorgegraultgarplywaldofredplughxyzzythud",
-      QuicStrCat("foo", "bar", "baz", "qux", "quux", "quuz", "corge", "grault",
-                 "garply", "waldo", "fred", "plugh", "xyzzy", "thud"));
+  EXPECT_EQ("foobarbazquxquuxquuzcorgegraultgarplywaldofredplughxyzzythud",
+            quiche::QuicheStrCat("foo", "bar", "baz", "qux", "quux", "quuz",
+                                 "corge", "grault", "garply", "waldo", "fred",
+                                 "plugh", "xyzzy", "thud"));
 
   // Numerical arguments.
   const int16_t i = 1;
   const uint64_t u = 8;
   const double d = 3.1415;
 
-  EXPECT_EQ("1 8", QuicStrCat(i, " ", u));
-  EXPECT_EQ("3.14151181", QuicStrCat(d, i, i, u, i));
+  EXPECT_EQ("1 8", quiche::QuicheStrCat(i, " ", u));
+  EXPECT_EQ("3.14151181", quiche::QuicheStrCat(d, i, i, u, i));
   EXPECT_EQ("i: 1, u: 8, d: 3.1415",
-            QuicStrCat("i: ", i, ", u: ", u, ", d: ", d));
+            quiche::QuicheStrCat("i: ", i, ", u: ", u, ", d: ", d));
 
   // Boolean arguments.
   const bool t = true;
   const bool f = false;
 
-  EXPECT_EQ("1", QuicStrCat(t));
-  EXPECT_EQ("0", QuicStrCat(f));
-  EXPECT_EQ("0110", QuicStrCat(f, t, t, f));
+  EXPECT_EQ("1", quiche::QuicheStrCat(t));
+  EXPECT_EQ("0", quiche::QuicheStrCat(f));
+  EXPECT_EQ("0110", quiche::QuicheStrCat(f, t, t, f));
 
   // Mixed string-like, numerical, and Boolean arguments.
   EXPECT_EQ("foo1foo081bar3.14151",
-            QuicStrCat(kFoo, i, string_foo, f, u, t, stringpiece_bar, d, t));
+            quiche::QuicheStrCat(kFoo, i, string_foo, f, u, t, stringpiece_bar,
+                                 d, t));
   EXPECT_EQ("3.141511bar18bar13.14150",
-            QuicStrCat(d, t, t, string_bar, i, u, kBar, t, d, f));
+            quiche::QuicheStrCat(d, t, t, string_bar, i, u, kBar, t, d, f));
 }
 
 TEST(QuicStringUtilsTest, QuicStrAppend) {
@@ -80,7 +81,7 @@
   // Single string-like argument.
   const char kFoo[] = "foo";
   const std::string string_foo(kFoo);
-  const QuicStringPiece stringpiece_foo(string_foo);
+  const quiche::QuicheStringPiece stringpiece_foo(string_foo);
   QuicStrAppend(&output, kFoo);
   EXPECT_EQ("foo", output);
   QuicStrAppend(&output, string_foo);
@@ -96,7 +97,7 @@
 
   // Two string-like arguments.
   const char kBar[] = "bar";
-  const QuicStringPiece stringpiece_bar(kBar);
+  const quiche::QuicheStringPiece stringpiece_bar(kBar);
   const std::string string_bar(kBar);
   QuicStrAppend(&output, kFoo, kBar);
   EXPECT_EQ("foobar", output);
@@ -167,10 +168,11 @@
 }
 
 TEST(QuicStringUtilsTest, QuicStringPrintf) {
-  EXPECT_EQ("", QuicStringPrintf("%s", ""));
-  EXPECT_EQ("foobar", QuicStringPrintf("%sbar", "foo"));
-  EXPECT_EQ("foobar", QuicStringPrintf("%s%s", "foo", "bar"));
-  EXPECT_EQ("foo: 1, bar: 2.0", QuicStringPrintf("foo: %d, bar: %.1f", 1, 2.0));
+  EXPECT_EQ("", quiche::QuicheStringPrintf("%s", ""));
+  EXPECT_EQ("foobar", quiche::QuicheStringPrintf("%sbar", "foo"));
+  EXPECT_EQ("foobar", quiche::QuicheStringPrintf("%s%s", "foo", "bar"));
+  EXPECT_EQ("foo: 1, bar: 2.0",
+            quiche::QuicheStringPrintf("foo: %d, bar: %.1f", 1, 2.0));
 }
 
 }  // namespace
diff --git a/quic/platform/api/quic_test_output.h b/quic/platform/api/quic_test_output.h
index f6bb443..2499876 100644
--- a/quic/platform/api/quic_test_output.h
+++ b/quic/platform/api/quic_test_output.h
@@ -5,20 +5,22 @@
 #ifndef QUICHE_QUIC_PLATFORM_API_QUIC_TEST_OUTPUT_H_
 #define QUICHE_QUIC_PLATFORM_API_QUIC_TEST_OUTPUT_H_
 
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
 #include "net/quic/platform/impl/quic_test_output_impl.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
 // Save |data| into ${QUIC_TEST_OUTPUT_DIR}/filename. If a file with the same
 // path already exists, overwrite it.
-inline void QuicSaveTestOutput(QuicStringPiece filename, QuicStringPiece data) {
+inline void QuicSaveTestOutput(quiche::QuicheStringPiece filename,
+                               quiche::QuicheStringPiece data) {
   QuicSaveTestOutputImpl(filename, data);
 }
 
 // Load the content of ${QUIC_TEST_OUTPUT_DIR}/filename into |*data|.
 // Return whether it is successfully loaded.
-inline bool QuicLoadTestOutput(QuicStringPiece filename, std::string* data) {
+inline bool QuicLoadTestOutput(quiche::QuicheStringPiece filename,
+                               std::string* data) {
   return QuicLoadTestOutputImpl(filename, data);
 }
 
@@ -29,7 +31,8 @@
 // The |identifier| is a human-readable identifier that will be combined with
 // the name of the unit test and a timestamp.  |data| is the serialized
 // quic_trace.Trace protobuf that is being recorded into the file.
-inline void QuicRecordTrace(QuicStringPiece identifier, QuicStringPiece data) {
+inline void QuicRecordTrace(quiche::QuicheStringPiece identifier,
+                            quiche::QuicheStringPiece data) {
   QuicRecordTraceImpl(identifier, data);
 }