diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 0cdb5c7..d006acd 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -31,11 +31,8 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_port_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_sleep.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_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/quic/platform/impl/quic_socket_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/bad_packet_writer.h"
 #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h"
@@ -65,6 +62,9 @@
 #include "net/third_party/quiche/src/quic/tools/quic_server.h"
 #include "net/third_party/quiche/src/quic/tools/quic_simple_client_stream.h"
 #include "net/third_party/quiche/src/quic/tools/quic_simple_server_stream.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"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 using spdy::kV3LowestPriority;
 using spdy::SpdyFramer;
@@ -115,7 +115,7 @@
 
 // Used by ::testing::PrintToStringParamName().
 std::string PrintToString(const TestParams& p) {
-  std::string rv = QuicStrCat(
+  std::string rv = quiche::QuicheStrCat(
       ParsedQuicVersionToString(p.negotiated_version), "_Server_",
       ParsedQuicVersionVectorToString(p.server_supported_versions), "_Client_",
       ParsedQuicVersionVectorToString(p.client_supported_versions), "_",
@@ -476,9 +476,9 @@
     }
   }
 
-  void AddToCache(QuicStringPiece path,
+  void AddToCache(quiche::QuicheStringPiece path,
                   int response_code,
-                  QuicStringPiece body) {
+                  quiche::QuicheStringPiece body) {
     memory_cache_backend_.AddSimpleResponse(server_hostname_, path,
                                             response_code, body);
   }
@@ -2903,7 +2903,7 @@
     SpdyHeaderBlock headers;
     headers[":status"] = "500";
     headers["content-length"] =
-        QuicTextUtils::Uint64ToString(response_body_.size());
+        quiche::QuicheTextUtils::Uint64ToString(response_body_.size());
     // This method must call CloseReadSide to cause the test case, StopReading
     // is not sufficient.
     QuicStreamPeer::CloseReadSide(this);
@@ -3122,7 +3122,8 @@
 
   SpdyHeaderBlock headers;
   headers[":status"] = "200";
-  headers["content-length"] = QuicTextUtils::Uint64ToString(kBody.size());
+  headers["content-length"] =
+      quiche::QuicheTextUtils::Uint64ToString(kBody.size());
 
   SpdyHeaderBlock trailers;
   trailers["some-trailing-header"] = "trailing-header-value";
@@ -3173,11 +3174,12 @@
       std::string body =
           use_large_response
               ? large_resource
-              : QuicStrCat("This is server push response body for ", url);
+              : quiche::QuicheStrCat("This is server push response body for ",
+                                     url);
       SpdyHeaderBlock response_headers;
       response_headers[":status"] = "200";
       response_headers["content-length"] =
-          QuicTextUtils::Uint64ToString(body.size());
+          quiche::QuicheTextUtils::Uint64ToString(body.size());
       push_resources.push_back(QuicBackendResponse::ServerPushInfo(
           resource_url, std::move(response_headers), kV3LowestPriority, body));
     }
@@ -3235,7 +3237,7 @@
   for (const std::string& url : push_urls) {
     QUIC_DVLOG(1) << "send request for pushed stream on url " << url;
     std::string expected_body =
-        QuicStrCat("This is server push response body for ", url);
+        quiche::QuicheStrCat("This is server push response body for ", url);
     std::string response_body = client_->SendSynchronousRequest(url);
     QUIC_DVLOG(1) << "response body " << response_body;
     EXPECT_EQ(expected_body, response_body);
@@ -3288,7 +3290,7 @@
     // as the responses are already in the client's cache.
     QUIC_DVLOG(1) << "send request for pushed stream on url " << url;
     std::string expected_body =
-        QuicStrCat("This is server push response body for ", url);
+        quiche::QuicheStrCat("This is server push response body for ", url);
     std::string response_body = client_->SendSynchronousRequest(url);
     QUIC_DVLOG(1) << "response body " << response_body;
     EXPECT_EQ(expected_body, response_body);
@@ -3327,7 +3329,8 @@
   const size_t kNumResources = 1 + kNumMaxStreams;  // 11.
   std::string push_urls[11];
   for (size_t i = 0; i < kNumResources; ++i) {
-    push_urls[i] = QuicStrCat("https://example.com/push_resources", i);
+    push_urls[i] =
+        quiche::QuicheStrCat("https://example.com/push_resources", i);
   }
   AddRequestAndResponseWithServerPush("example.com", "/push_example", kBody,
                                       push_urls, kNumResources, 0);
@@ -3344,8 +3347,9 @@
   for (const std::string& url : push_urls) {
     // Sending subsequent requesets will not actually send anything on the wire,
     // as the responses are already in the client's cache.
-    EXPECT_EQ(QuicStrCat("This is server push response body for ", url),
-              client_->SendSynchronousRequest(url));
+    EXPECT_EQ(
+        quiche::QuicheStrCat("This is server push response body for ", url),
+        client_->SendSynchronousRequest(url));
   }
 
   // Only 1 request should have been sent.
@@ -3385,7 +3389,7 @@
   const size_t kNumResources = kNumMaxStreams + 1;
   std::string push_urls[11];
   for (size_t i = 0; i < kNumResources; ++i) {
-    push_urls[i] = QuicStrCat("http://example.com/push_resources", i);
+    push_urls[i] = quiche::QuicheStrCat("http://example.com/push_resources", i);
   }
   AddRequestAndResponseWithServerPush("example.com", "/push_example", kBody,
                                       push_urls, kNumResources, kBodySize);
@@ -3462,7 +3466,7 @@
   headers[":scheme"] = "https";
   headers[":authority"] = server_hostname_;
   headers["content-length"] =
-      QuicTextUtils::Uint64ToString(request_body_size_bytes);
+      quiche::QuicheTextUtils::Uint64ToString(request_body_size_bytes);
 
   client_->SendMessage(headers, "", /*fin=*/false);
 
@@ -3794,9 +3798,9 @@
   // (and the FIN) after the response body.
   std::string response_body(1305, 'a');
   SpdyHeaderBlock response_headers;
-  response_headers[":status"] = QuicTextUtils::Uint64ToString(200);
+  response_headers[":status"] = quiche::QuicheTextUtils::Uint64ToString(200);
   response_headers["content-length"] =
-      QuicTextUtils::Uint64ToString(response_body.length());
+      quiche::QuicheTextUtils::Uint64ToString(response_body.length());
   memory_cache_backend_.AddSpecialResponse(
       server_hostname_, "/test_url", std::move(response_headers), response_body,
       QuicBackendResponse::INCOMPLETE_RESPONSE);
@@ -3853,22 +3857,22 @@
   ASSERT_LT(0, client_session->GetCurrentLargestMessagePayload());
 
   std::string message_string(kMaxOutgoingPacketSize, 'a');
-  QuicStringPiece message_buffer(message_string);
+  quiche::QuicheStringPiece message_buffer(message_string);
   QuicRandom* random =
       QuicConnectionPeer::GetHelper(client_connection)->GetRandomGenerator();
   QuicMemSliceStorage storage(nullptr, 0, nullptr, 0);
   {
     QuicConnection::ScopedPacketFlusher flusher(client_session->connection());
     // Verify the largest message gets successfully sent.
-    EXPECT_EQ(
-        MessageResult(MESSAGE_STATUS_SUCCESS, 1),
-        client_session->SendMessage(MakeSpan(
-            client_session->connection()
-                ->helper()
-                ->GetStreamSendBufferAllocator(),
-            QuicStringPiece(message_buffer.data(),
-                            client_session->GetCurrentLargestMessagePayload()),
-            &storage)));
+    EXPECT_EQ(MessageResult(MESSAGE_STATUS_SUCCESS, 1),
+              client_session->SendMessage(MakeSpan(
+                  client_session->connection()
+                      ->helper()
+                      ->GetStreamSendBufferAllocator(),
+                  quiche::QuicheStringPiece(
+                      message_buffer.data(),
+                      client_session->GetCurrentLargestMessagePayload()),
+                  &storage)));
     // Send more messages with size (0, largest_payload] until connection is
     // write blocked.
     const int kTestMaxNumberOfMessages = 100;
@@ -3881,7 +3885,8 @@
           client_session->connection()
               ->helper()
               ->GetStreamSendBufferAllocator(),
-          QuicStringPiece(message_buffer.data(), message_length), &storage));
+          quiche::QuicheStringPiece(message_buffer.data(), message_length),
+          &storage));
       if (result.status == MESSAGE_STATUS_BLOCKED) {
         // Connection is write blocked.
         break;
@@ -3897,7 +3902,7 @@
                     client_session->connection()
                         ->helper()
                         ->GetStreamSendBufferAllocator(),
-                    QuicStringPiece(
+                    quiche::QuicheStringPiece(
                         message_buffer.data(),
                         client_session->GetCurrentLargestMessagePayload() + 1),
                     &storage))
@@ -4026,9 +4031,9 @@
   // frame for the stream.
   std::string response_body(1305, 'a');
   SpdyHeaderBlock response_headers;
-  response_headers[":status"] = QuicTextUtils::Uint64ToString(200);
+  response_headers[":status"] = quiche::QuicheTextUtils::Uint64ToString(200);
   response_headers["content-length"] =
-      QuicTextUtils::Uint64ToString(response_body.length());
+      quiche::QuicheTextUtils::Uint64ToString(response_body.length());
   memory_cache_backend_.AddStopSendingResponse(
       server_hostname_, "/test_url", std::move(response_headers), response_body,
       kStopSendingTestCode);
diff --git a/quic/core/http/http_decoder.cc b/quic/core/http/http_decoder.cc
index 41632a9..51c70e0 100644
--- a/quic/core/http/http_decoder.cc
+++ b/quic/core/http/http_decoder.cc
@@ -11,6 +11,7 @@
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_fallthrough.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -190,7 +191,7 @@
     case static_cast<uint64_t>(HttpFrameType::DATA): {
       QuicByteCount bytes_to_read = std::min<QuicByteCount>(
           remaining_frame_length_, reader->BytesRemaining());
-      QuicStringPiece payload;
+      quiche::QuicheStringPiece payload;
       bool success = reader->ReadStringPiece(&payload, bytes_to_read);
       DCHECK(success);
       DCHECK(!payload.empty());
@@ -201,7 +202,7 @@
     case static_cast<uint64_t>(HttpFrameType::HEADERS): {
       QuicByteCount bytes_to_read = std::min<QuicByteCount>(
           remaining_frame_length_, reader->BytesRemaining());
-      QuicStringPiece payload;
+      quiche::QuicheStringPiece payload;
       bool success = reader->ReadStringPiece(&payload, bytes_to_read);
       DCHECK(success);
       DCHECK(!payload.empty());
@@ -277,7 +278,7 @@
       if (bytes_to_read == 0) {
         break;
       }
-      QuicStringPiece payload;
+      quiche::QuicheStringPiece payload;
       bool success = reader->ReadStringPiece(&payload, bytes_to_read);
       DCHECK(success);
       DCHECK(!payload.empty());
@@ -300,7 +301,7 @@
     default: {
       QuicByteCount bytes_to_read = std::min<QuicByteCount>(
           remaining_frame_length_, reader->BytesRemaining());
-      QuicStringPiece payload;
+      quiche::QuicheStringPiece payload;
       bool success = reader->ReadStringPiece(&payload, bytes_to_read);
       DCHECK(success);
       DCHECK(!payload.empty());
@@ -440,7 +441,7 @@
 void HttpDecoder::DiscardFramePayload(QuicDataReader* reader) {
   QuicByteCount bytes_to_read = std::min<QuicByteCount>(
       remaining_frame_length_, reader->BytesRemaining());
-  QuicStringPiece payload;
+  quiche::QuicheStringPiece payload;
   bool success = reader->ReadStringPiece(&payload, bytes_to_read);
   DCHECK(success);
   remaining_frame_length_ -= payload.length();
diff --git a/quic/core/http/http_decoder.h b/quic/core/http/http_decoder.h
index 862c5de..1dc2225 100644
--- a/quic/core/http/http_decoder.h
+++ b/quic/core/http/http_decoder.h
@@ -11,7 +11,7 @@
 #include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.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 {
 
@@ -70,7 +70,7 @@
     // Called when part of the payload of a DATA frame has been read.  May be
     // called multiple times for a single frame.  |payload| is guaranteed to be
     // non-empty.
-    virtual bool OnDataFramePayload(QuicStringPiece payload) = 0;
+    virtual bool OnDataFramePayload(quiche::QuicheStringPiece payload) = 0;
     // Called when a DATA frame has been completely processed.
     virtual bool OnDataFrameEnd() = 0;
 
@@ -80,7 +80,7 @@
     // Called when part of the payload of a HEADERS frame has been read.  May be
     // called multiple times for a single frame.  |payload| is guaranteed to be
     // non-empty.
-    virtual bool OnHeadersFramePayload(QuicStringPiece payload) = 0;
+    virtual bool OnHeadersFramePayload(quiche::QuicheStringPiece payload) = 0;
     // Called when a HEADERS frame has been completely processed.
     // |frame_len| is the length of the HEADERS frame payload.
     virtual bool OnHeadersFrameEnd() = 0;
@@ -94,7 +94,8 @@
     // Called when part of the header block of a PUSH_PROMISE frame has been
     // read. May be called multiple times for a single frame.  |payload| is
     // guaranteed to be non-empty.
-    virtual bool OnPushPromiseFramePayload(QuicStringPiece payload) = 0;
+    virtual bool OnPushPromiseFramePayload(
+        quiche::QuicheStringPiece payload) = 0;
     // Called when a PUSH_PROMISE frame has been completely processed.
     virtual bool OnPushPromiseFrameEnd() = 0;
 
@@ -106,7 +107,7 @@
     // Called when part of the payload of the unknown frame has been read.  May
     // be called multiple times for a single frame.  |payload| is guaranteed to
     // be non-empty.
-    virtual bool OnUnknownFramePayload(QuicStringPiece payload) = 0;
+    virtual bool OnUnknownFramePayload(quiche::QuicheStringPiece payload) = 0;
     // Called when the unknown frame has been completely processed.
     virtual bool OnUnknownFrameEnd() = 0;
   };
diff --git a/quic/core/http/http_decoder_test.cc b/quic/core/http/http_decoder_test.cc
index 751ca58..6796d25 100644
--- a/quic/core/http/http_decoder_test.cc
+++ b/quic/core/http/http_decoder_test.cc
@@ -12,10 +12,11 @@
 #include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
 #include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.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/test_tools/quic_test_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"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 using ::testing::_;
 using ::testing::Eq;
@@ -50,21 +51,22 @@
   MOCK_METHOD1(OnDuplicatePushFrame, bool(const DuplicatePushFrame& frame));
 
   MOCK_METHOD1(OnDataFrameStart, bool(QuicByteCount header_length));
-  MOCK_METHOD1(OnDataFramePayload, bool(QuicStringPiece payload));
+  MOCK_METHOD1(OnDataFramePayload, bool(quiche::QuicheStringPiece payload));
   MOCK_METHOD0(OnDataFrameEnd, bool());
 
   MOCK_METHOD1(OnHeadersFrameStart, bool(QuicByteCount header_length));
-  MOCK_METHOD1(OnHeadersFramePayload, bool(QuicStringPiece payload));
+  MOCK_METHOD1(OnHeadersFramePayload, bool(quiche::QuicheStringPiece payload));
   MOCK_METHOD0(OnHeadersFrameEnd, bool());
 
   MOCK_METHOD1(OnPushPromiseFrameStart, bool(QuicByteCount header_length));
   MOCK_METHOD2(OnPushPromiseFramePushId,
                bool(PushId push_id, QuicByteCount push_id_length));
-  MOCK_METHOD1(OnPushPromiseFramePayload, bool(QuicStringPiece payload));
+  MOCK_METHOD1(OnPushPromiseFramePayload,
+               bool(quiche::QuicheStringPiece payload));
   MOCK_METHOD0(OnPushPromiseFrameEnd, bool());
 
   MOCK_METHOD2(OnUnknownFrameStart, bool(uint64_t, QuicByteCount));
-  MOCK_METHOD1(OnUnknownFramePayload, bool(QuicStringPiece));
+  MOCK_METHOD1(OnUnknownFramePayload, bool(quiche::QuicheStringPiece));
   MOCK_METHOD0(OnUnknownFrameEnd, bool());
 };
 
@@ -101,13 +103,13 @@
   }
 
   // Process |input| in a single call to HttpDecoder::ProcessInput().
-  QuicByteCount ProcessInput(QuicStringPiece input) {
+  QuicByteCount ProcessInput(quiche::QuicheStringPiece input) {
     return decoder_.ProcessInput(input.data(), input.size());
   }
 
   // Feed |input| to |decoder_| one character at a time,
   // verifying that each character gets processed.
-  void ProcessInputCharByChar(QuicStringPiece input) {
+  void ProcessInputCharByChar(quiche::QuicheStringPiece input) {
     for (char c : input) {
       EXPECT_EQ(1u, decoder_.ProcessInput(&c, 1));
     }
@@ -115,8 +117,10 @@
 
   // Append garbage to |input|, then process it in a single call to
   // HttpDecoder::ProcessInput().  Verify that garbage is not read.
-  QuicByteCount ProcessInputWithGarbageAppended(QuicStringPiece input) {
-    std::string input_with_garbage_appended = QuicStrCat(input, "blahblah");
+  QuicByteCount ProcessInputWithGarbageAppended(
+      quiche::QuicheStringPiece input) {
+    std::string input_with_garbage_appended =
+        quiche::QuicheStrCat(input, "blahblah");
     QuicByteCount processed_bytes = ProcessInput(input_with_garbage_appended);
 
     // Guaranteed by HttpDecoder::ProcessInput() contract.
@@ -181,7 +185,7 @@
 
 TEST_F(HttpDecoderTest, CancelPush) {
   InSequence s;
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "03"    // type (CANCEL_PUSH)
       "01"    // length
       "01");  // Push Id
@@ -208,17 +212,17 @@
 
 TEST_F(HttpDecoderTest, PushPromiseFrame) {
   InSequence s;
-  std::string input =
-      QuicStrCat(QuicTextUtils::HexDecode("05"  // type (PUSH PROMISE)
-                                          "0f"  // length
-                                          "C000000000000101"),  // push id 257
-                 "Headers");                                    // headers
+  std::string input = quiche::QuicheStrCat(
+      quiche::QuicheTextUtils::HexDecode("05"  // type (PUSH PROMISE)
+                                         "0f"  // length
+                                         "C000000000000101"),  // push id 257
+      "Headers");                                              // headers
 
   // Visitor pauses processing.
   EXPECT_CALL(visitor_, OnPushPromiseFrameStart(2)).WillOnce(Return(false));
   EXPECT_CALL(visitor_, OnPushPromiseFramePushId(257, 8))
       .WillOnce(Return(false));
-  QuicStringPiece remaining_input(input);
+  quiche::QuicheStringPiece remaining_input(input);
   QuicByteCount processed_bytes =
       ProcessInputWithGarbageAppended(remaining_input);
   EXPECT_EQ(2u, processed_bytes);
@@ -227,7 +231,8 @@
   EXPECT_EQ(8u, processed_bytes);
   remaining_input = remaining_input.substr(processed_bytes);
 
-  EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("Headers")))
+  EXPECT_CALL(visitor_,
+              OnPushPromiseFramePayload(quiche::QuicheStringPiece("Headers")))
       .WillOnce(Return(false));
   processed_bytes = ProcessInputWithGarbageAppended(remaining_input);
   EXPECT_EQ(remaining_input.size(), processed_bytes);
@@ -240,7 +245,8 @@
   // Process the full frame.
   EXPECT_CALL(visitor_, OnPushPromiseFrameStart(2));
   EXPECT_CALL(visitor_, OnPushPromiseFramePushId(257, 8));
-  EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("Headers")));
+  EXPECT_CALL(visitor_,
+              OnPushPromiseFramePayload(quiche::QuicheStringPiece("Headers")));
   EXPECT_CALL(visitor_, OnPushPromiseFrameEnd());
   EXPECT_EQ(input.size(), ProcessInput(input));
   EXPECT_THAT(decoder_.error(), IsQuicNoError());
@@ -249,13 +255,20 @@
   // Process the frame incrementally.
   EXPECT_CALL(visitor_, OnPushPromiseFrameStart(2));
   EXPECT_CALL(visitor_, OnPushPromiseFramePushId(257, 8));
-  EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("H")));
-  EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("e")));
-  EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("a")));
-  EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("d")));
-  EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("e")));
-  EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("r")));
-  EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("s")));
+  EXPECT_CALL(visitor_,
+              OnPushPromiseFramePayload(quiche::QuicheStringPiece("H")));
+  EXPECT_CALL(visitor_,
+              OnPushPromiseFramePayload(quiche::QuicheStringPiece("e")));
+  EXPECT_CALL(visitor_,
+              OnPushPromiseFramePayload(quiche::QuicheStringPiece("a")));
+  EXPECT_CALL(visitor_,
+              OnPushPromiseFramePayload(quiche::QuicheStringPiece("d")));
+  EXPECT_CALL(visitor_,
+              OnPushPromiseFramePayload(quiche::QuicheStringPiece("e")));
+  EXPECT_CALL(visitor_,
+              OnPushPromiseFramePayload(quiche::QuicheStringPiece("r")));
+  EXPECT_CALL(visitor_,
+              OnPushPromiseFramePayload(quiche::QuicheStringPiece("s")));
   EXPECT_CALL(visitor_, OnPushPromiseFrameEnd());
   ProcessInputCharByChar(input);
   EXPECT_THAT(decoder_.error(), IsQuicNoError());
@@ -264,7 +277,8 @@
   // Process push id incrementally and append headers with last byte of push id.
   EXPECT_CALL(visitor_, OnPushPromiseFrameStart(2));
   EXPECT_CALL(visitor_, OnPushPromiseFramePushId(257, 8));
-  EXPECT_CALL(visitor_, OnPushPromiseFramePayload(QuicStringPiece("Headers")));
+  EXPECT_CALL(visitor_,
+              OnPushPromiseFramePayload(quiche::QuicheStringPiece("Headers")));
   EXPECT_CALL(visitor_, OnPushPromiseFrameEnd());
   ProcessInputCharByChar(input.substr(0, 9));
   EXPECT_EQ(8u, ProcessInput(input.substr(9)));
@@ -275,7 +289,7 @@
 TEST_F(HttpDecoderTest, CorruptPushPromiseFrame) {
   InSequence s;
 
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "05"    // type (PUSH_PROMISE)
       "01"    // length
       "40");  // first byte of two-byte varint push id
@@ -306,7 +320,7 @@
 
 TEST_F(HttpDecoderTest, MaxPushId) {
   InSequence s;
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "0D"    // type (MAX_PUSH_ID)
       "01"    // length
       "01");  // Push Id
@@ -333,7 +347,7 @@
 
 TEST_F(HttpDecoderTest, DuplicatePush) {
   InSequence s;
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "0E"    // type (DUPLICATE_PUSH)
       "01"    // length
       "01");  // Push Id
@@ -360,7 +374,7 @@
 
 TEST_F(HttpDecoderTest, PriorityFrame) {
   InSequence s;
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "02"    // type (PRIORITY)
       "04"    // length
       "08"    // request stream, request stream, exclusive
@@ -378,7 +392,7 @@
 
   // Visitor pauses processing.
   EXPECT_CALL(visitor_, OnPriorityFrameStart(2)).WillOnce(Return(false));
-  QuicStringPiece remaining_input(input);
+  quiche::QuicheStringPiece remaining_input(input);
   QuicByteCount processed_bytes =
       ProcessInputWithGarbageAppended(remaining_input);
   EXPECT_EQ(2u, processed_bytes);
@@ -404,7 +418,7 @@
   EXPECT_THAT(decoder_.error(), IsQuicNoError());
   EXPECT_EQ("", decoder_.error_detail());
 
-  std::string input2 = QuicTextUtils::HexDecode(
+  std::string input2 = quiche::QuicheTextUtils::HexDecode(
       "02"    // type (PRIORITY)
       "02"    // length
       "f8"    // root of tree, root of tree, exclusive
@@ -470,7 +484,7 @@
 
 TEST_F(HttpDecoderTest, SettingsFrame) {
   InSequence s;
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "04"    // type (SETTINGS)
       "07"    // length
       "01"    // identifier (SETTINGS_QPACK_MAX_TABLE_CAPACITY)
@@ -486,7 +500,7 @@
   frame.values[256] = 4;
 
   // Visitor pauses processing.
-  QuicStringPiece remaining_input(input);
+  quiche::QuicheStringPiece remaining_input(input);
   EXPECT_CALL(visitor_, OnSettingsFrameStart(2)).WillOnce(Return(false));
   QuicByteCount processed_bytes =
       ProcessInputWithGarbageAppended(remaining_input);
@@ -550,7 +564,7 @@
 }
 
 TEST_F(HttpDecoderTest, DuplicateSettingsIdentifier) {
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "04"    // type (SETTINGS)
       "04"    // length
       "01"    // identifier
@@ -569,19 +583,20 @@
 
 TEST_F(HttpDecoderTest, DataFrame) {
   InSequence s;
-  std::string input = QuicStrCat(QuicTextUtils::HexDecode("00"    // type (DATA)
-                                                          "05"),  // length
-                                 "Data!");                        // data
+  std::string input = quiche::QuicheStrCat(
+      quiche::QuicheTextUtils::HexDecode("00"    // type (DATA)
+                                         "05"),  // length
+      "Data!");                                  // data
 
   // Visitor pauses processing.
   EXPECT_CALL(visitor_, OnDataFrameStart(2)).WillOnce(Return(false));
-  QuicStringPiece remaining_input(input);
+  quiche::QuicheStringPiece remaining_input(input);
   QuicByteCount processed_bytes =
       ProcessInputWithGarbageAppended(remaining_input);
   EXPECT_EQ(2u, processed_bytes);
   remaining_input = remaining_input.substr(processed_bytes);
 
-  EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("Data!")))
+  EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece("Data!")))
       .WillOnce(Return(false));
   processed_bytes = ProcessInputWithGarbageAppended(remaining_input);
   EXPECT_EQ(remaining_input.size(), processed_bytes);
@@ -593,7 +608,7 @@
 
   // Process the full frame.
   EXPECT_CALL(visitor_, OnDataFrameStart(2));
-  EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("Data!")));
+  EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece("Data!")));
   EXPECT_CALL(visitor_, OnDataFrameEnd());
   EXPECT_EQ(input.size(), ProcessInput(input));
   EXPECT_THAT(decoder_.error(), IsQuicNoError());
@@ -601,11 +616,11 @@
 
   // Process the frame incrementally.
   EXPECT_CALL(visitor_, OnDataFrameStart(2));
-  EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("D")));
-  EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("a")));
-  EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("t")));
-  EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("a")));
-  EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("!")));
+  EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece("D")));
+  EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece("a")));
+  EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece("t")));
+  EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece("a")));
+  EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece("!")));
   EXPECT_CALL(visitor_, OnDataFrameEnd());
   ProcessInputCharByChar(input);
   EXPECT_THAT(decoder_.error(), IsQuicNoError());
@@ -633,7 +648,7 @@
   EXPECT_EQ("", decoder_.error_detail());
 
   // Send data.
-  EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece(input)));
+  EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece(input)));
   EXPECT_CALL(visitor_, OnDataFrameEnd());
   EXPECT_EQ(2048u, decoder_.ProcessInput(input.data(), 2048));
   EXPECT_THAT(decoder_.error(), IsQuicNoError());
@@ -669,7 +684,7 @@
 
 TEST_F(HttpDecoderTest, GoAway) {
   InSequence s;
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "07"    // type (GOAWAY)
       "01"    // length
       "01");  // StreamId
@@ -696,20 +711,21 @@
 
 TEST_F(HttpDecoderTest, HeadersFrame) {
   InSequence s;
-  std::string input =
-      QuicStrCat(QuicTextUtils::HexDecode("01"    // type (HEADERS)
-                                          "07"),  // length
-                 "Headers");                      // headers
+  std::string input = quiche::QuicheStrCat(
+      quiche::QuicheTextUtils::HexDecode("01"    // type (HEADERS)
+                                         "07"),  // length
+      "Headers");                                // headers
 
   // Visitor pauses processing.
   EXPECT_CALL(visitor_, OnHeadersFrameStart(2)).WillOnce(Return(false));
-  QuicStringPiece remaining_input(input);
+  quiche::QuicheStringPiece remaining_input(input);
   QuicByteCount processed_bytes =
       ProcessInputWithGarbageAppended(remaining_input);
   EXPECT_EQ(2u, processed_bytes);
   remaining_input = remaining_input.substr(processed_bytes);
 
-  EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("Headers")))
+  EXPECT_CALL(visitor_,
+              OnHeadersFramePayload(quiche::QuicheStringPiece("Headers")))
       .WillOnce(Return(false));
   processed_bytes = ProcessInputWithGarbageAppended(remaining_input);
   EXPECT_EQ(remaining_input.size(), processed_bytes);
@@ -721,7 +737,8 @@
 
   // Process the full frame.
   EXPECT_CALL(visitor_, OnHeadersFrameStart(2));
-  EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("Headers")));
+  EXPECT_CALL(visitor_,
+              OnHeadersFramePayload(quiche::QuicheStringPiece("Headers")));
   EXPECT_CALL(visitor_, OnHeadersFrameEnd());
   EXPECT_EQ(input.size(), ProcessInput(input));
   EXPECT_THAT(decoder_.error(), IsQuicNoError());
@@ -729,13 +746,13 @@
 
   // Process the frame incrementally.
   EXPECT_CALL(visitor_, OnHeadersFrameStart(2));
-  EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("H")));
-  EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("e")));
-  EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("a")));
-  EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("d")));
-  EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("e")));
-  EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("r")));
-  EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("s")));
+  EXPECT_CALL(visitor_, OnHeadersFramePayload(quiche::QuicheStringPiece("H")));
+  EXPECT_CALL(visitor_, OnHeadersFramePayload(quiche::QuicheStringPiece("e")));
+  EXPECT_CALL(visitor_, OnHeadersFramePayload(quiche::QuicheStringPiece("a")));
+  EXPECT_CALL(visitor_, OnHeadersFramePayload(quiche::QuicheStringPiece("d")));
+  EXPECT_CALL(visitor_, OnHeadersFramePayload(quiche::QuicheStringPiece("e")));
+  EXPECT_CALL(visitor_, OnHeadersFramePayload(quiche::QuicheStringPiece("r")));
+  EXPECT_CALL(visitor_, OnHeadersFramePayload(quiche::QuicheStringPiece("s")));
   EXPECT_CALL(visitor_, OnHeadersFrameEnd());
   ProcessInputCharByChar(input);
   EXPECT_THAT(decoder_.error(), IsQuicNoError());
@@ -744,7 +761,7 @@
 
 TEST_F(HttpDecoderTest, EmptyDataFrame) {
   InSequence s;
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "00"    // type (DATA)
       "00");  // length
 
@@ -774,7 +791,7 @@
 
 TEST_F(HttpDecoderTest, EmptyHeadersFrame) {
   InSequence s;
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "01"    // type (HEADERS)
       "00");  // length
 
@@ -804,7 +821,7 @@
 
 TEST_F(HttpDecoderTest, PushPromiseFrameNoHeaders) {
   InSequence s;
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "05"    // type (PUSH_PROMISE)
       "01"    // length
       "01");  // Push Id
@@ -837,7 +854,7 @@
 }
 
 TEST_F(HttpDecoderTest, MalformedFrameWithOverlyLargePayload) {
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "03"    // type (CANCEL_PUSH)
       "10"    // length
       "15");  // malformed payload
@@ -865,19 +882,20 @@
 
 TEST_F(HttpDecoderTest, HeadersPausedThenData) {
   InSequence s;
-  std::string input =
-      QuicStrCat(QuicTextUtils::HexDecode("01"    // type (HEADERS)
-                                          "07"),  // length
-                 "Headers",                       // headers
-                 QuicTextUtils::HexDecode("00"    // type (DATA)
-                                          "05"),  // length
-                 "Data!");                        // data
+  std::string input = quiche::QuicheStrCat(
+      quiche::QuicheTextUtils::HexDecode("01"    // type (HEADERS)
+                                         "07"),  // length
+      "Headers",                                 // headers
+      quiche::QuicheTextUtils::HexDecode("00"    // type (DATA)
+                                         "05"),  // length
+      "Data!");                                  // data
 
   // Visitor pauses processing, maybe because header decompression is blocked.
   EXPECT_CALL(visitor_, OnHeadersFrameStart(2));
-  EXPECT_CALL(visitor_, OnHeadersFramePayload(QuicStringPiece("Headers")));
+  EXPECT_CALL(visitor_,
+              OnHeadersFramePayload(quiche::QuicheStringPiece("Headers")));
   EXPECT_CALL(visitor_, OnHeadersFrameEnd()).WillOnce(Return(false));
-  QuicStringPiece remaining_input(input);
+  quiche::QuicheStringPiece remaining_input(input);
   QuicByteCount processed_bytes =
       ProcessInputWithGarbageAppended(remaining_input);
   EXPECT_EQ(9u, processed_bytes);
@@ -885,7 +903,7 @@
 
   // Process DATA frame.
   EXPECT_CALL(visitor_, OnDataFrameStart(2));
-  EXPECT_CALL(visitor_, OnDataFramePayload(QuicStringPiece("Data!")));
+  EXPECT_CALL(visitor_, OnDataFramePayload(quiche::QuicheStringPiece("Data!")));
   EXPECT_CALL(visitor_, OnDataFrameEnd());
 
   processed_bytes = ProcessInput(remaining_input);
@@ -943,7 +961,7 @@
       HttpDecoder decoder(&visitor_);
       EXPECT_CALL(visitor_, OnError(&decoder));
 
-      QuicStringPiece input(test_data.input);
+      quiche::QuicheStringPiece input(test_data.input);
       decoder.ProcessInput(input.data(), input.size());
       EXPECT_THAT(decoder.error(), IsError(QUIC_INVALID_FRAME_DATA));
       EXPECT_EQ(test_data.error_message, decoder.error_detail());
@@ -952,7 +970,7 @@
       HttpDecoder decoder(&visitor_);
       EXPECT_CALL(visitor_, OnError(&decoder));
 
-      QuicStringPiece input(test_data.input);
+      quiche::QuicheStringPiece input(test_data.input);
       for (auto c : input) {
         decoder.ProcessInput(&c, 1);
       }
@@ -963,7 +981,7 @@
 }
 
 TEST_F(HttpDecoderTest, EmptyCancelPushFrame) {
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "03"    // type (CANCEL_PUSH)
       "00");  // frame length
 
@@ -974,7 +992,7 @@
 }
 
 TEST_F(HttpDecoderTest, EmptySettingsFrame) {
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "04"    // type (SETTINGS)
       "00");  // frame length
 
@@ -990,7 +1008,7 @@
 
 // Regression test for https://crbug.com/1001823.
 TEST_F(HttpDecoderTest, EmptyPushPromiseFrame) {
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "05"    // type (PUSH_PROMISE)
       "00");  // frame length
 
@@ -1001,7 +1019,7 @@
 }
 
 TEST_F(HttpDecoderTest, EmptyGoAwayFrame) {
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "07"    // type (GOAWAY)
       "00");  // frame length
 
@@ -1012,7 +1030,7 @@
 }
 
 TEST_F(HttpDecoderTest, EmptyMaxPushIdFrame) {
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "0d"    // type (MAX_PUSH_ID)
       "00");  // frame length
 
@@ -1023,7 +1041,7 @@
 }
 
 TEST_F(HttpDecoderTest, EmptyDuplicatePushFrame) {
-  std::string input = QuicTextUtils::HexDecode(
+  std::string input = quiche::QuicheTextUtils::HexDecode(
       "0e"    // type (DUPLICATE_PUSH)
       "00");  // frame length
 
diff --git a/quic/core/http/http_frames.h b/quic/core/http/http_frames.h
index 215fa56..de0abc4 100644
--- a/quic/core/http/http_frames.h
+++ b/quic/core/http/http_frames.h
@@ -11,9 +11,9 @@
 
 #include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.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_string_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"
 #include "net/third_party/quiche/src/spdy/core/spdy_framer.h"
 
 namespace quic {
@@ -35,7 +35,7 @@
 //   DATA frames (type=0x0) convey arbitrary, variable-length sequences of
 //   octets associated with an HTTP request or response payload.
 struct QUIC_EXPORT_PRIVATE DataFrame {
-  QuicStringPiece data;
+  quiche::QuicheStringPiece data;
 };
 
 // 4.2.2.  HEADERS
@@ -43,7 +43,7 @@
 //   The HEADERS frame (type=0x1) is used to carry a header block,
 //   compressed using QPACK.
 struct QUIC_EXPORT_PRIVATE HeadersFrame {
-  QuicStringPiece headers;
+  quiche::QuicheStringPiece headers;
 };
 
 // 4.2.3.  PRIORITY
@@ -82,12 +82,12 @@
            weight == rhs.weight;
   }
   std::string ToString() const {
-    return QuicStrCat("Priority Frame : {prioritized_type: ", prioritized_type,
-                      ", dependency_type: ", dependency_type,
-                      ", exclusive: ", exclusive,
-                      ", prioritized_element_id: ", prioritized_element_id,
-                      ", element_dependency_id: ", element_dependency_id,
-                      ", weight: ", weight, "}");
+    return quiche::QuicheStrCat(
+        "Priority Frame : {prioritized_type: ", prioritized_type,
+        ", dependency_type: ", dependency_type, ", exclusive: ", exclusive,
+        ", prioritized_element_id: ", prioritized_element_id,
+        ", element_dependency_id: ", element_dependency_id,
+        ", weight: ", weight, "}");
   }
 
   friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
@@ -129,7 +129,7 @@
   std::string ToString() const {
     std::string s;
     for (auto it : values) {
-      std::string setting = QuicStrCat(
+      std::string setting = quiche::QuicheStrCat(
           SpdyUtils::H3SettingsToString(
               static_cast<Http3AndQpackSettingsIdentifiers>(it.first)),
           " = ", it.second, "; ");
@@ -150,7 +150,7 @@
 //   set from server to client, as in HTTP/2.
 struct QUIC_EXPORT_PRIVATE PushPromiseFrame {
   PushId push_id;
-  QuicStringPiece headers;
+  quiche::QuicheStringPiece headers;
 
   bool operator==(const PushPromiseFrame& rhs) const {
     return push_id == rhs.push_id && headers == rhs.headers;
diff --git a/quic/core/http/quic_header_list.cc b/quic/core/http/quic_header_list.cc
index cba3e58..cbf60ce 100644
--- a/quic/core/http/quic_header_list.cc
+++ b/quic/core/http/quic_header_list.cc
@@ -9,6 +9,7 @@
 
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.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 {
@@ -35,7 +36,8 @@
       << "OnHeaderBlockStart called more than once!";
 }
 
-void QuicHeaderList::OnHeader(QuicStringPiece name, QuicStringPiece value) {
+void QuicHeaderList::OnHeader(quiche::QuicheStringPiece name,
+                              quiche::QuicheStringPiece value) {
   // Avoid infinite buffering of headers. No longer store headers
   // once the current headers are over the limit.
   if (current_header_list_size_ < max_header_list_size_) {
diff --git a/quic/core/http/quic_header_list.h b/quic/core/http/quic_header_list.h
index cc6e7bc..c019ceb 100644
--- a/quic/core/http/quic_header_list.h
+++ b/quic/core/http/quic_header_list.h
@@ -13,7 +13,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_containers.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"
 #include "net/third_party/quiche/src/spdy/core/spdy_header_block.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_headers_handler_interface.h"
 
@@ -36,7 +36,8 @@
 
   // From SpdyHeadersHandlerInteface.
   void OnHeaderBlockStart() override;
-  void OnHeader(QuicStringPiece name, QuicStringPiece value) override;
+  void OnHeader(quiche::QuicheStringPiece name,
+                quiche::QuicheStringPiece value) override;
   void OnHeaderBlockEnd(size_t uncompressed_header_bytes,
                         size_t compressed_header_bytes) override;
 
diff --git a/quic/core/http/quic_headers_stream_test.cc b/quic/core/http/quic_headers_stream_test.cc
index 4cf11cc..35c74fc 100644
--- a/quic/core/http/quic_headers_stream_test.cc
+++ b/quic/core/http/quic_headers_stream_test.cc
@@ -18,14 +18,14 @@
 #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_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_string_piece.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_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/common/platform/api/quiche_endian.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"
 #include "net/third_party/quiche/src/spdy/core/http2_frame_decoder_adapter.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
@@ -128,7 +128,7 @@
   MOCK_METHOD2(OnContinuation, void(SpdyStreamId stream_id, bool end));
   MOCK_METHOD3(OnAltSvc,
                void(SpdyStreamId stream_id,
-                    QuicStringPiece origin,
+                    quiche::QuicheStringPiece origin,
                     const SpdyAltSvcWireFormat::AlternativeServiceVector&
                         altsvc_vector));
   MOCK_METHOD4(OnPriority,
@@ -163,7 +163,7 @@
 
 // Used by ::testing::PrintToStringParamName().
 std::string PrintToString(const TestParams& tp) {
-  return QuicStrCat(
+  return quiche::QuicheStrCat(
       ParsedQuicVersionToString(tp.version), "_",
       (tp.perspective == Perspective::IS_CLIENT ? "client" : "server"));
 }
@@ -244,7 +244,7 @@
     return true;
   }
 
-  void SaveHeaderDataStringPiece(QuicStringPiece data) {
+  void SaveHeaderDataStringPiece(quiche::QuicheStringPiece data) {
     saved_header_data_.append(data.data(), data.length());
   }
 
@@ -661,30 +661,34 @@
   SpdySerializedFrame frame(framer_->SerializeFrame(data));
   EXPECT_CALL(
       *connection_,
-      CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
-                      QuicStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
-                                 SETTINGS_MAX_CONCURRENT_STREAMS),
-                      _));
+      CloseConnection(
+          QUIC_INVALID_HEADERS_STREAM_DATA,
+          quiche::QuicheStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
+                               SETTINGS_MAX_CONCURRENT_STREAMS),
+          _));
   EXPECT_CALL(
       *connection_,
-      CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
-                      QuicStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
-                                 SETTINGS_INITIAL_WINDOW_SIZE),
-                      _));
+      CloseConnection(
+          QUIC_INVALID_HEADERS_STREAM_DATA,
+          quiche::QuicheStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
+                               SETTINGS_INITIAL_WINDOW_SIZE),
+          _));
   if (session_.perspective() == Perspective::IS_CLIENT) {
-    EXPECT_CALL(*connection_,
-                CloseConnection(
-                    QUIC_INVALID_HEADERS_STREAM_DATA,
-                    QuicStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
-                               SETTINGS_ENABLE_PUSH),
-                    _));
+    EXPECT_CALL(
+        *connection_,
+        CloseConnection(
+            QUIC_INVALID_HEADERS_STREAM_DATA,
+            quiche::QuicheStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
+                                 SETTINGS_ENABLE_PUSH),
+            _));
   }
   EXPECT_CALL(
       *connection_,
-      CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
-                      QuicStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
-                                 SETTINGS_MAX_FRAME_SIZE),
-                      _));
+      CloseConnection(
+          QUIC_INVALID_HEADERS_STREAM_DATA,
+          quiche::QuicheStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
+                               SETTINGS_MAX_FRAME_SIZE),
+          _));
   stream_frame_.data_buffer = frame.data();
   stream_frame_.data_length = frame.size();
   headers_stream_->OnStreamFrame(stream_frame_);
diff --git a/quic/core/http/quic_receive_control_stream.cc b/quic/core/http/quic_receive_control_stream.cc
index c949fa7..26d2e82 100644
--- a/quic/core/http/quic_receive_control_stream.cc
+++ b/quic/core/http/quic_receive_control_stream.cc
@@ -11,6 +11,7 @@
 #include "net/third_party/quiche/src/quic/core/http/quic_spdy_session.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -95,7 +96,7 @@
     return false;
   }
 
-  bool OnDataFramePayload(QuicStringPiece /*payload*/) override {
+  bool OnDataFramePayload(quiche::QuicheStringPiece /*payload*/) override {
     CloseConnectionOnWrongFrame("Data");
     return false;
   }
@@ -110,7 +111,7 @@
     return false;
   }
 
-  bool OnHeadersFramePayload(QuicStringPiece /*payload*/) override {
+  bool OnHeadersFramePayload(quiche::QuicheStringPiece /*payload*/) override {
     CloseConnectionOnWrongFrame("Headers");
     return false;
   }
@@ -131,7 +132,8 @@
     return false;
   }
 
-  bool OnPushPromiseFramePayload(QuicStringPiece /*payload*/) override {
+  bool OnPushPromiseFramePayload(
+      quiche::QuicheStringPiece /*payload*/) override {
     CloseConnectionOnWrongFrame("Push Promise");
     return false;
   }
@@ -147,7 +149,7 @@
     return true;
   }
 
-  bool OnUnknownFramePayload(QuicStringPiece /* payload */) override {
+  bool OnUnknownFramePayload(quiche::QuicheStringPiece /* payload */) override {
     // Ignore unknown frame types.
     return true;
   }
@@ -158,11 +160,11 @@
   }
 
  private:
-  void CloseConnectionOnWrongFrame(QuicStringPiece frame_type) {
+  void CloseConnectionOnWrongFrame(quiche::QuicheStringPiece frame_type) {
     // TODO(renjietang): Change to HTTP/3 error type.
     stream_->session()->connection()->CloseConnection(
         QUIC_HTTP_DECODER_ERROR,
-        QuicStrCat(frame_type, " frame received on control stream"),
+        quiche::QuicheStrCat(frame_type, " frame received on control stream"),
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
   }
 
diff --git a/quic/core/http/quic_receive_control_stream_test.cc b/quic/core/http/quic_receive_control_stream_test.cc
index 8418766..b9a2923 100644
--- a/quic/core/http/quic_receive_control_stream_test.cc
+++ b/quic/core/http/quic_receive_control_stream_test.cc
@@ -8,10 +8,11 @@
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_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/common/platform/api/quiche_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 namespace quic {
 namespace test {
@@ -43,7 +44,7 @@
 
 // Used by ::testing::PrintToStringParamName().
 std::string PrintToString(const TestParams& tp) {
-  return QuicStrCat(
+  return quiche::QuicheStrCat(
       ParsedQuicVersionToString(tp.version), "_",
       (tp.perspective == Perspective::IS_CLIENT ? "client" : "server"));
 }
@@ -88,7 +89,7 @@
                                 session_.transport_version(), 3);
     char type[] = {kControlStream};
 
-    QuicStreamFrame data1(id, false, 0, QuicStringPiece(type, 1));
+    QuicStreamFrame data1(id, false, 0, quiche::QuicheStringPiece(type, 1));
     session_.OnStreamFrame(data1);
 
     receive_control_stream_ =
@@ -285,7 +286,7 @@
 
 // Regression test for b/137554973: unknown frames should be consumed.
 TEST_P(QuicReceiveControlStreamTest, ConsumeUnknownFrame) {
-  std::string unknown_frame = QuicTextUtils::HexDecode(
+  std::string unknown_frame = quiche::QuicheTextUtils::HexDecode(
       "21"        // reserved frame type
       "03"        // payload length
       "666f6f");  // payload "foo"
diff --git a/quic/core/http/quic_send_control_stream.cc b/quic/core/http/quic_send_control_stream.cc
index ed7cd7f..abb21ae 100644
--- a/quic/core/http/quic_send_control_stream.cc
+++ b/quic/core/http/quic_send_control_stream.cc
@@ -11,7 +11,7 @@
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.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 {
 
@@ -46,8 +46,8 @@
   char data[sizeof(kControlStream)];
   QuicDataWriter writer(QUIC_ARRAYSIZE(data), data);
   writer.WriteVarInt62(kControlStream);
-  WriteOrBufferData(QuicStringPiece(writer.data(), writer.length()), false,
-                    nullptr);
+  WriteOrBufferData(quiche::QuicheStringPiece(writer.data(), writer.length()),
+                    false, nullptr);
 
   SettingsFrame settings;
   settings.values[SETTINGS_QPACK_MAX_TABLE_CAPACITY] =
@@ -66,7 +66,7 @@
   if (spdy_session->debug_visitor() != nullptr) {
     spdy_session->debug_visitor()->OnSettingsFrameSent(settings);
   }
-  WriteOrBufferData(QuicStringPiece(buffer.get(), frame_length),
+  WriteOrBufferData(quiche::QuicheStringPiece(buffer.get(), frame_length),
                     /*fin = */ false, nullptr);
   settings_sent_ = true;
 }
@@ -78,8 +78,8 @@
   QuicByteCount frame_length =
       HttpEncoder::SerializePriorityFrame(priority, &buffer);
   QUIC_DVLOG(1) << "Control Stream " << id() << " is writing " << priority;
-  WriteOrBufferData(QuicStringPiece(buffer.get(), frame_length), false,
-                    nullptr);
+  WriteOrBufferData(quiche::QuicheStringPiece(buffer.get(), frame_length),
+                    false, nullptr);
 }
 
 void QuicSendControlStream::SendMaxPushIdFrame(PushId max_push_id) {
@@ -91,7 +91,7 @@
   std::unique_ptr<char[]> buffer;
   QuicByteCount frame_length =
       HttpEncoder::SerializeMaxPushIdFrame(frame, &buffer);
-  WriteOrBufferData(QuicStringPiece(buffer.get(), frame_length),
+  WriteOrBufferData(quiche::QuicheStringPiece(buffer.get(), frame_length),
                     /*fin = */ false, nullptr);
 }
 
@@ -110,8 +110,8 @@
   std::unique_ptr<char[]> buffer;
   QuicByteCount frame_length =
       HttpEncoder::SerializeGoAwayFrame(frame, &buffer);
-  WriteOrBufferData(QuicStringPiece(buffer.get(), frame_length), false,
-                    nullptr);
+  WriteOrBufferData(quiche::QuicheStringPiece(buffer.get(), frame_length),
+                    false, nullptr);
 }
 
 }  // namespace quic
diff --git a/quic/core/http/quic_send_control_stream_test.cc b/quic/core/http/quic_send_control_stream_test.cc
index de2e705..9d3504e 100644
--- a/quic/core/http/quic_send_control_stream_test.cc
+++ b/quic/core/http/quic_send_control_stream_test.cc
@@ -6,10 +6,11 @@
 
 #include <utility>
 
-#include "net/third_party/quiche/src/quic/platform/api/quic_text_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 namespace quic {
 namespace test {
@@ -43,7 +44,7 @@
 
 // Used by ::testing::PrintToStringParamName().
 std::string PrintToString(const TestParams& tp) {
-  return QuicStrCat(
+  return quiche::QuicheStrCat(
       ParsedQuicVersionToString(tp.version), "_",
       (tp.perspective == Perspective::IS_CLIENT ? "client" : "server"));
 }
@@ -109,7 +110,7 @@
   Initialize();
   testing::InSequence s;
 
-  std::string expected_write_data = QuicTextUtils::HexDecode(
+  std::string expected_write_data = quiche::QuicheTextUtils::HexDecode(
       "00"    // stream type: control stream
       "04"    // frame type: SETTINGS frame
       "08"    // frame length
@@ -141,7 +142,7 @@
 
   send_control_stream_->MaybeSendSettingsFrame();
   EXPECT_EQ(expected_write_data,
-            QuicStringPiece(writer.data(), writer.length()));
+            quiche::QuicheStringPiece(writer.data(), writer.length()));
 }
 
 TEST_P(QuicSendControlStreamTest, WriteSettingsOnlyOnce) {
diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index a1b1b3c..c13709e 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -36,6 +36,7 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.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"
 
 using testing::_;
 using testing::StrictMock;
@@ -235,7 +236,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());
 
@@ -294,7 +295,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.
@@ -305,9 +306,9 @@
 TEST_P(QuicServerSessionBaseTest, 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());
@@ -336,9 +337,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.
diff --git a/quic/core/http/quic_spdy_client_session_test.cc b/quic/core/http/quic_spdy_client_session_test.cc
index 685ffc7..d699c85 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -17,7 +17,6 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.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_test.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_spdy_client_stream.h"
@@ -28,6 +27,8 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_session_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 using spdy::SpdyHeaderBlock;
 using testing::_;
@@ -427,7 +428,7 @@
         connection_->transport_version(), 3);
     char type[] = {0x00};
 
-    QuicStreamFrame data1(id, false, 0, QuicStringPiece(type, 1));
+    QuicStreamFrame data1(id, false, 0, quiche::QuicheStringPiece(type, 1));
     session_->OnStreamFrame(data1);
   } else {
     id = QuicUtils::GetHeadersStreamId(connection_->transport_version());
@@ -457,7 +458,7 @@
         connection_->transport_version(), 3);
     char type[] = {0x00};
 
-    QuicStreamFrame data1(id, false, 0, QuicStringPiece(type, 1));
+    QuicStreamFrame data1(id, false, 0, quiche::QuicheStringPiece(type, 1));
     session_->OnStreamFrame(data1);
   } else {
     id = QuicUtils::GetHeadersStreamId(connection_->transport_version());
@@ -744,7 +745,7 @@
 
 TEST_P(QuicSpdyClientSessionTest, ReceivingPromiseEnhanceYourCalm) {
   for (size_t i = 0u; i < session_->get_max_promises(); i++) {
-    push_promise_[":path"] = QuicStringPrintf("/bar%zu", i);
+    push_promise_[":path"] = quiche::QuicheStringPrintf("/bar%zu", i);
 
     QuicStreamId id =
         promised_stream_id_ +
@@ -762,7 +763,7 @@
 
   // One more promise, this should be refused.
   int i = session_->get_max_promises();
-  push_promise_[":path"] = QuicStringPrintf("/bar%d", i);
+  push_promise_[":path"] = quiche::QuicheStringPrintf("/bar%d", i);
 
   QuicStreamId id =
       promised_stream_id_ +
@@ -922,7 +923,7 @@
         connection_->transport_version(), promise_count);
     auto headers = QuicHeaderList();
     headers.OnHeaderBlockStart();
-    headers.OnHeader(":path", QuicStrCat("/", promise_count));
+    headers.OnHeader(":path", quiche::QuicheStrCat("/", promise_count));
     headers.OnHeader(":authority", "www.google.com");
     headers.OnHeader(":method", "GET");
     headers.OnHeader(":scheme", "https");
diff --git a/quic/core/http/quic_spdy_client_stream.cc b/quic/core/http/quic_spdy_client_stream.cc
index 5cbb79d..7232f76 100644
--- a/quic/core/http/quic_spdy_client_stream.cc
+++ b/quic/core/http/quic_spdy_client_stream.cc
@@ -11,6 +11,7 @@
 #include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
 #include "net/third_party/quiche/src/quic/core/quic_alarm.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.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"
 
 using spdy::SpdyHeaderBlock;
@@ -140,7 +141,7 @@
 }
 
 size_t QuicSpdyClientStream::SendRequest(SpdyHeaderBlock headers,
-                                         QuicStringPiece body,
+                                         quiche::QuicheStringPiece body,
                                          bool fin) {
   QuicConnection::ScopedPacketFlusher flusher(session_->connection());
   bool send_fin_with_headers = fin && body.empty();
diff --git a/quic/core/http/quic_spdy_client_stream.h b/quic/core/http/quic_spdy_client_stream.h
index 5cd27d4..dfb9270 100644
--- a/quic/core/http/quic_spdy_client_stream.h
+++ b/quic/core/http/quic_spdy_client_stream.h
@@ -10,7 +10,7 @@
 
 #include "net/third_party/quiche/src/quic/core/http/quic_spdy_stream.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/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_framer.h"
 
 namespace quic {
@@ -52,7 +52,7 @@
   // Serializes the headers and body, sends it to the server, and
   // returns the number of bytes sent.
   size_t SendRequest(spdy::SpdyHeaderBlock headers,
-                     QuicStringPiece body,
+                     quiche::QuicheStringPiece body,
                      bool fin);
 
   // Returns the response data.
diff --git a/quic/core/http/quic_spdy_client_stream_test.cc b/quic/core/http/quic_spdy_client_stream_test.cc
index 8c1501e..50224cb 100644
--- a/quic/core/http/quic_spdy_client_stream_test.cc
+++ b/quic/core/http/quic_spdy_client_stream_test.cc
@@ -14,10 +14,10 @@
 #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/crypto_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 using spdy::SpdyHeaderBlock;
 using testing::_;
@@ -212,7 +212,7 @@
   SpdyHeaderBlock trailer_block;
   trailer_block["trailer key"] = "trailer value";
   trailer_block[kFinalOffsetHeaderKey] =
-      QuicTextUtils::Uint64ToString(body_.size());
+      quiche::QuicheTextUtils::Uint64ToString(body_.size());
   auto trailers = AsHeaderList(trailer_block);
   stream_->OnStreamHeaderList(true, trailers.uncompressed_header_bytes(),
                               trailers);
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 2d38f86..23c0c63 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -22,8 +22,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_stack_trace.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"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 #include "net/third_party/quiche/src/spdy/core/http2_frame_decoder_adapter.h"
 
 using http2::Http2DecoderAdapter;
@@ -145,10 +146,10 @@
       default:
         break;
     }
-    CloseConnection(
-        QuicStrCat("SPDY framing error: ",
-                   Http2DecoderAdapter::SpdyFramerErrorToString(error)),
-        code);
+    CloseConnection(quiche::QuicheStrCat(
+                        "SPDY framing error: ",
+                        Http2DecoderAdapter::SpdyFramerErrorToString(error)),
+                    code);
   }
 
   void OnDataFrameHeader(SpdyStreamId /*stream_id*/,
@@ -414,20 +415,22 @@
       2 * max_inbound_header_list_size_);
 }
 
-void QuicSpdySession::OnDecoderStreamError(QuicStringPiece error_message) {
+void QuicSpdySession::OnDecoderStreamError(
+    quiche::QuicheStringPiece error_message) {
   DCHECK(VersionUsesHttp3(transport_version()));
 
   CloseConnectionWithDetails(
       QUIC_QPACK_DECODER_STREAM_ERROR,
-      QuicStrCat("Decoder stream error: ", error_message));
+      quiche::QuicheStrCat("Decoder stream error: ", error_message));
 }
 
-void QuicSpdySession::OnEncoderStreamError(QuicStringPiece error_message) {
+void QuicSpdySession::OnEncoderStreamError(
+    quiche::QuicheStringPiece error_message) {
   DCHECK(VersionUsesHttp3(transport_version()));
 
   CloseConnectionWithDetails(
       QUIC_QPACK_ENCODER_STREAM_ERROR,
-      QuicStrCat("Encoder stream error: ", error_message));
+      quiche::QuicheStrCat("Encoder stream error: ", error_message));
 }
 
 void QuicSpdySession::OnStreamHeadersPriority(
@@ -460,7 +463,8 @@
       const std::string& header_key = header.first;
       const std::string& header_value = header.second;
       if (header_key == kFinalOffsetHeaderKey) {
-        if (!QuicTextUtils::StringToSizeT(header_value, &final_byte_offset)) {
+        if (!quiche::QuicheTextUtils::StringToSizeT(header_value,
+                                                    &final_byte_offset)) {
           connection()->CloseConnection(
               QUIC_INVALID_HEADERS_STREAM_DATA,
               "Trailers are malformed (no final offset)",
@@ -523,7 +527,7 @@
   SpdyPriorityIR priority_frame(id, parent_stream_id, weight, exclusive);
   SpdySerializedFrame frame(spdy_framer_.SerializeFrame(priority_frame));
   headers_stream()->WriteOrBufferData(
-      QuicStringPiece(frame.data(), frame.size()), false, nullptr);
+      quiche::QuicheStringPiece(frame.data(), frame.size()), false, nullptr);
   return frame.size();
 }
 
@@ -581,7 +585,7 @@
 
     SpdySerializedFrame frame(spdy_framer_.SerializeFrame(push_promise));
     headers_stream()->WriteOrBufferData(
-        QuicStringPiece(frame.data(), frame.size()), false, nullptr);
+        quiche::QuicheStringPiece(frame.data(), frame.size()), false, nullptr);
     return;
   }
 
@@ -628,7 +632,8 @@
   if (stream && stream->is_static()) {
     QUIC_BUG << "GetOrCreateSpdyDataStream returns static stream " << stream_id;
     connection()->CloseConnection(
-        QUIC_INVALID_STREAM_ID, QuicStrCat("stream ", stream_id, " is static"),
+        QUIC_INVALID_STREAM_ID,
+        quiche::QuicheStrCat("stream ", stream_id, " is static"),
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return nullptr;
   }
@@ -681,7 +686,7 @@
   }
   SpdySerializedFrame frame(spdy_framer_.SerializeFrame(headers_frame));
   headers_stream()->WriteOrBufferData(
-      QuicStringPiece(frame.data(), frame.size()), false,
+      quiche::QuicheStringPiece(frame.data(), frame.size()), false,
       std::move(ack_listener));
 
   // Calculate compressed header block size without framing overhead.
@@ -766,7 +771,8 @@
           if (IsConnected()) {
             CloseConnectionWithDetails(
                 QUIC_INVALID_HEADERS_STREAM_DATA,
-                QuicStrCat("Invalid value for SETTINGS_ENABLE_PUSH: ", value));
+                quiche::QuicheStrCat("Invalid value for SETTINGS_ENABLE_PUSH: ",
+                                     value));
           }
           return;
         }
@@ -782,7 +788,8 @@
         if (IsConnected()) {
           CloseConnectionWithDetails(
               QUIC_INVALID_HEADERS_STREAM_DATA,
-              QuicStrCat("Unsupported field of HTTP/2 SETTINGS frame: ", id));
+              quiche::QuicheStrCat(
+                  "Unsupported field of HTTP/2 SETTINGS frame: ", id));
         }
       }
       break;
@@ -799,7 +806,8 @@
       if (IsConnected()) {
         CloseConnectionWithDetails(
             QUIC_INVALID_HEADERS_STREAM_DATA,
-            QuicStrCat("Unsupported field of HTTP/2 SETTINGS frame: ", id));
+            quiche::QuicheStrCat("Unsupported field of HTTP/2 SETTINGS frame: ",
+                                 id));
       }
   }
 }
@@ -1062,12 +1070,13 @@
 }
 
 void QuicSpdySession::CloseConnectionOnDuplicateHttp3UnidirectionalStreams(
-    QuicStringPiece type) {
-  QUIC_PEER_BUG << QuicStrCat("Received a duplicate ", type,
-                              " stream: Closing connection.");
+    quiche::QuicheStringPiece type) {
+  QUIC_PEER_BUG << quiche::QuicheStrCat("Received a duplicate ", type,
+                                        " stream: Closing connection.");
   // TODO(b/124216424): Change to HTTP_STREAM_CREATION_ERROR.
-  CloseConnectionWithDetails(QUIC_INVALID_STREAM_ID,
-                             QuicStrCat(type, " stream is received twice."));
+  CloseConnectionWithDetails(
+      QUIC_INVALID_STREAM_ID,
+      quiche::QuicheStrCat(type, " stream is received twice."));
 }
 
 // static
diff --git a/quic/core/http/quic_spdy_session.h b/quic/core/http/quic_spdy_session.h
index 7e952c5..032ee12 100644
--- a/quic/core/http/quic_spdy_session.h
+++ b/quic/core/http/quic_spdy_session.h
@@ -24,7 +24,7 @@
 #include "net/third_party/quiche/src/quic/core/quic_session.h"
 #include "net/third_party/quiche/src/quic/core/quic_versions.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"
 #include "net/third_party/quiche/src/spdy/core/http2_frame_decoder_adapter.h"
 
 namespace quic {
@@ -95,10 +95,10 @@
   void Initialize() override;
 
   // QpackEncoder::DecoderStreamErrorDelegate implementation.
-  void OnDecoderStreamError(QuicStringPiece error_message) override;
+  void OnDecoderStreamError(quiche::QuicheStringPiece error_message) override;
 
   // QpackDecoder::EncoderStreamErrorDelegate implementation.
-  void OnEncoderStreamError(QuicStringPiece error_message) override;
+  void OnEncoderStreamError(quiche::QuicheStringPiece error_message) override;
 
   // Called by |headers_stream_| when headers with a priority have been
   // received for a stream.  This method will only be called for server streams.
@@ -363,7 +363,7 @@
                   const spdy::SpdyStreamPrecedence& precedence);
 
   void CloseConnectionOnDuplicateHttp3UnidirectionalStreams(
-      QuicStringPiece type);
+      quiche::QuicheStringPiece type);
 
   // Sends any data which should be sent at the start of a connection,
   // including the initial SETTINGS frame, etc.
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index bf5004e..7503593 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -26,10 +26,7 @@
 #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/quic/platform/api/quic_ptr_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_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/qpack/qpack_encoder_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_header_table_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.h"
@@ -42,6 +39,9 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_stream_send_buffer_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_endian.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"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_framer.h"
 
 using spdy::kV3HighestPriority;
@@ -627,8 +627,8 @@
   EXPECT_CALL(*connection_, SendControlFrame(_));
   EXPECT_CALL(*connection_, OnStreamReset(closed_stream_id, _));
   stream2->Reset(QUIC_BAD_APPLICATION_PAYLOAD);
-  std::string msg =
-      QuicStrCat("Marking unknown stream ", closed_stream_id, " blocked.");
+  std::string msg = quiche::QuicheStrCat("Marking unknown stream ",
+                                         closed_stream_id, " blocked.");
   EXPECT_QUIC_BUG(session_.MarkConnectionLevelWriteBlocked(closed_stream_id),
                   msg);
 }
@@ -1085,7 +1085,7 @@
 TEST_P(QuicSpdySessionTestServer, RstStreamBeforeHeadersDecompressed) {
   // Send two bytes of payload.
   QuicStreamFrame data1(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                        QuicStringPiece("HT"));
+                        quiche::QuicheStringPiece("HT"));
   session_.OnStreamFrame(data1);
   EXPECT_EQ(1u, session_.GetNumOpenIncomingStreams());
 
@@ -1129,14 +1129,14 @@
     id = GetNthClientInitiatedUnidirectionalStreamId(transport_version(), 3);
     char type[] = {kControlStream};
 
-    QuicStreamFrame data1(id, false, 0, QuicStringPiece(type, 1));
+    QuicStreamFrame data1(id, false, 0, quiche::QuicheStringPiece(type, 1));
     session_.OnStreamFrame(data1);
   } else {
     id = QuicUtils::GetHeadersStreamId(transport_version());
   }
 
   // Send two bytes of payload.
-  QuicStreamFrame data1(id, true, 0, QuicStringPiece("HT"));
+  QuicStreamFrame data1(id, true, 0, quiche::QuicheStringPiece("HT"));
   EXPECT_CALL(*connection_,
               CloseConnection(
                   QUIC_INVALID_STREAM_ID, "Attempt to close a static stream",
@@ -1151,7 +1151,7 @@
     id = GetNthClientInitiatedUnidirectionalStreamId(transport_version(), 3);
     char type[] = {kControlStream};
 
-    QuicStreamFrame data1(id, false, 0, QuicStringPiece(type, 1));
+    QuicStreamFrame data1(id, false, 0, quiche::QuicheStringPiece(type, 1));
     session_.OnStreamFrame(data1);
   } else {
     id = QuicUtils::GetHeadersStreamId(transport_version());
@@ -1170,7 +1170,7 @@
 TEST_P(QuicSpdySessionTestServer, OnStreamFrameInvalidStreamId) {
   // Send two bytes of payload.
   QuicStreamFrame data1(QuicUtils::GetInvalidStreamId(transport_version()),
-                        true, 0, QuicStringPiece("HT"));
+                        true, 0, quiche::QuicheStringPiece("HT"));
   EXPECT_CALL(*connection_,
               CloseConnection(
                   QUIC_INVALID_STREAM_ID, "Received data for an invalid stream",
@@ -1320,8 +1320,8 @@
   while (!headers_stream->flow_controller()->IsBlocked() && stream_id < 2000) {
     EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
     EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
-    headers["header"] = QuicStrCat(random.RandUint64(), random.RandUint64(),
-                                   random.RandUint64());
+    headers["header"] = quiche::QuicheStrCat(
+        random.RandUint64(), random.RandUint64(), random.RandUint64());
     session_.WriteHeadersOnHeadersStream(stream_id, headers.Clone(), true,
                                          spdy::SpdyStreamPrecedence(0),
                                          nullptr);
@@ -1447,7 +1447,8 @@
   // account the total number of bytes sent by the peer.
   const QuicStreamOffset kByteOffset = 5678;
   std::string body = "hello";
-  QuicStreamFrame frame(stream->id(), true, kByteOffset, QuicStringPiece(body));
+  QuicStreamFrame frame(stream->id(), true, kByteOffset,
+                        quiche::QuicheStringPiece(body));
   session_.OnStreamFrame(frame);
 
   QuicStreamOffset total_stream_bytes_sent_by_peer =
@@ -1564,7 +1565,8 @@
   EXPECT_CALL(*connection_, SendControlFrame(_));
   EXPECT_CALL(*connection_, OnStreamReset(stream->id(), _));
   stream->Reset(QUIC_STREAM_CANCELLED);
-  QuicStreamFrame frame(stream->id(), true, kLargeOffset, QuicStringPiece());
+  QuicStreamFrame frame(stream->id(), true, kLargeOffset,
+                        quiche::QuicheStringPiece());
   session_.OnStreamFrame(frame);
 
   // Check that RST results in connection close.
@@ -1630,7 +1632,7 @@
   // FIN or a RST_STREAM from the client.
   const QuicStreamId kNextId = QuicUtils::StreamIdDelta(transport_version());
   for (QuicStreamId i = kFirstStreamId; i < kFinalStreamId; i += kNextId) {
-    QuicStreamFrame data1(i, false, 0, QuicStringPiece("HT"));
+    QuicStreamFrame data1(i, false, 0, quiche::QuicheStringPiece("HT"));
     session_.OnStreamFrame(data1);
     // EXPECT_EQ(1u, session_.GetNumOpenStreams());
     if (!VersionHasIetfQuicFrames(transport_version())) {
@@ -1666,7 +1668,8 @@
                         _));
   }
   // Create one more data streams to exceed limit of open stream.
-  QuicStreamFrame data1(kFinalStreamId, false, 0, QuicStringPiece("HT"));
+  QuicStreamFrame data1(kFinalStreamId, false, 0,
+                        quiche::QuicheStringPiece("HT"));
   session_.OnStreamFrame(data1);
 }
 
@@ -1701,7 +1704,7 @@
   const QuicStreamId kFinalStreamId =
       GetNthClientInitiatedBidirectionalId(kMaxStreams + 1);
   for (QuicStreamId i = kFirstStreamId; i < kFinalStreamId; i += IdDelta()) {
-    QuicStreamFrame data1(i, true, 0, QuicStringPiece("HT"));
+    QuicStreamFrame data1(i, true, 0, quiche::QuicheStringPiece("HT"));
     session_.OnStreamFrame(data1);
     EXPECT_EQ(1u, session_.GetNumOpenIncomingStreams());
     session_.StreamDraining(i);
@@ -1815,7 +1818,7 @@
   QuicStreamPeer::CloseReadSide(stream);
 
   // Receive a stream data frame with FIN.
-  QuicStreamFrame frame(stream_id, true, 0, QuicStringPiece());
+  QuicStreamFrame frame(stream_id, true, 0, quiche::QuicheStringPiece());
   session_.OnStreamFrame(frame);
   EXPECT_TRUE(stream->fin_received());
 
@@ -1869,8 +1872,8 @@
 
   const QuicMemSlice& slice =
       QuicStreamSendBufferPeer::CurrentWriteSlice(&send_buffer)->slice;
-  EXPECT_EQ(QuicStringPiece(frame.data(), frame.size()),
-            QuicStringPiece(slice.data(), slice.length()));
+  EXPECT_EQ(quiche::QuicheStringPiece(frame.data(), frame.size()),
+            quiche::QuicheStringPiece(slice.data(), slice.length()));
 }
 
 TEST_P(QuicSpdySessionTestClient, Http3ServerPush) {
@@ -1881,7 +1884,7 @@
   EXPECT_EQ(0u, session_.GetNumOpenIncomingStreams());
 
   // Push unidirectional stream is type 0x01.
-  std::string frame_type1 = QuicTextUtils::HexDecode("01");
+  std::string frame_type1 = quiche::QuicheTextUtils::HexDecode("01");
   QuicStreamId stream_id1 =
       GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 0);
   session_.OnStreamFrame(QuicStreamFrame(stream_id1, /* fin = */ false,
@@ -1893,7 +1896,7 @@
   EXPECT_EQ(1u, session_.flow_controller()->bytes_consumed());
 
   // The same stream type can be encoded differently.
-  std::string frame_type2 = QuicTextUtils::HexDecode("80000001");
+  std::string frame_type2 = quiche::QuicheTextUtils::HexDecode("80000001");
   QuicStreamId stream_id2 =
       GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 1);
   session_.OnStreamFrame(QuicStreamFrame(stream_id2, /* fin = */ false,
@@ -1913,9 +1916,9 @@
   EXPECT_EQ(0u, session_.GetNumOpenIncomingStreams());
 
   // Push unidirectional stream is type 0x01.
-  std::string frame_type = QuicTextUtils::HexDecode("01");
+  std::string frame_type = quiche::QuicheTextUtils::HexDecode("01");
   // The first field of a push stream is the Push ID.
-  std::string push_id = QuicTextUtils::HexDecode("4000");
+  std::string push_id = quiche::QuicheTextUtils::HexDecode("4000");
 
   QuicStreamId stream_id =
       GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 0);
@@ -2120,7 +2123,7 @@
 
   char input[] = {0x04,            // type
                   'a', 'b', 'c'};  // data
-  QuicStringPiece payload(input, QUIC_ARRAYSIZE(input));
+  quiche::QuicheStringPiece payload(input, QUIC_ARRAYSIZE(input));
 
   // This is a server test with a client-initiated unidirectional stream.
   QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
@@ -2156,7 +2159,7 @@
 
   char input[] = {0x04,            // type
                   'a', 'b', 'c'};  // data
-  QuicStringPiece payload(input, QUIC_ARRAYSIZE(input));
+  quiche::QuicheStringPiece payload(input, QUIC_ARRAYSIZE(input));
 
   // This is a server test with a client-initiated unidirectional stream.
   QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
@@ -2197,7 +2200,7 @@
 
   char input[] = {0x41, 0x00,      // type (256)
                   'a', 'b', 'c'};  // data
-  QuicStringPiece payload(input, QUIC_ARRAYSIZE(input));
+  quiche::QuicheStringPiece payload(input, QUIC_ARRAYSIZE(input));
 
   // This is a server test with a client-initiated unidirectional stream.
   QuicStreamId stream_id = QuicUtils::GetFirstUnidirectionalStreamId(
@@ -2244,7 +2247,8 @@
       GetNthClientInitiatedUnidirectionalStreamId(transport_version(), 3);
   char type[] = {kControlStream};
 
-  QuicStreamFrame data1(stream_id, false, 0, QuicStringPiece(type, 1));
+  QuicStreamFrame data1(stream_id, false, 0,
+                        quiche::QuicheStringPiece(type, 1));
   EXPECT_CALL(debug_visitor, OnPeerControlStreamCreated(stream_id)).Times(0);
   session_.OnStreamFrame(data1);
   EXPECT_EQ(stream_id,
@@ -2256,7 +2260,7 @@
   settings.values[SETTINGS_MAX_HEADER_LIST_SIZE] = 5;
   settings.values[SETTINGS_QPACK_BLOCKED_STREAMS] = 42;
   std::string data = EncodeSettings(settings);
-  QuicStreamFrame frame(stream_id, false, 1, QuicStringPiece(data));
+  QuicStreamFrame frame(stream_id, false, 1, quiche::QuicheStringPiece(data));
 
   QpackEncoder* qpack_encoder = session_.qpack_encoder();
   QpackHeaderTable* header_table =
@@ -2289,8 +2293,9 @@
   settings.values[SETTINGS_MAX_HEADER_LIST_SIZE] = 5;
   std::string data = EncodeSettings(settings);
 
-  QuicStreamFrame data1(stream_id, false, 1, QuicStringPiece(data));
-  QuicStreamFrame data2(stream_id, false, 0, QuicStringPiece(type, 1));
+  QuicStreamFrame data1(stream_id, false, 1, quiche::QuicheStringPiece(data));
+  QuicStreamFrame data2(stream_id, false, 0,
+                        quiche::QuicheStringPiece(type, 1));
 
   session_.OnStreamFrame(data1);
   EXPECT_NE(5u, session_.max_outbound_header_list_size());
@@ -2310,14 +2315,15 @@
   TestStream* stream = session_.CreateIncomingStream(stream_id);
 
   // HEADERS frame referencing first dynamic table entry.
-  std::string headers_payload = QuicTextUtils::HexDecode("020080");
+  std::string headers_payload = quiche::QuicheTextUtils::HexDecode("020080");
   std::unique_ptr<char[]> headers_buffer;
   QuicByteCount headers_frame_header_length =
       HttpEncoder::SerializeHeadersFrameHeader(headers_payload.length(),
                                                &headers_buffer);
-  QuicStringPiece headers_frame_header(headers_buffer.get(),
-                                       headers_frame_header_length);
-  std::string headers = QuicStrCat(headers_frame_header, headers_payload);
+  quiche::QuicheStringPiece headers_frame_header(headers_buffer.get(),
+                                                 headers_frame_header_length);
+  std::string headers =
+      quiche::QuicheStrCat(headers_frame_header, headers_payload);
   stream->OnStreamFrame(QuicStreamFrame(stream_id, false, 0, headers));
 
   // Decoding is blocked because dynamic table entry has not been received yet.
@@ -2344,14 +2350,15 @@
   TestStream* stream = session_.CreateIncomingStream(stream_id);
 
   // HEADERS frame referencing first dynamic table entry.
-  std::string headers_payload = QuicTextUtils::HexDecode("020080");
+  std::string headers_payload = quiche::QuicheTextUtils::HexDecode("020080");
   std::unique_ptr<char[]> headers_buffer;
   QuicByteCount headers_frame_header_length =
       HttpEncoder::SerializeHeadersFrameHeader(headers_payload.length(),
                                                &headers_buffer);
-  QuicStringPiece headers_frame_header(headers_buffer.get(),
-                                       headers_frame_header_length);
-  std::string headers = QuicStrCat(headers_frame_header, headers_payload);
+  quiche::QuicheStringPiece headers_frame_header(headers_buffer.get(),
+                                                 headers_frame_header_length);
+  std::string headers =
+      quiche::QuicheStrCat(headers_frame_header, headers_payload);
   stream->OnStreamFrame(QuicStreamFrame(stream_id, false, 0, headers));
 
   // Decoding is blocked because dynamic table entry has not been received yet.
@@ -2376,7 +2383,7 @@
   // Payload consists of two bytes.  The first byte is an unknown unidirectional
   // stream type.  The second one would be the type of a push stream, but it
   // must not be interpreted as stream type.
-  std::string payload = QuicTextUtils::HexDecode("3f01");
+  std::string payload = quiche::QuicheTextUtils::HexDecode("3f01");
   QuicStreamFrame frame(stream_id, /* fin = */ false, /* offset = */ 0,
                         payload);
 
@@ -2422,7 +2429,7 @@
   // Payload consists of two bytes.  The first byte is an unknown unidirectional
   // stream type.  The second one would be the type of a push stream, but it
   // must not be interpreted as stream type.
-  std::string payload = QuicTextUtils::HexDecode("3f01");
+  std::string payload = quiche::QuicheTextUtils::HexDecode("3f01");
   QuicStreamFrame frame(stream_id, /* fin = */ false, /* offset = */ 0,
                         payload);
 
@@ -2459,7 +2466,7 @@
       GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 0);
 
   // Payload is the first byte of a two byte varint encoding.
-  std::string payload = QuicTextUtils::HexDecode("40");
+  std::string payload = quiche::QuicheTextUtils::HexDecode("40");
   QuicStreamFrame frame(stream_id, /* fin = */ false, /* offset = */ 0,
                         payload);
 
@@ -2487,7 +2494,7 @@
       GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 0);
 
   // Payload is the first byte of a two byte varint encoding with a FIN.
-  std::string payload = QuicTextUtils::HexDecode("40");
+  std::string payload = quiche::QuicheTextUtils::HexDecode("40");
   QuicStreamFrame frame(stream_id, /* fin = */ true, /* offset = */ 0, payload);
 
   session_.OnStreamFrame(frame);
@@ -2506,12 +2513,12 @@
       GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 0);
   char type1[] = {kControlStream};
 
-  QuicStreamFrame data1(id1, false, 0, QuicStringPiece(type1, 1));
+  QuicStreamFrame data1(id1, false, 0, quiche::QuicheStringPiece(type1, 1));
   EXPECT_CALL(debug_visitor, OnPeerControlStreamCreated(id1));
   session_.OnStreamFrame(data1);
   QuicStreamId id2 =
       GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 1);
-  QuicStreamFrame data2(id2, false, 0, QuicStringPiece(type1, 1));
+  QuicStreamFrame data2(id2, false, 0, quiche::QuicheStringPiece(type1, 1));
   EXPECT_CALL(debug_visitor, OnPeerControlStreamCreated(id2)).Times(0);
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_INVALID_STREAM_ID,
@@ -2524,13 +2531,13 @@
       GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 2);
   char type2[]{kQpackEncoderStream};
 
-  QuicStreamFrame data3(id3, false, 0, QuicStringPiece(type2, 1));
+  QuicStreamFrame data3(id3, false, 0, quiche::QuicheStringPiece(type2, 1));
   EXPECT_CALL(debug_visitor, OnPeerQpackEncoderStreamCreated(id3));
   session_.OnStreamFrame(data3);
 
   QuicStreamId id4 =
       GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 3);
-  QuicStreamFrame data4(id4, false, 0, QuicStringPiece(type2, 1));
+  QuicStreamFrame data4(id4, false, 0, quiche::QuicheStringPiece(type2, 1));
   EXPECT_CALL(debug_visitor, OnPeerQpackEncoderStreamCreated(id4)).Times(0);
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_INVALID_STREAM_ID,
@@ -2543,13 +2550,13 @@
       GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 4);
   char type3[]{kQpackDecoderStream};
 
-  QuicStreamFrame data5(id5, false, 0, QuicStringPiece(type3, 1));
+  QuicStreamFrame data5(id5, false, 0, quiche::QuicheStringPiece(type3, 1));
   EXPECT_CALL(debug_visitor, OnPeerQpackDecoderStreamCreated(id5));
   session_.OnStreamFrame(data5);
 
   QuicStreamId id6 =
       GetNthServerInitiatedUnidirectionalStreamId(transport_version(), 5);
-  QuicStreamFrame data6(id6, false, 0, QuicStringPiece(type3, 1));
+  QuicStreamFrame data6(id6, false, 0, quiche::QuicheStringPiece(type3, 1));
   EXPECT_CALL(debug_visitor, OnPeerQpackDecoderStreamCreated(id6)).Times(0);
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_INVALID_STREAM_ID,
@@ -2564,7 +2571,7 @@
     return;
   }
 
-  std::string data = QuicTextUtils::HexDecode(
+  std::string data = quiche::QuicheTextUtils::HexDecode(
       "02"    // Encoder stream.
       "00");  // Duplicate entry 0, but no entries exist.
 
@@ -2585,7 +2592,7 @@
     return;
   }
 
-  std::string data = QuicTextUtils::HexDecode(
+  std::string data = quiche::QuicheTextUtils::HexDecode(
       "03"    // Decoder stream.
       "00");  // Insert Count Increment with forbidden increment value of zero.
 
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index bf1f127..a65e964 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -23,8 +23,8 @@
 #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_mem_slice_storage.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/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;
@@ -91,7 +91,7 @@
     return stream_->OnDataFrameStart(header_length);
   }
 
-  bool OnDataFramePayload(QuicStringPiece payload) override {
+  bool OnDataFramePayload(quiche::QuicheStringPiece payload) override {
     DCHECK(!payload.empty());
     return stream_->OnDataFramePayload(payload);
   }
@@ -106,7 +106,7 @@
     return stream_->OnHeadersFrameStart(header_length);
   }
 
-  bool OnHeadersFramePayload(QuicStringPiece payload) override {
+  bool OnHeadersFramePayload(quiche::QuicheStringPiece payload) override {
     DCHECK(!payload.empty());
     if (!VersionUsesHttp3(stream_->transport_version())) {
       CloseConnectionOnWrongFrame("Headers");
@@ -140,7 +140,7 @@
     return stream_->OnPushPromiseFramePushId(push_id, push_id_length);
   }
 
-  bool OnPushPromiseFramePayload(QuicStringPiece payload) override {
+  bool OnPushPromiseFramePayload(quiche::QuicheStringPiece payload) override {
     DCHECK(!payload.empty());
     if (!VersionUsesHttp3(stream_->transport_version())) {
       CloseConnectionOnWrongFrame("Push Promise");
@@ -162,17 +162,17 @@
     return stream_->OnUnknownFrameStart(frame_type, header_length);
   }
 
-  bool OnUnknownFramePayload(QuicStringPiece payload) override {
+  bool OnUnknownFramePayload(quiche::QuicheStringPiece payload) override {
     return stream_->OnUnknownFramePayload(payload);
   }
 
   bool OnUnknownFrameEnd() override { return stream_->OnUnknownFrameEnd(); }
 
  private:
-  void CloseConnectionOnWrongFrame(QuicStringPiece frame_type) {
+  void CloseConnectionOnWrongFrame(quiche::QuicheStringPiece frame_type) {
     stream_->session()->connection()->CloseConnection(
         QUIC_HTTP_DECODER_ERROR,
-        QuicStrCat(frame_type, " frame received on data stream"),
+        quiche::QuicheStrCat(frame_type, " frame received on data stream"),
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
   }
 
@@ -273,8 +273,8 @@
 
     QUIC_LOG(INFO) << ENDPOINT << "Stream " << id()
                    << " is writing type as server push";
-    WriteOrBufferData(QuicStringPiece(writer.data(), writer.length()), false,
-                      nullptr);
+    WriteOrBufferData(quiche::QuicheStringPiece(writer.data(), writer.length()),
+                      false, nullptr);
   }
   size_t bytes_written =
       WriteHeadersImpl(std::move(header_block), fin, std::move(ack_listener));
@@ -289,7 +289,8 @@
   return bytes_written;
 }
 
-void QuicSpdyStream::WriteOrBufferBody(QuicStringPiece data, bool fin) {
+void QuicSpdyStream::WriteOrBufferBody(quiche::QuicheStringPiece data,
+                                       bool fin) {
   if (!VersionUsesHttp3(transport_version()) || data.length() == 0) {
     WriteOrBufferData(data, fin, nullptr);
     return;
@@ -306,8 +307,8 @@
   QUIC_DLOG(INFO) << ENDPOINT << "Stream " << id()
                   << " is writing DATA frame header of length "
                   << header_length;
-  WriteOrBufferData(QuicStringPiece(buffer.get(), header_length), false,
-                    nullptr);
+  WriteOrBufferData(quiche::QuicheStringPiece(buffer.get(), header_length),
+                    false, nullptr);
 
   // Write body.
   QUIC_DLOG(INFO) << ENDPOINT << "Stream " << id()
@@ -331,8 +332,9 @@
         stream_bytes_written() + BufferedDataBytes();
     QUIC_DLOG(INFO) << ENDPOINT << "Inserting trailer: ("
                     << kFinalOffsetHeaderKey << ", " << final_offset << ")";
-    trailer_block.insert(std::make_pair(
-        kFinalOffsetHeaderKey, QuicTextUtils::Uint64ToString(final_offset)));
+    trailer_block.insert(
+        std::make_pair(kFinalOffsetHeaderKey,
+                       quiche::QuicheTextUtils::Uint64ToString(final_offset)));
   }
 
   // Write the trailing headers with a FIN, and close stream for writing:
@@ -373,8 +375,8 @@
                   << " is writing Push Promise frame header of length "
                   << push_promise_frame_length << " , with promised id "
                   << frame.push_id;
-  WriteOrBufferData(QuicStringPiece(push_promise_frame_with_id.get(),
-                                    push_promise_frame_length),
+  WriteOrBufferData(quiche::QuicheStringPiece(push_promise_frame_with_id.get(),
+                                              push_promise_frame_length),
                     /* fin = */ false, /* ack_listener = */ nullptr);
 
   // Write response headers.
@@ -565,10 +567,11 @@
   }
 }
 
-void QuicSpdyStream::OnHeaderDecodingError(QuicStringPiece error_message) {
+void QuicSpdyStream::OnHeaderDecodingError(
+    quiche::QuicheStringPiece error_message) {
   qpack_decoded_headers_accumulator_.reset();
 
-  std::string connection_close_error_message = QuicStrCat(
+  std::string connection_close_error_message = quiche::QuicheStrCat(
       "Error decoding ", headers_decompressed_ ? "trailers" : "headers",
       " on stream ", id(), ": ", error_message);
   CloseConnectionWithDetails(QUIC_QPACK_DECOMPRESSION_FAILED,
@@ -580,7 +583,7 @@
     // TODO(b/124216424): Reset stream with H3_REQUEST_CANCELLED (if client)
     // or with H3_REQUEST_REJECTED (if server).
     std::string error_message =
-        QuicStrCat("Too large headers received on stream ", id());
+        quiche::QuicheStrCat("Too large headers received on stream ", id());
     CloseConnectionWithDetails(QUIC_HEADERS_STREAM_DATA_DECOMPRESS_FAILURE,
                                error_message);
   } else {
@@ -601,14 +604,14 @@
       OnStreamFrame(
           QuicStreamFrame(id(), /* fin = */ true,
                           flow_controller()->highest_received_byte_offset(),
-                          QuicStringPiece()));
+                          quiche::QuicheStringPiece()));
     }
     return;
   }
 
   if (fin && !rst_sent()) {
-    OnStreamFrame(
-        QuicStreamFrame(id(), fin, /* offset = */ 0, QuicStringPiece()));
+    OnStreamFrame(QuicStreamFrame(id(), fin, /* offset = */ 0,
+                                  quiche::QuicheStringPiece()));
   }
   if (FinishedReadingHeaders()) {
     sequencer()->SetUnblocked();
@@ -668,7 +671,8 @@
         VersionUsesHttp3(transport_version())
             ? flow_controller()->highest_received_byte_offset()
             : final_byte_offset;
-    OnStreamFrame(QuicStreamFrame(id(), fin, offset, QuicStringPiece()));
+    OnStreamFrame(
+        QuicStreamFrame(id(), fin, offset, quiche::QuicheStringPiece()));
   }
 }
 
@@ -794,7 +798,7 @@
   if (it == header.end()) {
     return false;
   }
-  const QuicStringPiece status(it->second);
+  const quiche::QuicheStringPiece status(it->second);
   if (status.size() != 3) {
     return false;
   }
@@ -806,7 +810,7 @@
   if (!isdigit(status[1]) || !isdigit(status[2])) {
     return false;
   }
-  return QuicTextUtils::StringToInt(status, status_code);
+  return quiche::QuicheTextUtils::StringToInt(status, status_code);
 }
 
 bool QuicSpdyStream::FinishedReadingTrailers() const {
@@ -840,7 +844,7 @@
   return true;
 }
 
-bool QuicSpdyStream::OnDataFramePayload(QuicStringPiece payload) {
+bool QuicSpdyStream::OnDataFramePayload(quiche::QuicheStringPiece payload) {
   DCHECK(VersionUsesHttp3(transport_version()));
 
   body_manager_.OnBody(payload);
@@ -926,7 +930,7 @@
   return true;
 }
 
-bool QuicSpdyStream::OnHeadersFramePayload(QuicStringPiece payload) {
+bool QuicSpdyStream::OnHeadersFramePayload(quiche::QuicheStringPiece payload) {
   DCHECK(VersionUsesHttp3(transport_version()));
   DCHECK(qpack_decoded_headers_accumulator_);
 
@@ -989,7 +993,8 @@
   return true;
 }
 
-bool QuicSpdyStream::OnPushPromiseFramePayload(QuicStringPiece payload) {
+bool QuicSpdyStream::OnPushPromiseFramePayload(
+    quiche::QuicheStringPiece payload) {
   spdy_session_->OnCompressedFrameSize(payload.length());
   return OnHeadersFramePayload(payload);
 }
@@ -1010,7 +1015,7 @@
   return true;
 }
 
-bool QuicSpdyStream::OnUnknownFramePayload(QuicStringPiece payload) {
+bool QuicSpdyStream::OnUnknownFramePayload(quiche::QuicheStringPiece payload) {
   // Ignore unknown frames, but consume frame payload.
   QUIC_DVLOG(1) << ENDPOINT << "Discarding " << payload.size()
                 << " bytes of payload of frame of unknown type.";
@@ -1058,9 +1063,9 @@
   QUIC_DLOG(INFO) << ENDPOINT << "Stream " << id()
                   << " is writing HEADERS frame header of length "
                   << headers_frame_header_length;
-  WriteOrBufferData(
-      QuicStringPiece(headers_frame_header.get(), headers_frame_header_length),
-      /* fin = */ false, /* ack_listener = */ nullptr);
+  WriteOrBufferData(quiche::QuicheStringPiece(headers_frame_header.get(),
+                                              headers_frame_header_length),
+                    /* fin = */ false, /* ack_listener = */ nullptr);
 
   QUIC_DLOG(INFO) << ENDPOINT << "Stream " << id()
                   << " is writing HEADERS frame payload of length "
diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index c4333f3..9650744 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -26,6 +26,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.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/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_framer.h"
 
 namespace quic {
@@ -121,7 +122,7 @@
       QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
 
   // Sends |data| to the peer, or buffers if it can't be sent immediately.
-  void WriteOrBufferBody(QuicStringPiece data, bool fin);
+  void WriteOrBufferBody(quiche::QuicheStringPiece data, bool fin);
 
   // Writes the trailers contained in |trailer_block| on the dedicated headers
   // stream or on this stream, depending on VersionUsesHttp3().  Trailers will
@@ -216,7 +217,7 @@
   // QpackDecodedHeadersAccumulator::Visitor implementation.
   void OnHeadersDecoded(QuicHeaderList headers,
                         bool header_list_size_limit_exceeded) override;
-  void OnHeaderDecodingError(QuicStringPiece error_message) override;
+  void OnHeaderDecodingError(quiche::QuicheStringPiece error_message) override;
 
  protected:
   // Called when the received headers are too large. By default this will
@@ -255,17 +256,17 @@
 
   // Called by HttpDecoderVisitor.
   bool OnDataFrameStart(QuicByteCount header_length);
-  bool OnDataFramePayload(QuicStringPiece payload);
+  bool OnDataFramePayload(quiche::QuicheStringPiece payload);
   bool OnDataFrameEnd();
   bool OnHeadersFrameStart(QuicByteCount header_length);
-  bool OnHeadersFramePayload(QuicStringPiece payload);
+  bool OnHeadersFramePayload(quiche::QuicheStringPiece payload);
   bool OnHeadersFrameEnd();
   bool OnPushPromiseFrameStart(QuicByteCount header_length);
   bool OnPushPromiseFramePushId(PushId push_id, QuicByteCount push_id_length);
-  bool OnPushPromiseFramePayload(QuicStringPiece payload);
+  bool OnPushPromiseFramePayload(quiche::QuicheStringPiece payload);
   bool OnPushPromiseFrameEnd();
   bool OnUnknownFrameStart(uint64_t frame_type, QuicByteCount header_length);
-  bool OnUnknownFramePayload(QuicStringPiece payload);
+  bool OnUnknownFramePayload(quiche::QuicheStringPiece payload);
   bool OnUnknownFrameEnd();
 
   // Given the interval marked by [|offset|, |offset| + |data_length|), return
diff --git a/quic/core/http/quic_spdy_stream_body_manager.cc b/quic/core/http/quic_spdy_stream_body_manager.cc
index 798f551..1e36aa7 100644
--- a/quic/core/http/quic_spdy_stream_body_manager.cc
+++ b/quic/core/http/quic_spdy_stream_body_manager.cc
@@ -7,6 +7,7 @@
 #include <algorithm>
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -27,7 +28,7 @@
   return 0;
 }
 
-void QuicSpdyStreamBodyManager::OnBody(QuicStringPiece body) {
+void QuicSpdyStreamBodyManager::OnBody(quiche::QuicheStringPiece body) {
   DCHECK(!body.empty());
 
   fragments_.push_back({body, 0});
@@ -45,7 +46,7 @@
     }
 
     Fragment& fragment = fragments_.front();
-    const QuicStringPiece body = fragment.body;
+    const quiche::QuicheStringPiece body = fragment.body;
 
     if (body.length() > remaining_bytes) {
       // Consume leading |remaining_bytes| bytes of body.
@@ -77,7 +78,7 @@
 
   size_t iov_filled = 0;
   while (iov_filled < fragments_.size() && iov_filled < iov_len) {
-    QuicStringPiece body = fragments_[iov_filled].body;
+    quiche::QuicheStringPiece body = fragments_[iov_filled].body;
     iov[iov_filled].iov_base = const_cast<char*>(body.data());
     iov[iov_filled].iov_len = body.size();
     iov_filled++;
@@ -101,7 +102,7 @@
 
   while (!fragments_.empty()) {
     Fragment& fragment = fragments_.front();
-    const QuicStringPiece body = fragment.body;
+    const quiche::QuicheStringPiece body = fragment.body;
 
     const size_t bytes_to_copy =
         std::min<size_t>(body.length(), dest_remaining);
diff --git a/quic/core/http/quic_spdy_stream_body_manager.h b/quic/core/http/quic_spdy_stream_body_manager.h
index 1942c26..ac22978 100644
--- a/quic/core/http/quic_spdy_stream_body_manager.h
+++ b/quic/core/http/quic_spdy_stream_body_manager.h
@@ -11,7 +11,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_iovec.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_macros.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 {
 
@@ -43,7 +43,7 @@
   // Called when body is received.  |body| is added to |fragments_|.  The data
   // pointed to by |body| must be kept alive until an OnBodyConsumed() or
   // ReadBody() call consumes it.  |body| must not be empty.
-  void OnBody(QuicStringPiece body);
+  void OnBody(quiche::QuicheStringPiece body);
 
   // Internally marks |num_bytes| of body consumed.  |num_bytes| might be zero.
   // Returns the number of bytes that the caller should mark consumed with the
@@ -79,7 +79,7 @@
   // consumed as soon as all of the body fragment is read.
   struct QUIC_EXPORT_PRIVATE Fragment {
     // |body| must not be empty.
-    QuicStringPiece body;
+    quiche::QuicheStringPiece body;
     // Might be zero.
     QuicByteCount trailing_non_body_byte_count;
   };
diff --git a/quic/core/http/quic_spdy_stream_body_manager_test.cc b/quic/core/http/quic_spdy_stream_body_manager_test.cc
index 10b19f1..b9e63ab 100644
--- a/quic/core/http/quic_spdy_stream_body_manager_test.cc
+++ b/quic/core/http/quic_spdy_stream_body_manager_test.cc
@@ -12,6 +12,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.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 {
 
@@ -152,7 +153,7 @@
               static_cast<size_t>(body_manager.PeekBody(&iovecs[0], iov_len)));
     for (size_t iovec_index = 0; iovec_index < iovs_filled; ++iovec_index) {
       EXPECT_EQ(frame_payloads[iovec_index],
-                QuicStringPiece(
+                quiche::QuicheStringPiece(
                     static_cast<const char*>(iovecs[iovec_index].iov_base),
                     iovecs[iovec_index].iov_len));
     }
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index efb34ac..c5dc417 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -19,9 +19,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.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/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/qpack/qpack_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_flow_controller_peer.h"
@@ -30,6 +28,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_stream_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 using spdy::kV3HighestPriority;
 using spdy::kV3LowestPriority;
@@ -168,7 +168,8 @@
 
   // Return QPACK-encoded header block without using the dynamic table.
   std::string EncodeQpackHeaders(
-      std::vector<std::pair<QuicStringPiece, QuicStringPiece>> headers) {
+      std::vector<std::pair<quiche::QuicheStringPiece,
+                            quiche::QuicheStringPiece>> headers) {
     SpdyHeaderBlock header_block;
     for (const auto& header_field : headers) {
       header_block.AppendValueOrAddHeader(header_field.first,
@@ -280,7 +281,8 @@
   // Construct HEADERS frame with QPACK-encoded |headers| without using the
   // dynamic table.
   std::string HeadersFrame(
-      std::vector<std::pair<QuicStringPiece, QuicStringPiece>> headers) {
+      std::vector<std::pair<quiche::QuicheStringPiece,
+                            quiche::QuicheStringPiece>> headers) {
     return HeadersFrame(EncodeQpackHeaders(headers));
   }
 
@@ -291,26 +293,27 @@
   }
 
   // Construct HEADERS frame with given payload.
-  std::string HeadersFrame(QuicStringPiece payload) {
+  std::string HeadersFrame(quiche::QuicheStringPiece payload) {
     std::unique_ptr<char[]> headers_buffer;
     QuicByteCount headers_frame_header_length =
         HttpEncoder::SerializeHeadersFrameHeader(payload.length(),
                                                  &headers_buffer);
-    QuicStringPiece headers_frame_header(headers_buffer.get(),
-                                         headers_frame_header_length);
-    return QuicStrCat(headers_frame_header, payload);
+    quiche::QuicheStringPiece headers_frame_header(headers_buffer.get(),
+                                                   headers_frame_header_length);
+    return quiche::QuicheStrCat(headers_frame_header, payload);
   }
 
-  std::string DataFrame(QuicStringPiece payload) {
+  std::string DataFrame(quiche::QuicheStringPiece payload) {
     std::unique_ptr<char[]> data_buffer;
     QuicByteCount data_frame_header_length =
         HttpEncoder::SerializeDataFrameHeader(payload.length(), &data_buffer);
-    QuicStringPiece data_frame_header(data_buffer.get(),
-                                      data_frame_header_length);
-    return QuicStrCat(data_frame_header, payload);
+    quiche::QuicheStringPiece data_frame_header(data_buffer.get(),
+                                                data_frame_header_length);
+    return quiche::QuicheStrCat(data_frame_header, payload);
   }
 
-  std::string UnknownFrame(uint64_t frame_type, QuicStringPiece payload) {
+  std::string UnknownFrame(uint64_t frame_type,
+                           quiche::QuicheStringPiece payload) {
     std::string frame;
     const size_t length = QuicDataWriter::GetVarInt62Len(frame_type) +
                           QuicDataWriter::GetVarInt62Len(payload.size()) +
@@ -498,7 +501,7 @@
   EXPECT_EQ(headers, stream_->header_list());
   stream_->ConsumeHeaderList();
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                        QuicStringPiece(data));
+                        quiche::QuicheStringPiece(data));
 
   EXPECT_CALL(*connection_, CloseConnection(QUIC_HTTP_DECODER_ERROR, _, _))
       .WillOnce(
@@ -530,7 +533,7 @@
   EXPECT_EQ(headers, stream_->header_list());
   stream_->ConsumeHeaderList();
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                        QuicStringPiece(data));
+                        quiche::QuicheStringPiece(data));
   stream_->OnStreamFrame(frame);
   EXPECT_EQ(QuicHeaderList(), stream_->header_list());
   EXPECT_EQ(body, stream_->data());
@@ -547,10 +550,10 @@
     stream_->ConsumeHeaderList();
     for (size_t offset = 0; offset < data.size(); offset += fragment_size) {
       size_t remaining_data = data.size() - offset;
-      QuicStringPiece fragment(data.data() + offset,
-                               std::min(fragment_size, remaining_data));
+      quiche::QuicheStringPiece fragment(
+          data.data() + offset, std::min(fragment_size, remaining_data));
       QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false,
-                            offset, QuicStringPiece(fragment));
+                            offset, quiche::QuicheStringPiece(fragment));
       stream_->OnStreamFrame(frame);
     }
     ASSERT_EQ(body, stream_->data()) << "fragment_size: " << fragment_size;
@@ -567,15 +570,15 @@
     ASSERT_EQ(headers, stream_->header_list());
     stream_->ConsumeHeaderList();
 
-    QuicStringPiece fragment1(data.data(), split_point);
+    quiche::QuicheStringPiece fragment1(data.data(), split_point);
     QuicStreamFrame frame1(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                           QuicStringPiece(fragment1));
+                           quiche::QuicheStringPiece(fragment1));
     stream_->OnStreamFrame(frame1);
 
-    QuicStringPiece fragment2(data.data() + split_point,
-                              data.size() - split_point);
+    quiche::QuicheStringPiece fragment2(data.data() + split_point,
+                                        data.size() - split_point);
     QuicStreamFrame frame2(GetNthClientInitiatedBidirectionalId(0), false,
-                           split_point, QuicStringPiece(fragment2));
+                           split_point, quiche::QuicheStringPiece(fragment2));
     stream_->OnStreamFrame(frame2);
 
     ASSERT_EQ(body, stream_->data()) << "split_point: " << split_point;
@@ -590,7 +593,7 @@
 
   ProcessHeaders(false, headers_);
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                        QuicStringPiece(data));
+                        quiche::QuicheStringPiece(data));
   stream_->OnStreamFrame(frame);
   stream_->ConsumeHeaderList();
 
@@ -613,7 +616,7 @@
 
   ProcessHeaders(false, headers_);
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                        QuicStringPiece(data));
+                        quiche::QuicheStringPiece(data));
   stream_->OnStreamFrame(frame);
   stream_->ConsumeHeaderList();
   char buffer[2048];
@@ -637,7 +640,7 @@
 
   ProcessHeaders(false, headers_);
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                        QuicStringPiece(data));
+                        quiche::QuicheStringPiece(data));
   stream_->OnStreamFrame(frame);
   stream_->ConsumeHeaderList();
 
@@ -660,9 +663,9 @@
 
   ProcessHeaders(false, headers_);
   QuicStreamFrame frame1(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                         QuicStringPiece(data1));
+                         quiche::QuicheStringPiece(data1));
   QuicStreamFrame frame2(GetNthClientInitiatedBidirectionalId(0), false,
-                         data1.length(), QuicStringPiece(data2));
+                         data1.length(), quiche::QuicheStringPiece(data2));
   stream_->OnStreamFrame(frame1);
   stream_->OnStreamFrame(frame2);
   stream_->ConsumeHeaderList();
@@ -680,7 +683,7 @@
 
   ProcessHeaders(false, headers_);
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                        QuicStringPiece(data));
+                        quiche::QuicheStringPiece(data));
   stream_->OnStreamFrame(frame);
   stream_->ConsumeHeaderList();
 
@@ -704,7 +707,7 @@
 
   ProcessHeaders(false, headers_);
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                        QuicStringPiece(data));
+                        quiche::QuicheStringPiece(data));
   stream_->OnStreamFrame(frame);
   stream_->ConsumeHeaderList();
 
@@ -795,7 +798,7 @@
   ProcessHeaders(false, headers_);
 
   QuicStreamFrame frame1(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                         QuicStringPiece(data));
+                         quiche::QuicheStringPiece(data));
   stream_->OnStreamFrame(frame1);
   EXPECT_EQ(
       kWindow - (kWindow / 3) - header_length,
@@ -805,7 +808,8 @@
   // half full. This should all be buffered, decreasing the receive window but
   // not sending WINDOW_UPDATE.
   QuicStreamFrame frame2(GetNthClientInitiatedBidirectionalId(0), false,
-                         kWindow / 3 + header_length, QuicStringPiece(data));
+                         kWindow / 3 + header_length,
+                         quiche::QuicheStringPiece(data));
   stream_->OnStreamFrame(frame2);
   EXPECT_EQ(
       kWindow - (2 * kWindow / 3) - 2 * header_length,
@@ -846,7 +850,7 @@
   stream_->ConsumeHeaderList();
 
   QuicStreamFrame frame1(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                         QuicStringPiece(data));
+                         quiche::QuicheStringPiece(data));
   stream_->OnStreamFrame(frame1);
   EXPECT_EQ(
       kWindow - (kWindow / 3) - header_length,
@@ -857,7 +861,8 @@
   // offset and send a WINDOW_UPDATE. The result will be again an available
   // window of kWindow bytes.
   QuicStreamFrame frame2(GetNthClientInitiatedBidirectionalId(0), false,
-                         kWindow / 3 + header_length, QuicStringPiece(data));
+                         kWindow / 3 + header_length,
+                         quiche::QuicheStringPiece(data));
   EXPECT_CALL(*connection_, SendControlFrame(_));
   stream_->OnStreamFrame(frame2);
   EXPECT_EQ(kWindow, QuicFlowControllerPeer::ReceiveWindowSize(
@@ -921,10 +926,10 @@
   }
 
   QuicStreamFrame frame1(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                         QuicStringPiece(data));
+                         quiche::QuicheStringPiece(data));
   stream_->OnStreamFrame(frame1);
   QuicStreamFrame frame2(GetNthClientInitiatedBidirectionalId(1), false, 0,
-                         QuicStringPiece(data));
+                         quiche::QuicheStringPiece(data));
   stream2_->OnStreamFrame(frame2);
 
   // Now receive a further single byte on one stream - again this does not
@@ -932,7 +937,8 @@
   // is over half full and thus a connection WINDOW_UPDATE is sent.
   EXPECT_CALL(*connection_, SendControlFrame(_));
   QuicStreamFrame frame3(GetNthClientInitiatedBidirectionalId(0), false,
-                         body.length() + header_length, QuicStringPiece(data2));
+                         body.length() + header_length,
+                         quiche::QuicheStringPiece(data2));
   stream_->OnStreamFrame(frame3);
 }
 
@@ -954,7 +960,7 @@
   std::string body(kWindow + 1, 'a');
   std::string data = UsesHttp3() ? DataFrame(body) : body;
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                        QuicStringPiece(data));
+                        quiche::QuicheStringPiece(data));
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, _, _));
   stream_->OnStreamFrame(frame);
@@ -994,7 +1000,7 @@
 
   EXPECT_LT(data.size(), kStreamWindow);
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
-                        QuicStringPiece(data));
+                        quiche::QuicheStringPiece(data));
 
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, _, _));
@@ -1094,7 +1100,7 @@
   trailers_block["key2"] = "value2";
   trailers_block["key3"] = "value3";
   trailers_block[kFinalOffsetHeaderKey] =
-      QuicTextUtils::Uint64ToString(data.size());
+      quiche::QuicheTextUtils::Uint64ToString(data.size());
 
   QuicHeaderList trailers = ProcessHeaders(true, trailers_block);
 
@@ -1343,7 +1349,7 @@
   // on the headers stream.
   if (!UsesHttp3()) {
     expected_trailers[kFinalOffsetHeaderKey] =
-        QuicTextUtils::Uint64ToString(body.length() + header_length);
+        quiche::QuicheTextUtils::Uint64ToString(body.length() + header_length);
   }
 
   EXPECT_CALL(*stream_, WriteHeadersMock(true));
@@ -1786,7 +1792,8 @@
   std::string trailers =
       HeadersFrame({std::make_pair("custom-key", "custom-value")});
 
-  std::string stream_frame_payload = QuicStrCat(headers, data, trailers);
+  std::string stream_frame_payload =
+      quiche::QuicheStrCat(headers, data, trailers);
   QuicStreamFrame frame(stream_->id(), false, 0, stream_frame_payload);
   stream_->OnStreamFrame(frame);
 
@@ -1820,7 +1827,8 @@
   std::string trailers = HeadersFrame(trailers_block);
 
   // Feed all three HTTP/3 frames in a single stream frame.
-  std::string stream_frame_payload = QuicStrCat(headers, data, trailers);
+  std::string stream_frame_payload =
+      quiche::QuicheStrCat(headers, data, trailers);
   QuicStreamFrame frame(stream_->id(), false, 0, stream_frame_payload);
   stream_->OnStreamFrame(frame);
 
@@ -1838,7 +1846,7 @@
   vec.iov_base = buffer;
   vec.iov_len = QUIC_ARRAYSIZE(buffer);
   size_t bytes_read = stream_->Readv(&vec, 1);
-  EXPECT_EQ(kDataFramePayload, QuicStringPiece(buffer, bytes_read));
+  EXPECT_EQ(kDataFramePayload, quiche::QuicheStringPiece(buffer, bytes_read));
 
   EXPECT_FALSE(stream_->HasBytesToRead());
 }
@@ -1858,10 +1866,10 @@
 
   // Random bad headers.
   std::string headers =
-      HeadersFrame(QuicTextUtils::HexDecode("00002a94e7036261"));
+      HeadersFrame(quiche::QuicheTextUtils::HexDecode("00002a94e7036261"));
   std::string data = DataFrame(kDataFramePayload);
 
-  std::string stream_frame_payload = QuicStrCat(headers, data);
+  std::string stream_frame_payload = quiche::QuicheStrCat(headers, data);
   QuicStreamFrame frame(stream_->id(), false, 0, stream_frame_payload);
 
   EXPECT_CALL(
@@ -1924,7 +1932,8 @@
 
   // Invalid headers: Required Insert Count is zero, but the header block
   // contains a dynamic table reference.
-  std::string headers = HeadersFrame(QuicTextUtils::HexDecode("000080"));
+  std::string headers =
+      HeadersFrame(quiche::QuicheTextUtils::HexDecode("000080"));
   QuicStreamFrame frame(stream_->id(), false, 0, headers);
   stream_->OnStreamFrame(frame);
 }
@@ -1948,7 +1957,8 @@
   session_->qpack_decoder()->OnInsertWithoutNameReference("foo", "bar");
 
   // HEADERS frame referencing first dynamic table entry.
-  std::string headers = HeadersFrame(QuicTextUtils::HexDecode("020080"));
+  std::string headers =
+      HeadersFrame(quiche::QuicheTextUtils::HexDecode("020080"));
   stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, 0, headers));
 
   // Headers can be decoded immediately.
@@ -1970,7 +1980,8 @@
   session_->qpack_decoder()->OnInsertWithoutNameReference("trailing", "foobar");
 
   // Trailing HEADERS frame referencing second dynamic table entry.
-  std::string trailers = HeadersFrame(QuicTextUtils::HexDecode("030080"));
+  std::string trailers =
+      HeadersFrame(quiche::QuicheTextUtils::HexDecode("030080"));
   stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), true, /* offset = */
                                          headers.length() + data.length(),
                                          trailers));
@@ -1994,7 +2005,8 @@
   session_->qpack_decoder()->OnSetDynamicTableCapacity(1024);
 
   // HEADERS frame referencing first dynamic table entry.
-  std::string headers = HeadersFrame(QuicTextUtils::HexDecode("020080"));
+  std::string headers =
+      HeadersFrame(quiche::QuicheTextUtils::HexDecode("020080"));
   stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, 0, headers));
 
   // Decoding is blocked because dynamic table entry has not been received yet.
@@ -2021,7 +2033,8 @@
   EXPECT_EQ(kDataFramePayload, stream_->data());
 
   // Trailing HEADERS frame referencing second dynamic table entry.
-  std::string trailers = HeadersFrame(QuicTextUtils::HexDecode("030080"));
+  std::string trailers =
+      HeadersFrame(quiche::QuicheTextUtils::HexDecode("030080"));
   stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), true, /* offset = */
                                          headers.length() + data.length(),
                                          trailers));
@@ -2051,7 +2064,8 @@
 
   // HEADERS frame only referencing entry with absolute index 0 but with
   // Required Insert Count = 2, which is incorrect.
-  std::string headers = HeadersFrame(QuicTextUtils::HexDecode("030081"));
+  std::string headers =
+      HeadersFrame(quiche::QuicheTextUtils::HexDecode("030081"));
   stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, 0, headers));
 
   // Even though entire header block is received and every referenced entry is
@@ -2083,7 +2097,8 @@
   session_->qpack_decoder()->OnSetDynamicTableCapacity(1024);
 
   // Relative index 2 is invalid because it is larger than or equal to the Base.
-  std::string headers = HeadersFrame(QuicTextUtils::HexDecode("020082"));
+  std::string headers =
+      HeadersFrame(quiche::QuicheTextUtils::HexDecode("020082"));
   stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, 0, headers));
 
   // Decoding is blocked.
@@ -2111,7 +2126,8 @@
   session_->qpack_decoder()->OnSetDynamicTableCapacity(1024);
 
   // HEADERS frame referencing first dynamic table entry.
-  std::string headers = HeadersFrame(QuicTextUtils::HexDecode("020080"));
+  std::string headers =
+      HeadersFrame(quiche::QuicheTextUtils::HexDecode("020080"));
   stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, 0, headers));
 
   // Decoding is blocked because dynamic table entry has not been received yet.
@@ -2139,7 +2155,8 @@
 
   // Trailing HEADERS frame only referencing entry with absolute index 0 but
   // with Required Insert Count = 2, which is incorrect.
-  std::string trailers = HeadersFrame(QuicTextUtils::HexDecode("030081"));
+  std::string trailers =
+      HeadersFrame(quiche::QuicheTextUtils::HexDecode("030081"));
   stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), true, /* offset = */
                                          headers.length() + data.length(),
                                          trailers));
@@ -2168,7 +2185,7 @@
 
   // Create QuicStreamFrame with |payload|
   // and pass it to stream_->OnStreamFrame().
-  void OnStreamFrame(QuicStringPiece payload) {
+  void OnStreamFrame(quiche::QuicheStringPiece payload) {
     QuicStreamFrame frame(stream_->id(), /* fin = */ false, offset_, payload);
     stream_->OnStreamFrame(frame);
     offset_ += payload.size();
@@ -2221,11 +2238,12 @@
 
   // All HEADERS frame bytes are consumed even if the frame is not received
   // completely.
-  OnStreamFrame(QuicStringPiece(headers).substr(0, headers.size() - 1));
+  OnStreamFrame(
+      quiche::QuicheStringPiece(headers).substr(0, headers.size() - 1));
   EXPECT_EQ(headers.size() - 1, NewlyConsumedBytes());
 
   // The rest of the HEADERS frame is also consumed immediately.
-  OnStreamFrame(QuicStringPiece(headers).substr(headers.size() - 1));
+  OnStreamFrame(quiche::QuicheStringPiece(headers).substr(headers.size() - 1));
   EXPECT_EQ(1u, NewlyConsumedBytes());
 
   // Verify headers.
@@ -2233,7 +2251,7 @@
   stream_->ConsumeHeaderList();
 
   // DATA frame.
-  QuicStringPiece data_payload(kDataFramePayload);
+  quiche::QuicheStringPiece data_payload(kDataFramePayload);
   std::string data_frame = DataFrame(data_payload);
   QuicByteCount data_frame_header_length =
       data_frame.size() - data_payload.size();
@@ -2252,7 +2270,8 @@
       HeadersFrame({std::make_pair("custom-key", "custom-value")});
 
   // No bytes are consumed, because last byte of DATA payload is still buffered.
-  OnStreamFrame(QuicStringPiece(trailers).substr(0, trailers.size() - 1));
+  OnStreamFrame(
+      quiche::QuicheStringPiece(trailers).substr(0, trailers.size() - 1));
   EXPECT_EQ(0u, NewlyConsumedBytes());
 
   // Reading last byte of DATA payload triggers consumption of all data received
@@ -2261,7 +2280,8 @@
   EXPECT_EQ(1 + trailers.size() - 1, NewlyConsumedBytes());
 
   // Last byte of trailers is immediately consumed.
-  OnStreamFrame(QuicStringPiece(trailers).substr(trailers.size() - 1));
+  OnStreamFrame(
+      quiche::QuicheStringPiece(trailers).substr(trailers.size() - 1));
   EXPECT_EQ(1u, NewlyConsumedBytes());
 
   // Verify trailers.
@@ -2285,11 +2305,12 @@
 
   // All HEADERS frame bytes are consumed even if the frame is not received
   // completely.
-  OnStreamFrame(QuicStringPiece(headers).substr(0, headers.size() - 1));
+  OnStreamFrame(
+      quiche::QuicheStringPiece(headers).substr(0, headers.size() - 1));
   EXPECT_EQ(headers.size() - 1, NewlyConsumedBytes());
 
   // The rest of the HEADERS frame is also consumed immediately.
-  OnStreamFrame(QuicStringPiece(headers).substr(headers.size() - 1));
+  OnStreamFrame(quiche::QuicheStringPiece(headers).substr(headers.size() - 1));
   EXPECT_EQ(1u, NewlyConsumedBytes());
 
   // Verify headers.
@@ -2303,7 +2324,7 @@
   EXPECT_EQ(unknown_frame2.size(), NewlyConsumedBytes());
 
   // DATA frame.
-  QuicStringPiece data_payload(kDataFramePayload);
+  quiche::QuicheStringPiece data_payload(kDataFramePayload);
   std::string data_frame = DataFrame(data_payload);
   QuicByteCount data_frame_header_length =
       data_frame.size() - data_payload.size();
@@ -2328,7 +2349,8 @@
       HeadersFrame({std::make_pair("custom-key", "custom-value")});
 
   // No bytes are consumed, because last byte of DATA payload is still buffered.
-  OnStreamFrame(QuicStringPiece(trailers).substr(0, trailers.size() - 1));
+  OnStreamFrame(
+      quiche::QuicheStringPiece(trailers).substr(0, trailers.size() - 1));
   EXPECT_EQ(0u, NewlyConsumedBytes());
 
   // Reading last byte of DATA payload triggers consumption of all data received
@@ -2338,7 +2360,8 @@
             NewlyConsumedBytes());
 
   // Last byte of trailers is immediately consumed.
-  OnStreamFrame(QuicStringPiece(trailers).substr(trailers.size() - 1));
+  OnStreamFrame(
+      quiche::QuicheStringPiece(trailers).substr(trailers.size() - 1));
   EXPECT_EQ(1u, NewlyConsumedBytes());
 
   // Verify trailers.
@@ -2508,7 +2531,7 @@
   Initialize(kShouldProcessData);
 
   // SETTINGS frame with empty payload.
-  std::string settings = QuicTextUtils::HexDecode("0400");
+  std::string settings = quiche::QuicheTextUtils::HexDecode("0400");
 
   // HEADERS frame.
   // Since it arrives after a SETTINGS frame, it should never be read.
@@ -2516,7 +2539,7 @@
 
   // Combine the two frames to make sure they are processed in a single
   // QuicSpdyStream::OnDataAvailable() call.
-  std::string frames = QuicStrCat(settings, headers);
+  std::string frames = quiche::QuicheStrCat(settings, headers);
 
   EXPECT_EQ(0u, stream_->sequencer()->NumBytesConsumed());
 
diff --git a/quic/core/http/spdy_server_push_utils.cc b/quic/core/http/spdy_server_push_utils.cc
index 02c963c..4ba3289 100644
--- a/quic/core/http/spdy_server_push_utils.cc
+++ b/quic/core/http/spdy_server_push_utils.cc
@@ -5,6 +5,7 @@
 #include "net/third_party/quiche/src/quic/core/http/spdy_server_push_utils.h"
 
 #include "url/gurl.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 using spdy::SpdyHeaderBlock;
 
@@ -39,7 +40,7 @@
   if (it == headers.end() || it->second.empty()) {
     return std::string();
   }
-  QuicStringPiece scheme = it->second;
+  quiche::QuicheStringPiece scheme = it->second;
 
   // RFC 7540, Section 8.2: The server MUST include a value in the
   // ":authority" pseudo-header field for which the server is authoritative
@@ -48,7 +49,7 @@
   if (it == headers.end() || it->second.empty()) {
     return std::string();
   }
-  QuicStringPiece authority = it->second;
+  quiche::QuicheStringPiece authority = it->second;
 
   // RFC 7540, Section 8.1.2.3 requires that the ":path" pseudo-header MUST
   // NOT be empty for "http" or "https" URIs;
@@ -59,7 +60,7 @@
   if (it == headers.end()) {
     return std::string();
   }
-  QuicStringPiece path = it->second;
+  quiche::QuicheStringPiece path = it->second;
 
   return GetPushPromiseUrl(scheme, authority, path);
 }
@@ -79,9 +80,10 @@
 }
 
 // static
-std::string SpdyServerPushUtils::GetPushPromiseUrl(QuicStringPiece scheme,
-                                                   QuicStringPiece authority,
-                                                   QuicStringPiece path) {
+std::string SpdyServerPushUtils::GetPushPromiseUrl(
+    quiche::QuicheStringPiece scheme,
+    quiche::QuicheStringPiece authority,
+    quiche::QuicheStringPiece path) {
   // RFC 7540, Section 8.1.2.3: The ":path" pseudo-header field includes the
   // path and query parts of the target URI (the "path-absolute" production
   // and optionally a '?' character followed by the "query" production (see
diff --git a/quic/core/http/spdy_server_push_utils.h b/quic/core/http/spdy_server_push_utils.h
index 3d11b65..16e1ac6 100644
--- a/quic/core/http/spdy_server_push_utils.h
+++ b/quic/core/http/spdy_server_push_utils.h
@@ -6,7 +6,7 @@
 #define QUICHE_QUIC_CORE_HTTP_SPDY_SERVER_PUSH_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/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 {
@@ -33,9 +33,9 @@
   // Returns a canonical, valid URL for a PUSH_PROMISE with the specified
   // ":scheme", ":authority", and ":path" header fields, or an empty
   // string if the resulting URL is not valid or supported.
-  static std::string GetPushPromiseUrl(QuicStringPiece scheme,
-                                       QuicStringPiece authority,
-                                       QuicStringPiece path);
+  static std::string GetPushPromiseUrl(quiche::QuicheStringPiece scheme,
+                                       quiche::QuicheStringPiece authority,
+                                       quiche::QuicheStringPiece path);
 };
 
 }  // namespace quic
diff --git a/quic/core/http/spdy_server_push_utils_test.cc b/quic/core/http/spdy_server_push_utils_test.cc
index 0f6ec8a..aa35550 100644
--- a/quic/core/http/spdy_server_push_utils_test.cc
+++ b/quic/core/http/spdy_server_push_utils_test.cc
@@ -8,9 +8,7 @@
 #include <string>
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.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"
 
 using spdy::SpdyHeaderBlock;
 
diff --git a/quic/core/http/spdy_utils.cc b/quic/core/http/spdy_utils.cc
index 56d3b19..98d22cb 100644
--- a/quic/core/http/spdy_utils.cc
+++ b/quic/core/http/spdy_utils.cc
@@ -12,9 +12,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_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_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"
+#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;
@@ -29,12 +29,12 @@
     return false;
   } else {
     // Check whether multiple values are consistent.
-    QuicStringPiece content_length_header = it->second;
-    std::vector<QuicStringPiece> values =
-        QuicTextUtils::Split(content_length_header, '\0');
-    for (const QuicStringPiece& value : values) {
+    quiche::QuicheStringPiece content_length_header = it->second;
+    std::vector<quiche::QuicheStringPiece> values =
+        quiche::QuicheTextUtils::Split(content_length_header, '\0');
+    for (const quiche::QuicheStringPiece& value : values) {
       uint64_t new_value;
-      if (!QuicTextUtils::StringToUint64(value, &new_value)) {
+      if (!quiche::QuicheTextUtils::StringToUint64(value, &new_value)) {
         QUIC_DLOG(ERROR)
             << "Content length was either unparseable or negative.";
         return false;
@@ -65,7 +65,7 @@
       return false;
     }
 
-    if (QuicTextUtils::ContainsUpperCase(name)) {
+    if (quiche::QuicheTextUtils::ContainsUpperCase(name)) {
       QUIC_DLOG(ERROR) << "Malformed header: Header name " << name
                        << " contains upper-case characters.";
       return false;
@@ -95,7 +95,7 @@
     // response body bytes expected.
     if (expect_final_byte_offset && !found_final_byte_offset &&
         name == kFinalOffsetHeaderKey &&
-        QuicTextUtils::StringToSizeT(p.second, final_byte_offset)) {
+        quiche::QuicheTextUtils::StringToSizeT(p.second, final_byte_offset)) {
       found_final_byte_offset = true;
       continue;
     }
@@ -107,7 +107,7 @@
       return false;
     }
 
-    if (QuicTextUtils::ContainsUpperCase(name)) {
+    if (quiche::QuicheTextUtils::ContainsUpperCase(name)) {
       QUIC_DLOG(ERROR) << "Malformed header: Header name " << name
                        << " contains upper-case characters.";
       return false;
@@ -162,7 +162,7 @@
     RETURN_STRING_LITERAL(SETTINGS_MAX_HEADER_LIST_SIZE);
     RETURN_STRING_LITERAL(SETTINGS_QPACK_BLOCKED_STREAMS);
   }
-  return QuicStrCat("UNSUPPORTED_SETTINGS_TYPE(", identifier, ")");
+  return quiche::QuicheStrCat("UNSUPPORTED_SETTINGS_TYPE(", identifier, ")");
 }
 
 #undef RETURN_STRING_LITERAL  // undef for jumbo builds
diff --git a/quic/core/http/spdy_utils_test.cc b/quic/core/http/spdy_utils_test.cc
index 2ebf0cf..898d5f7 100644
--- a/quic/core/http/spdy_utils_test.cc
+++ b/quic/core/http/spdy_utils_test.cc
@@ -7,9 +7,9 @@
 
 #include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.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/common/platform/api/quiche_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 using spdy::SpdyHeaderBlock;
 using testing::Pair;
@@ -66,13 +66,14 @@
   SpdyHeaderBlock block;
   ASSERT_TRUE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
-  EXPECT_THAT(block,
-              UnorderedElementsAre(
-                  Pair("cookie", " part 1; part 2 ; part3;  fin!"),
-                  Pair("passed-through", QuicStringPiece("foo\0baz", 7)),
-                  Pair("joined", QuicStringPiece("value 1\0value 2", 15)),
-                  Pair("empty", ""),
-                  Pair("empty-joined", QuicStringPiece("\0foo\0\0", 6))));
+  EXPECT_THAT(
+      block,
+      UnorderedElementsAre(
+          Pair("cookie", " part 1; part 2 ; part3;  fin!"),
+          Pair("passed-through", quiche::QuicheStringPiece("foo\0baz", 7)),
+          Pair("joined", quiche::QuicheStringPiece("value 1\0value 2", 15)),
+          Pair("empty", ""),
+          Pair("empty-joined", quiche::QuicheStringPiece("\0foo\0\0", 6))));
   EXPECT_EQ(-1, content_length);
 }
 
@@ -103,10 +104,11 @@
   SpdyHeaderBlock block;
   ASSERT_TRUE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
-  EXPECT_THAT(block, UnorderedElementsAre(
-                         Pair("foo", "foovalue"), Pair("bar", "barvalue"),
-                         Pair("content-length", QuicStringPiece("9\09", 3)),
-                         Pair("baz", "")));
+  EXPECT_THAT(block,
+              UnorderedElementsAre(
+                  Pair("foo", "foovalue"), Pair("bar", "barvalue"),
+                  Pair("content-length", quiche::QuicheStringPiece("9\09", 3)),
+                  Pair("baz", "")));
   EXPECT_EQ(9, content_length);
 }
 
@@ -133,7 +135,8 @@
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
   EXPECT_THAT(block, UnorderedElementsAre(
                          Pair("foo", "foovalue"), Pair("bar", "barvalue"),
-                         Pair("content-length", QuicStringPiece("9000000000")),
+                         Pair("content-length",
+                              quiche::QuicheStringPiece("9000000000")),
                          Pair("baz", "")));
   EXPECT_EQ(9000000000, content_length);
 }
@@ -148,10 +151,11 @@
   SpdyHeaderBlock block;
   ASSERT_TRUE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
-  EXPECT_THAT(block, UnorderedElementsAre(
-                         Pair("foo", QuicStringPiece("foovalue\0boo", 12)),
-                         Pair("bar", "barvalue"),
-                         Pair("baz", QuicStringPiece("\0buzz", 5))));
+  EXPECT_THAT(block,
+              UnorderedElementsAre(
+                  Pair("foo", quiche::QuicheStringPiece("foovalue\0boo", 12)),
+                  Pair("bar", "barvalue"),
+                  Pair("baz", quiche::QuicheStringPiece("\0buzz", 5))));
   EXPECT_EQ(-1, content_length);
 }
 
@@ -163,9 +167,9 @@
   SpdyHeaderBlock block;
   ASSERT_TRUE(
       SpdyUtils::CopyAndValidateHeaders(*headers, &content_length, &block));
-  EXPECT_THAT(
-      block, UnorderedElementsAre(Pair(
-                 "set-cookie", QuicStringPiece("value1\0value2\0value3", 20))));
+  EXPECT_THAT(block, UnorderedElementsAre(Pair(
+                         "set-cookie", quiche::QuicheStringPiece(
+                                           "value1\0value2\0value3", 20))));
   EXPECT_EQ(-1, content_length);
 }
 
@@ -307,7 +311,7 @@
       block,
       UnorderedElementsAre(
           Pair("key",
-               QuicStringPiece(
+               quiche::QuicheStringPiece(
                    "value0\0value1\0\0\0value2\0\0non_contiguous_duplicate",
                    48)),
           Pair("other_key", "value")));