diff --git a/quic/core/qpack/fuzzer/qpack_decoder_fuzzer.cc b/quic/core/qpack/fuzzer/qpack_decoder_fuzzer.cc
index 162f88a..d5afa99 100644
--- a/quic/core/qpack/fuzzer/qpack_decoder_fuzzer.cc
+++ b/quic/core/qpack/fuzzer/qpack_decoder_fuzzer.cc
@@ -9,9 +9,9 @@
 
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_decoder.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_fuzzed_data_provider.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_decoder_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -30,7 +30,8 @@
   ErrorDelegate(bool* error_detected) : error_detected_(error_detected) {}
   ~ErrorDelegate() override = default;
 
-  void OnEncoderStreamError(QuicStringPiece /*error_message*/) override {
+  void OnEncoderStreamError(
+      quiche::QuicheStringPiece /*error_message*/) override {
     *error_detected_ = true;
   }
 
@@ -50,8 +51,8 @@
         error_detected_(error_detected) {}
   ~HeadersHandler() override = default;
 
-  void OnHeaderDecoded(QuicStringPiece /*name*/,
-                       QuicStringPiece /*value*/) override {}
+  void OnHeaderDecoded(quiche::QuicheStringPiece /*name*/,
+                       quiche::QuicheStringPiece /*value*/) override {}
 
   // Remove DecoderAndHandler from |*processing_decoders|.
   void OnDecodingCompleted() override {
@@ -60,7 +61,8 @@
     CHECK_EQ(1u, result);
   }
 
-  void OnDecodingErrorDetected(QuicStringPiece /*error_message*/) override {
+  void OnDecodingErrorDetected(
+      quiche::QuicheStringPiece /*error_message*/) override {
     *error_detected_ = true;
   }
 
diff --git a/quic/core/qpack/fuzzer/qpack_encoder_stream_receiver_fuzzer.cc b/quic/core/qpack/fuzzer/qpack_encoder_stream_receiver_fuzzer.cc
index 9b5fe11..78467a8 100644
--- a/quic/core/qpack/fuzzer/qpack_encoder_stream_receiver_fuzzer.cc
+++ b/quic/core/qpack/fuzzer/qpack_encoder_stream_receiver_fuzzer.cc
@@ -9,7 +9,7 @@
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_fuzzed_data_provider.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -24,12 +24,14 @@
 
   void OnInsertWithNameReference(bool /*is_static*/,
                                  uint64_t /*name_index*/,
-                                 QuicStringPiece /*value*/) override {}
-  void OnInsertWithoutNameReference(QuicStringPiece /*name*/,
-                                    QuicStringPiece /*value*/) override {}
+                                 quiche::QuicheStringPiece /*value*/) override {
+  }
+  void OnInsertWithoutNameReference(
+      quiche::QuicheStringPiece /*name*/,
+      quiche::QuicheStringPiece /*value*/) override {}
   void OnDuplicate(uint64_t /*index*/) override {}
   void OnSetDynamicTableCapacity(uint64_t /*capacity*/) override {}
-  void OnErrorDetected(QuicStringPiece /*error_message*/) override {
+  void OnErrorDetected(quiche::QuicheStringPiece /*error_message*/) override {
     error_detected_ = true;
   }
 
diff --git a/quic/core/qpack/fuzzer/qpack_encoder_stream_sender_fuzzer.cc b/quic/core/qpack/fuzzer/qpack_encoder_stream_sender_fuzzer.cc
index 7efaf88..d3e226c 100644
--- a/quic/core/qpack/fuzzer/qpack_encoder_stream_sender_fuzzer.cc
+++ b/quic/core/qpack/fuzzer/qpack_encoder_stream_sender_fuzzer.cc
@@ -9,7 +9,6 @@
 
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_encoder_stream_sender.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_fuzzed_data_provider.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_encoder_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.h"
 
diff --git a/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc b/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
index 018bf09..8c94f1e 100644
--- a/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
+++ b/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
@@ -18,6 +18,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_fuzzed_data_provider.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_decoder_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_encoder_peer.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 {
@@ -63,7 +64,8 @@
    public:
     ~CrashingDecoderStreamErrorDelegate() override = default;
 
-    void OnDecoderStreamError(QuicStringPiece error_message) override {
+    void OnDecoderStreamError(
+        quiche::QuicheStringPiece error_message) override {
       CHECK(false) << error_message;
     }
   };
@@ -90,7 +92,7 @@
     virtual void OnHeaderBlockStart(QuicStreamId stream_id) = 0;
     // Called when part or all of a header block is transmitted.
     virtual void OnHeaderBlockFragment(QuicStreamId stream_id,
-                                       QuicStringPiece data) = 0;
+                                       quiche::QuicheStringPiece data) = 0;
     // Called when transmission of a header block is complete.
     virtual void OnHeaderBlockEnd(QuicStreamId stream_id) = 0;
   };
@@ -203,16 +205,19 @@
 
     size_t RemainingLength() const { return data_.length() - offset_; }
 
-    QuicStringPiece Consume(size_t length) {
+    quiche::QuicheStringPiece Consume(size_t length) {
       DCHECK_NE(0u, length);
       DCHECK_LE(length, RemainingLength());
 
-      QuicStringPiece consumed = QuicStringPiece(&data_[offset_], length);
+      quiche::QuicheStringPiece consumed =
+          quiche::QuicheStringPiece(&data_[offset_], length);
       offset_ += length;
       return consumed;
     }
 
-    QuicStringPiece ConsumeRemaining() { return Consume(RemainingLength()); }
+    quiche::QuicheStringPiece ConsumeRemaining() {
+      return Consume(RemainingLength());
+    }
 
    private:
     // Complete header block.
@@ -274,11 +279,11 @@
     visitor_->OnHeaderBlockDecoded(stream_id_);
   }
 
-  void OnHeaderDecodingError(QuicStringPiece error_message) override {
+  void OnHeaderDecodingError(quiche::QuicheStringPiece error_message) override {
     CHECK(false) << error_message;
   }
 
-  void Decode(QuicStringPiece data) { accumulator_.Decode(data); }
+  void Decode(quiche::QuicheStringPiece data) { accumulator_.Decode(data); }
 
   void EndHeaderBlock() { accumulator_.EndHeaderBlock(); }
 
@@ -357,7 +362,7 @@
   }
 
   void OnHeaderBlockFragment(QuicStreamId stream_id,
-                             QuicStringPiece data) override {
+                             quiche::QuicheStringPiece data) override {
     auto it = verifying_decoders_.find(stream_id);
     CHECK(it != verifying_decoders_.end());
     it->second->Decode(data);
@@ -376,7 +381,8 @@
    public:
     ~CrashingEncoderStreamErrorDelegate() override = default;
 
-    void OnEncoderStreamError(QuicStringPiece error_message) override {
+    void OnEncoderStreamError(
+        quiche::QuicheStringPiece error_message) override {
       CHECK(false) << error_message;
     }
   };
@@ -406,7 +412,7 @@
   ~DelayedStreamDataTransmitter() { CHECK(stream_data.empty()); }
 
   // QpackStreamSenderDelegate implementation.
-  void WriteStreamData(QuicStringPiece data) override {
+  void WriteStreamData(quiche::QuicheStringPiece data) override {
     stream_data.push(std::string(data.data(), data.size()));
   }
 
diff --git a/quic/core/qpack/qpack_decoded_headers_accumulator.cc b/quic/core/qpack/qpack_decoded_headers_accumulator.cc
index b1f8012..7aa0f11 100644
--- a/quic/core/qpack/qpack_decoded_headers_accumulator.cc
+++ b/quic/core/qpack/qpack_decoded_headers_accumulator.cc
@@ -5,6 +5,7 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_decoded_headers_accumulator.h"
 
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_decoder.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -31,8 +32,9 @@
   quic_header_list_.OnHeaderBlockStart();
 }
 
-void QpackDecodedHeadersAccumulator::OnHeaderDecoded(QuicStringPiece name,
-                                                     QuicStringPiece value) {
+void QpackDecodedHeadersAccumulator::OnHeaderDecoded(
+    quiche::QuicheStringPiece name,
+    quiche::QuicheStringPiece value) {
   DCHECK(!error_detected_);
 
   uncompressed_header_bytes_without_overhead_ += name.size() + value.size();
@@ -67,7 +69,7 @@
 }
 
 void QpackDecodedHeadersAccumulator::OnDecodingErrorDetected(
-    QuicStringPiece error_message) {
+    quiche::QuicheStringPiece error_message) {
   DCHECK(!error_detected_);
   DCHECK(!headers_decoded_);
 
@@ -76,7 +78,7 @@
   visitor_->OnHeaderDecodingError(error_message);
 }
 
-void QpackDecodedHeadersAccumulator::Decode(QuicStringPiece data) {
+void QpackDecodedHeadersAccumulator::Decode(quiche::QuicheStringPiece data) {
   DCHECK(!error_detected_);
 
   compressed_header_bytes_ += data.size();
diff --git a/quic/core/qpack/qpack_decoded_headers_accumulator.h b/quic/core/qpack/qpack_decoded_headers_accumulator.h
index 96b527e..334fcbd 100644
--- a/quic/core/qpack/qpack_decoded_headers_accumulator.h
+++ b/quic/core/qpack/qpack_decoded_headers_accumulator.h
@@ -12,7 +12,7 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_progressive_decoder.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 {
 
@@ -45,7 +45,8 @@
                                   bool header_list_size_limit_exceeded) = 0;
 
     // Called when an error has occurred.
-    virtual void OnHeaderDecodingError(QuicStringPiece error_message) = 0;
+    virtual void OnHeaderDecodingError(
+        quiche::QuicheStringPiece error_message) = 0;
   };
 
   QpackDecodedHeadersAccumulator(QuicStreamId id,
@@ -56,14 +57,16 @@
 
   // QpackProgressiveDecoder::HeadersHandlerInterface implementation.
   // These methods should only be called by |decoder_|.
-  void OnHeaderDecoded(QuicStringPiece name, QuicStringPiece value) override;
+  void OnHeaderDecoded(quiche::QuicheStringPiece name,
+                       quiche::QuicheStringPiece value) override;
   void OnDecodingCompleted() override;
-  void OnDecodingErrorDetected(QuicStringPiece error_message) override;
+  void OnDecodingErrorDetected(
+      quiche::QuicheStringPiece error_message) override;
 
   // Decode payload data.
   // Must not be called if an error has been detected.
   // Must not be called after EndHeaderBlock().
-  void Decode(QuicStringPiece data);
+  void Decode(quiche::QuicheStringPiece data);
 
   // Signal end of HEADERS frame.
   // Must not be called if an error has been detected.
diff --git a/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc b/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
index 2334e89..c98f854 100644
--- a/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
+++ b/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
@@ -8,9 +8,10 @@
 
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_decoder.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_decoder_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 using ::testing::_;
 using ::testing::ElementsAre;
@@ -44,7 +45,8 @@
   MOCK_METHOD2(OnHeadersDecoded,
                void(QuicHeaderList headers,
                     bool header_list_size_limit_exceeded));
-  MOCK_METHOD1(OnHeaderDecodingError, void(QuicStringPiece error_message));
+  MOCK_METHOD1(OnHeaderDecodingError,
+               void(quiche::QuicheStringPiece error_message));
 };
 
 }  // anonymous namespace
@@ -79,7 +81,7 @@
 
 // HEADERS frame payload must have a complete Header Block Prefix.
 TEST_F(QpackDecodedHeadersAccumulatorTest, TruncatedHeaderBlockPrefix) {
-  accumulator_.Decode(QuicTextUtils::HexDecode("00"));
+  accumulator_.Decode(quiche::QuicheTextUtils::HexDecode("00"));
 
   EXPECT_CALL(visitor_,
               OnHeaderDecodingError(Eq("Incomplete header data prefix.")));
@@ -87,7 +89,7 @@
 }
 
 TEST_F(QpackDecodedHeadersAccumulatorTest, EmptyHeaderList) {
-  std::string encoded_data(QuicTextUtils::HexDecode("0000"));
+  std::string encoded_data(quiche::QuicheTextUtils::HexDecode("0000"));
   accumulator_.Decode(encoded_data);
 
   QuicHeaderList header_list;
@@ -103,7 +105,7 @@
 // This payload is the prefix of a valid payload, but EndHeaderBlock() is called
 // before it can be completely decoded.
 TEST_F(QpackDecodedHeadersAccumulatorTest, TruncatedPayload) {
-  accumulator_.Decode(QuicTextUtils::HexDecode("00002366"));
+  accumulator_.Decode(quiche::QuicheTextUtils::HexDecode("00002366"));
 
   EXPECT_CALL(visitor_, OnHeaderDecodingError(Eq("Incomplete header block.")));
   accumulator_.EndHeaderBlock();
@@ -113,11 +115,12 @@
 TEST_F(QpackDecodedHeadersAccumulatorTest, InvalidPayload) {
   EXPECT_CALL(visitor_,
               OnHeaderDecodingError(Eq("Static table entry not found.")));
-  accumulator_.Decode(QuicTextUtils::HexDecode("0000ff23ff24"));
+  accumulator_.Decode(quiche::QuicheTextUtils::HexDecode("0000ff23ff24"));
 }
 
 TEST_F(QpackDecodedHeadersAccumulatorTest, Success) {
-  std::string encoded_data(QuicTextUtils::HexDecode("000023666f6f03626172"));
+  std::string encoded_data(
+      quiche::QuicheTextUtils::HexDecode("000023666f6f03626172"));
   accumulator_.Decode(encoded_data);
 
   QuicHeaderList header_list;
@@ -135,7 +138,7 @@
 // otherwise decoding could fail with "incomplete header block" error.
 TEST_F(QpackDecodedHeadersAccumulatorTest, ExceedLimitThenSplitInstruction) {
   // Total length of header list exceeds kMaxHeaderListSize.
-  accumulator_.Decode(QuicTextUtils::HexDecode(
+  accumulator_.Decode(quiche::QuicheTextUtils::HexDecode(
       "0000"                                      // header block prefix
       "26666f6f626172"                            // header key: "foobar"
       "7d61616161616161616161616161616161616161"  // header value: 'a' 125 times
@@ -143,7 +146,7 @@
       "616161616161616161616161616161616161616161616161616161616161616161616161"
       "61616161616161616161616161616161616161616161616161616161616161616161"
       "ff"));  // first byte of a two-byte long Indexed Header Field instruction
-  accumulator_.Decode(QuicTextUtils::HexDecode(
+  accumulator_.Decode(quiche::QuicheTextUtils::HexDecode(
       "0f"  // second byte of a two-byte long Indexed Header Field instruction
       ));
 
@@ -154,7 +157,7 @@
 // Test that header list limit enforcement works with blocked encoding.
 TEST_F(QpackDecodedHeadersAccumulatorTest, ExceedLimitBlocked) {
   // Total length of header list exceeds kMaxHeaderListSize.
-  accumulator_.Decode(QuicTextUtils::HexDecode(
+  accumulator_.Decode(quiche::QuicheTextUtils::HexDecode(
       "0200"            // header block prefix
       "80"              // reference to dynamic table entry not yet received
       "26666f6f626172"  // header key: "foobar"
@@ -176,7 +179,7 @@
 
 TEST_F(QpackDecodedHeadersAccumulatorTest, BlockedDecoding) {
   // Reference to dynamic table entry not yet received.
-  std::string encoded_data(QuicTextUtils::HexDecode("020080"));
+  std::string encoded_data(quiche::QuicheTextUtils::HexDecode("020080"));
   accumulator_.Decode(encoded_data);
   accumulator_.EndHeaderBlock();
 
@@ -200,7 +203,7 @@
 TEST_F(QpackDecodedHeadersAccumulatorTest,
        BlockedDecodingUnblockedBeforeEndOfHeaderBlock) {
   // Reference to dynamic table entry not yet received.
-  accumulator_.Decode(QuicTextUtils::HexDecode("020080"));
+  accumulator_.Decode(quiche::QuicheTextUtils::HexDecode("020080"));
 
   // Set dynamic table capacity.
   qpack_decoder_.OnSetDynamicTableCapacity(kMaxDynamicTableCapacity);
@@ -210,7 +213,7 @@
   // Rest of header block: same entry again.
   EXPECT_CALL(decoder_stream_sender_delegate_,
               WriteStreamData(Eq(kHeaderAcknowledgement)));
-  accumulator_.Decode(QuicTextUtils::HexDecode("80"));
+  accumulator_.Decode(quiche::QuicheTextUtils::HexDecode("80"));
 
   QuicHeaderList header_list;
   EXPECT_CALL(visitor_, OnHeadersDecoded(_, false))
@@ -225,12 +228,12 @@
        BlockedDecodingUnblockedAndErrorBeforeEndOfHeaderBlock) {
   // Required Insert Count higher than number of entries causes decoding to be
   // blocked.
-  accumulator_.Decode(QuicTextUtils::HexDecode("0200"));
+  accumulator_.Decode(quiche::QuicheTextUtils::HexDecode("0200"));
   // Indexed Header Field instruction addressing dynamic table entry with
   // relative index 0, absolute index 0.
-  accumulator_.Decode(QuicTextUtils::HexDecode("80"));
+  accumulator_.Decode(quiche::QuicheTextUtils::HexDecode("80"));
   // Relative index larger than or equal to Base is invalid.
-  accumulator_.Decode(QuicTextUtils::HexDecode("81"));
+  accumulator_.Decode(quiche::QuicheTextUtils::HexDecode("81"));
 
   // Set dynamic table capacity.
   qpack_decoder_.OnSetDynamicTableCapacity(kMaxDynamicTableCapacity);
diff --git a/quic/core/qpack/qpack_decoder.cc b/quic/core/qpack/qpack_decoder.cc
index 3ae6bce..17790de 100644
--- a/quic/core/qpack/qpack_decoder.cc
+++ b/quic/core/qpack/qpack_decoder.cc
@@ -8,6 +8,7 @@
 
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_index_conversions.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"
 
 namespace quic {
 
@@ -69,7 +70,7 @@
 
 void QpackDecoder::OnInsertWithNameReference(bool is_static,
                                              uint64_t name_index,
-                                             QuicStringPiece value) {
+                                             quiche::QuicheStringPiece value) {
   if (is_static) {
     auto entry = header_table_.LookupEntry(/* is_static = */ true, name_index);
     if (!entry) {
@@ -108,8 +109,9 @@
   }
 }
 
-void QpackDecoder::OnInsertWithoutNameReference(QuicStringPiece name,
-                                                QuicStringPiece value) {
+void QpackDecoder::OnInsertWithoutNameReference(
+    quiche::QuicheStringPiece name,
+    quiche::QuicheStringPiece value) {
   const QpackEntry* entry = header_table_.InsertEntry(name, value);
   if (!entry) {
     encoder_stream_error_delegate_->OnEncoderStreamError(
@@ -147,7 +149,7 @@
   }
 }
 
-void QpackDecoder::OnErrorDetected(QuicStringPiece error_message) {
+void QpackDecoder::OnErrorDetected(quiche::QuicheStringPiece error_message) {
   encoder_stream_error_delegate_->OnEncoderStreamError(error_message);
 }
 
diff --git a/quic/core/qpack/qpack_decoder.h b/quic/core/qpack/qpack_decoder.h
index 4ac1e44..e09b14b 100644
--- a/quic/core/qpack/qpack_decoder.h
+++ b/quic/core/qpack/qpack_decoder.h
@@ -15,7 +15,7 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_progressive_decoder.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 {
 
@@ -34,7 +34,8 @@
    public:
     virtual ~EncoderStreamErrorDelegate() {}
 
-    virtual void OnEncoderStreamError(QuicStringPiece error_message) = 0;
+    virtual void OnEncoderStreamError(
+        quiche::QuicheStringPiece error_message) = 0;
   };
 
   QpackDecoder(uint64_t maximum_dynamic_table_capacity,
@@ -79,12 +80,12 @@
   // QpackEncoderStreamReceiver::Delegate implementation
   void OnInsertWithNameReference(bool is_static,
                                  uint64_t name_index,
-                                 QuicStringPiece value) override;
-  void OnInsertWithoutNameReference(QuicStringPiece name,
-                                    QuicStringPiece value) override;
+                                 quiche::QuicheStringPiece value) override;
+  void OnInsertWithoutNameReference(quiche::QuicheStringPiece name,
+                                    quiche::QuicheStringPiece value) override;
   void OnDuplicate(uint64_t index) override;
   void OnSetDynamicTableCapacity(uint64_t capacity) override;
-  void OnErrorDetected(QuicStringPiece error_message) override;
+  void OnErrorDetected(quiche::QuicheStringPiece error_message) override;
 
   // delegate must be set if dynamic table capacity is not zero.
   void set_qpack_stream_sender_delegate(QpackStreamSenderDelegate* delegate) {
diff --git a/quic/core/qpack/qpack_decoder_stream_receiver.cc b/quic/core/qpack/qpack_decoder_stream_receiver.cc
index 2ba89d4..5d6cf83 100644
--- a/quic/core/qpack/qpack_decoder_stream_receiver.cc
+++ b/quic/core/qpack/qpack_decoder_stream_receiver.cc
@@ -7,6 +7,7 @@
 #include "net/third_party/quiche/src/http2/decoder/decode_buffer.h"
 #include "net/third_party/quiche/src/http2/decoder/decode_status.h"
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_instructions.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -17,7 +18,7 @@
   DCHECK(delegate_);
 }
 
-void QpackDecoderStreamReceiver::Decode(QuicStringPiece data) {
+void QpackDecoderStreamReceiver::Decode(quiche::QuicheStringPiece data) {
   if (data.empty() || error_detected_) {
     return;
   }
@@ -42,7 +43,8 @@
   return true;
 }
 
-void QpackDecoderStreamReceiver::OnError(QuicStringPiece error_message) {
+void QpackDecoderStreamReceiver::OnError(
+    quiche::QuicheStringPiece error_message) {
   DCHECK(!error_detected_);
 
   error_detected_ = true;
diff --git a/quic/core/qpack/qpack_decoder_stream_receiver.h b/quic/core/qpack/qpack_decoder_stream_receiver.h
index 396c6df..19f51f0 100644
--- a/quic/core/qpack/qpack_decoder_stream_receiver.h
+++ b/quic/core/qpack/qpack_decoder_stream_receiver.h
@@ -11,7 +11,7 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_stream_receiver.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 {
 
@@ -34,7 +34,7 @@
     // 5.3.3 Stream Cancellation
     virtual void OnStreamCancellation(QuicStreamId stream_id) = 0;
     // Decoding error
-    virtual void OnErrorDetected(QuicStringPiece error_message) = 0;
+    virtual void OnErrorDetected(quiche::QuicheStringPiece error_message) = 0;
   };
 
   explicit QpackDecoderStreamReceiver(Delegate* delegate);
@@ -47,11 +47,11 @@
   // Decode data and call appropriate Delegate method after each decoded
   // instruction.  Once an error occurs, Delegate::OnErrorDetected() is called,
   // and all further data is ignored.
-  void Decode(QuicStringPiece data) override;
+  void Decode(quiche::QuicheStringPiece data) override;
 
   // QpackInstructionDecoder::Delegate implementation.
   bool OnInstructionDecoded(const QpackInstruction* instruction) override;
-  void OnError(QuicStringPiece error_message) override;
+  void OnError(quiche::QuicheStringPiece error_message) override;
 
  private:
   QpackInstructionDecoder instruction_decoder_;
diff --git a/quic/core/qpack/qpack_decoder_stream_receiver_test.cc b/quic/core/qpack/qpack_decoder_stream_receiver_test.cc
index 29a00d1..44a2286 100644
--- a/quic/core/qpack/qpack_decoder_stream_receiver_test.cc
+++ b/quic/core/qpack/qpack_decoder_stream_receiver_test.cc
@@ -5,7 +5,8 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_decoder_stream_receiver.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 testing::Eq;
 using testing::StrictMock;
@@ -21,7 +22,7 @@
   MOCK_METHOD1(OnInsertCountIncrement, void(uint64_t increment));
   MOCK_METHOD1(OnHeaderAcknowledgement, void(QuicStreamId stream_id));
   MOCK_METHOD1(OnStreamCancellation, void(QuicStreamId stream_id));
-  MOCK_METHOD1(OnErrorDetected, void(QuicStringPiece error_message));
+  MOCK_METHOD1(OnErrorDetected, void(quiche::QuicheStringPiece error_message));
 };
 
 class QpackDecoderStreamReceiverTest : public QuicTest {
@@ -35,53 +36,53 @@
 
 TEST_F(QpackDecoderStreamReceiverTest, InsertCountIncrement) {
   EXPECT_CALL(delegate_, OnInsertCountIncrement(0));
-  stream_.Decode(QuicTextUtils::HexDecode("00"));
+  stream_.Decode(quiche::QuicheTextUtils::HexDecode("00"));
 
   EXPECT_CALL(delegate_, OnInsertCountIncrement(10));
-  stream_.Decode(QuicTextUtils::HexDecode("0a"));
+  stream_.Decode(quiche::QuicheTextUtils::HexDecode("0a"));
 
   EXPECT_CALL(delegate_, OnInsertCountIncrement(63));
-  stream_.Decode(QuicTextUtils::HexDecode("3f00"));
+  stream_.Decode(quiche::QuicheTextUtils::HexDecode("3f00"));
 
   EXPECT_CALL(delegate_, OnInsertCountIncrement(200));
-  stream_.Decode(QuicTextUtils::HexDecode("3f8901"));
+  stream_.Decode(quiche::QuicheTextUtils::HexDecode("3f8901"));
 
   EXPECT_CALL(delegate_, OnErrorDetected(Eq("Encoded integer too large.")));
-  stream_.Decode(QuicTextUtils::HexDecode("3fffffffffffffffffffff"));
+  stream_.Decode(quiche::QuicheTextUtils::HexDecode("3fffffffffffffffffffff"));
 }
 
 TEST_F(QpackDecoderStreamReceiverTest, HeaderAcknowledgement) {
   EXPECT_CALL(delegate_, OnHeaderAcknowledgement(0));
-  stream_.Decode(QuicTextUtils::HexDecode("80"));
+  stream_.Decode(quiche::QuicheTextUtils::HexDecode("80"));
 
   EXPECT_CALL(delegate_, OnHeaderAcknowledgement(37));
-  stream_.Decode(QuicTextUtils::HexDecode("a5"));
+  stream_.Decode(quiche::QuicheTextUtils::HexDecode("a5"));
 
   EXPECT_CALL(delegate_, OnHeaderAcknowledgement(127));
-  stream_.Decode(QuicTextUtils::HexDecode("ff00"));
+  stream_.Decode(quiche::QuicheTextUtils::HexDecode("ff00"));
 
   EXPECT_CALL(delegate_, OnHeaderAcknowledgement(503));
-  stream_.Decode(QuicTextUtils::HexDecode("fff802"));
+  stream_.Decode(quiche::QuicheTextUtils::HexDecode("fff802"));
 
   EXPECT_CALL(delegate_, OnErrorDetected(Eq("Encoded integer too large.")));
-  stream_.Decode(QuicTextUtils::HexDecode("ffffffffffffffffffffff"));
+  stream_.Decode(quiche::QuicheTextUtils::HexDecode("ffffffffffffffffffffff"));
 }
 
 TEST_F(QpackDecoderStreamReceiverTest, StreamCancellation) {
   EXPECT_CALL(delegate_, OnStreamCancellation(0));
-  stream_.Decode(QuicTextUtils::HexDecode("40"));
+  stream_.Decode(quiche::QuicheTextUtils::HexDecode("40"));
 
   EXPECT_CALL(delegate_, OnStreamCancellation(19));
-  stream_.Decode(QuicTextUtils::HexDecode("53"));
+  stream_.Decode(quiche::QuicheTextUtils::HexDecode("53"));
 
   EXPECT_CALL(delegate_, OnStreamCancellation(63));
-  stream_.Decode(QuicTextUtils::HexDecode("7f00"));
+  stream_.Decode(quiche::QuicheTextUtils::HexDecode("7f00"));
 
   EXPECT_CALL(delegate_, OnStreamCancellation(110));
-  stream_.Decode(QuicTextUtils::HexDecode("7f2f"));
+  stream_.Decode(quiche::QuicheTextUtils::HexDecode("7f2f"));
 
   EXPECT_CALL(delegate_, OnErrorDetected(Eq("Encoded integer too large.")));
-  stream_.Decode(QuicTextUtils::HexDecode("7fffffffffffffffffffff"));
+  stream_.Decode(quiche::QuicheTextUtils::HexDecode("7fffffffffffffffffffff"));
 }
 
 }  // namespace
diff --git a/quic/core/qpack/qpack_decoder_stream_sender.cc b/quic/core/qpack/qpack_decoder_stream_sender.cc
index 72a446b..34f4de8 100644
--- a/quic/core/qpack/qpack_decoder_stream_sender.cc
+++ b/quic/core/qpack/qpack_decoder_stream_sender.cc
@@ -10,6 +10,7 @@
 
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_instructions.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"
 
 namespace quic {
 
diff --git a/quic/core/qpack/qpack_decoder_stream_sender.h b/quic/core/qpack/qpack_decoder_stream_sender.h
index d9033b0..eee95c1 100644
--- a/quic/core/qpack/qpack_decoder_stream_sender.h
+++ b/quic/core/qpack/qpack_decoder_stream_sender.h
@@ -11,7 +11,6 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_stream_sender_delegate.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"
 
 namespace quic {
 
diff --git a/quic/core/qpack/qpack_decoder_stream_sender_test.cc b/quic/core/qpack/qpack_decoder_stream_sender_test.cc
index e3dc124..1d18fa9 100644
--- a/quic/core/qpack/qpack_decoder_stream_sender_test.cc
+++ b/quic/core/qpack/qpack_decoder_stream_sender_test.cc
@@ -5,8 +5,8 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_decoder_stream_sender.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/common/platform/api/quiche_text_utils.h"
 
 using ::testing::Eq;
 using ::testing::StrictMock;
@@ -27,57 +27,67 @@
 };
 
 TEST_F(QpackDecoderStreamSenderTest, InsertCountIncrement) {
-  EXPECT_CALL(delegate_, WriteStreamData(Eq(QuicTextUtils::HexDecode("00"))));
+  EXPECT_CALL(delegate_,
+              WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("00"))));
   stream_.SendInsertCountIncrement(0);
   stream_.Flush();
 
-  EXPECT_CALL(delegate_, WriteStreamData(Eq(QuicTextUtils::HexDecode("0a"))));
+  EXPECT_CALL(delegate_,
+              WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("0a"))));
   stream_.SendInsertCountIncrement(10);
   stream_.Flush();
 
-  EXPECT_CALL(delegate_, WriteStreamData(Eq(QuicTextUtils::HexDecode("3f00"))));
+  EXPECT_CALL(delegate_,
+              WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("3f00"))));
   stream_.SendInsertCountIncrement(63);
   stream_.Flush();
 
-  EXPECT_CALL(delegate_,
-              WriteStreamData(Eq(QuicTextUtils::HexDecode("3f8901"))));
+  EXPECT_CALL(delegate_, WriteStreamData(
+                             Eq(quiche::QuicheTextUtils::HexDecode("3f8901"))));
   stream_.SendInsertCountIncrement(200);
   stream_.Flush();
 }
 
 TEST_F(QpackDecoderStreamSenderTest, HeaderAcknowledgement) {
-  EXPECT_CALL(delegate_, WriteStreamData(Eq(QuicTextUtils::HexDecode("80"))));
+  EXPECT_CALL(delegate_,
+              WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("80"))));
   stream_.SendHeaderAcknowledgement(0);
   stream_.Flush();
 
-  EXPECT_CALL(delegate_, WriteStreamData(Eq(QuicTextUtils::HexDecode("a5"))));
+  EXPECT_CALL(delegate_,
+              WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("a5"))));
   stream_.SendHeaderAcknowledgement(37);
   stream_.Flush();
 
-  EXPECT_CALL(delegate_, WriteStreamData(Eq(QuicTextUtils::HexDecode("ff00"))));
+  EXPECT_CALL(delegate_,
+              WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("ff00"))));
   stream_.SendHeaderAcknowledgement(127);
   stream_.Flush();
 
-  EXPECT_CALL(delegate_,
-              WriteStreamData(Eq(QuicTextUtils::HexDecode("fff802"))));
+  EXPECT_CALL(delegate_, WriteStreamData(
+                             Eq(quiche::QuicheTextUtils::HexDecode("fff802"))));
   stream_.SendHeaderAcknowledgement(503);
   stream_.Flush();
 }
 
 TEST_F(QpackDecoderStreamSenderTest, StreamCancellation) {
-  EXPECT_CALL(delegate_, WriteStreamData(Eq(QuicTextUtils::HexDecode("40"))));
+  EXPECT_CALL(delegate_,
+              WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("40"))));
   stream_.SendStreamCancellation(0);
   stream_.Flush();
 
-  EXPECT_CALL(delegate_, WriteStreamData(Eq(QuicTextUtils::HexDecode("53"))));
+  EXPECT_CALL(delegate_,
+              WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("53"))));
   stream_.SendStreamCancellation(19);
   stream_.Flush();
 
-  EXPECT_CALL(delegate_, WriteStreamData(Eq(QuicTextUtils::HexDecode("7f00"))));
+  EXPECT_CALL(delegate_,
+              WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("7f00"))));
   stream_.SendStreamCancellation(63);
   stream_.Flush();
 
-  EXPECT_CALL(delegate_, WriteStreamData(Eq(QuicTextUtils::HexDecode("7f2f"))));
+  EXPECT_CALL(delegate_,
+              WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("7f2f"))));
   stream_.SendStreamCancellation(110);
   stream_.Flush();
 }
@@ -87,15 +97,16 @@
   stream_.SendHeaderAcknowledgement(37);
   stream_.SendStreamCancellation(0);
 
-  EXPECT_CALL(delegate_,
-              WriteStreamData(Eq(QuicTextUtils::HexDecode("0aa540"))));
+  EXPECT_CALL(delegate_, WriteStreamData(
+                             Eq(quiche::QuicheTextUtils::HexDecode("0aa540"))));
   stream_.Flush();
 
   stream_.SendInsertCountIncrement(63);
   stream_.SendStreamCancellation(110);
 
-  EXPECT_CALL(delegate_,
-              WriteStreamData(Eq(QuicTextUtils::HexDecode("3f007f2f"))));
+  EXPECT_CALL(
+      delegate_,
+      WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("3f007f2f"))));
   stream_.Flush();
 }
 
diff --git a/quic/core/qpack/qpack_decoder_test.cc b/quic/core/qpack/qpack_decoder_test.cc
index 1fc5802..8b546b0 100644
--- a/quic/core/qpack/qpack_decoder_test.cc
+++ b/quic/core/qpack/qpack_decoder_test.cc
@@ -8,9 +8,10 @@
 
 #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/quic/platform/api/quic_text_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_decoder_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_header_block.h"
 
 using ::testing::_;
@@ -48,12 +49,13 @@
     // Destroy QpackProgressiveDecoder on error to test that it does not crash.
     // See https://crbug.com/1025209.
     ON_CALL(handler_, OnDecodingErrorDetected(_))
-        .WillByDefault(Invoke([this](QuicStringPiece /* error_message */) {
-          progressive_decoder_.reset();
-        }));
+        .WillByDefault(
+            Invoke([this](quiche::QuicheStringPiece /* error_message */) {
+              progressive_decoder_.reset();
+            }));
   }
 
-  void DecodeEncoderStreamData(QuicStringPiece data) {
+  void DecodeEncoderStreamData(quiche::QuicheStringPiece data) {
     qpack_decoder_.encoder_stream_receiver()->Decode(data);
   }
 
@@ -69,7 +71,7 @@
 
   // Pass header block data to QpackProgressiveDecoder::Decode()
   // in fragments dictated by |fragment_mode_|.
-  void DecodeData(QuicStringPiece data) {
+  void DecodeData(quiche::QuicheStringPiece data) {
     auto fragment_size_generator =
         FragmentModeToFragmentSizeGenerator(fragment_mode_);
     while (progressive_decoder_ && !data.empty()) {
@@ -89,7 +91,7 @@
   }
 
   // Decode an entire header block.
-  void DecodeHeaderBlock(QuicStringPiece data) {
+  void DecodeHeaderBlock(quiche::QuicheStringPiece data) {
     StartDecoding();
     DecodeData(data);
     EndDecoding();
@@ -115,7 +117,7 @@
               OnDecodingErrorDetected(Eq("Incomplete header data prefix.")));
 
   // Header Data Prefix is at least two bytes long.
-  DecodeHeaderBlock(QuicTextUtils::HexDecode("00"));
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("00"));
 }
 
 // Regression test for https://1025209: QpackProgressiveDecoder must not crash
@@ -127,50 +129,52 @@
               OnDecodingErrorDetected(Eq("Encoded integer too large.")));
 
   // Encoded Required Insert Count in Header Data Prefix is too large.
-  DecodeData(QuicTextUtils::HexDecode("ffffffffffffffffffffffffffff"));
+  DecodeData(
+      quiche::QuicheTextUtils::HexDecode("ffffffffffffffffffffffffffff"));
 }
 
 TEST_P(QpackDecoderTest, EmptyHeaderBlock) {
   EXPECT_CALL(handler_, OnDecodingCompleted());
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode("0000"));
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("0000"));
 }
 
 TEST_P(QpackDecoderTest, LiteralEntryEmptyName) {
   EXPECT_CALL(handler_, OnHeaderDecoded(Eq(""), Eq("foo")));
   EXPECT_CALL(handler_, OnDecodingCompleted());
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode("00002003666f6f"));
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("00002003666f6f"));
 }
 
 TEST_P(QpackDecoderTest, LiteralEntryEmptyValue) {
   EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("")));
   EXPECT_CALL(handler_, OnDecodingCompleted());
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode("000023666f6f00"));
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("000023666f6f00"));
 }
 
 TEST_P(QpackDecoderTest, LiteralEntryEmptyNameAndValue) {
   EXPECT_CALL(handler_, OnHeaderDecoded(Eq(""), Eq("")));
   EXPECT_CALL(handler_, OnDecodingCompleted());
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode("00002000"));
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("00002000"));
 }
 
 TEST_P(QpackDecoderTest, SimpleLiteralEntry) {
   EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("bar")));
   EXPECT_CALL(handler_, OnDecodingCompleted());
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode("000023666f6f03626172"));
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("000023666f6f03626172"));
 }
 
 TEST_P(QpackDecoderTest, MultipleLiteralEntries) {
   EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("bar")));
   std::string str(127, 'a');
-  EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foobaar"), QuicStringPiece(str)));
+  EXPECT_CALL(handler_,
+              OnHeaderDecoded(Eq("foobaar"), quiche::QuicheStringPiece(str)));
   EXPECT_CALL(handler_, OnDecodingCompleted());
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0000"                // prefix
       "23666f6f03626172"    // foo: bar
       "2700666f6f62616172"  // 7 octet long header name, the smallest number
@@ -188,7 +192,8 @@
   EXPECT_CALL(handler_,
               OnDecodingErrorDetected(Eq("Encoded integer too large.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode("000027ffffffffffffffffffff"));
+  DecodeHeaderBlock(
+      quiche::QuicheTextUtils::HexDecode("000027ffffffffffffffffffff"));
 }
 
 // Name Length value can be decoded by varint decoder but exceeds 1 MB limit.
@@ -196,7 +201,7 @@
   EXPECT_CALL(handler_,
               OnDecodingErrorDetected(Eq("String literal too long.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode("000027ffff7f"));
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("000027ffff7f"));
 }
 
 // Value Length value is too large for varint decoder to decode.
@@ -205,7 +210,7 @@
               OnDecodingErrorDetected(Eq("Encoded integer too large.")));
 
   DecodeHeaderBlock(
-      QuicTextUtils::HexDecode("000023666f6f7fffffffffffffffffffff"));
+      quiche::QuicheTextUtils::HexDecode("000023666f6f7fffffffffffffffffffff"));
 }
 
 // Value Length value can be decoded by varint decoder but exceeds 1 MB limit.
@@ -213,22 +218,22 @@
   EXPECT_CALL(handler_,
               OnDecodingErrorDetected(Eq("String literal too long.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode("000023666f6f7fffff7f"));
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("000023666f6f7fffff7f"));
 }
 
 TEST_P(QpackDecoderTest, IncompleteHeaderBlock) {
   EXPECT_CALL(handler_,
               OnDecodingErrorDetected(Eq("Incomplete header block.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode("00002366"));
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("00002366"));
 }
 
 TEST_P(QpackDecoderTest, HuffmanSimple) {
   EXPECT_CALL(handler_, OnHeaderDecoded(Eq("custom-key"), Eq("custom-value")));
   EXPECT_CALL(handler_, OnDecodingCompleted());
 
-  DecodeHeaderBlock(
-      QuicTextUtils::HexDecode("00002f0125a849e95ba97d7f8925a849e95bb8e8b4bf"));
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+      "00002f0125a849e95ba97d7f8925a849e95bb8e8b4bf"));
 }
 
 TEST_P(QpackDecoderTest, AlternatingHuffmanNonHuffman) {
@@ -236,7 +241,7 @@
       .Times(4);
   EXPECT_CALL(handler_, OnDecodingCompleted());
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0000"                        // Prefix.
       "2f0125a849e95ba97d7f"        // Huffman-encoded name.
       "8925a849e95bb8e8b4bf"        // Huffman-encoded value.
@@ -249,44 +254,44 @@
 }
 
 TEST_P(QpackDecoderTest, HuffmanNameDoesNotHaveEOSPrefix) {
-  EXPECT_CALL(handler_, OnDecodingErrorDetected(QuicStringPiece(
+  EXPECT_CALL(handler_, OnDecodingErrorDetected(quiche::QuicheStringPiece(
                             "Error in Huffman-encoded string.")));
 
   // 'y' ends in 0b0 on the most significant bit of the last byte.
   // The remaining 7 bits must be a prefix of EOS, which is all 1s.
-  DecodeHeaderBlock(
-      QuicTextUtils::HexDecode("00002f0125a849e95ba97d7e8925a849e95bb8e8b4bf"));
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+      "00002f0125a849e95ba97d7e8925a849e95bb8e8b4bf"));
 }
 
 TEST_P(QpackDecoderTest, HuffmanValueDoesNotHaveEOSPrefix) {
-  EXPECT_CALL(handler_, OnDecodingErrorDetected(QuicStringPiece(
+  EXPECT_CALL(handler_, OnDecodingErrorDetected(quiche::QuicheStringPiece(
                             "Error in Huffman-encoded string.")));
 
   // 'e' ends in 0b101, taking up the 3 most significant bits of the last byte.
   // The remaining 5 bits must be a prefix of EOS, which is all 1s.
-  DecodeHeaderBlock(
-      QuicTextUtils::HexDecode("00002f0125a849e95ba97d7f8925a849e95bb8e8b4be"));
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
+      "00002f0125a849e95ba97d7f8925a849e95bb8e8b4be"));
 }
 
 TEST_P(QpackDecoderTest, HuffmanNameEOSPrefixTooLong) {
-  EXPECT_CALL(handler_, OnDecodingErrorDetected(QuicStringPiece(
+  EXPECT_CALL(handler_, OnDecodingErrorDetected(quiche::QuicheStringPiece(
                             "Error in Huffman-encoded string.")));
 
   // The trailing EOS prefix must be at most 7 bits long.  Appending one octet
   // with value 0xff is invalid, even though 0b111111111111111 (15 bits) is a
   // prefix of EOS.
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "00002f0225a849e95ba97d7fff8925a849e95bb8e8b4bf"));
 }
 
 TEST_P(QpackDecoderTest, HuffmanValueEOSPrefixTooLong) {
-  EXPECT_CALL(handler_, OnDecodingErrorDetected(QuicStringPiece(
+  EXPECT_CALL(handler_, OnDecodingErrorDetected(quiche::QuicheStringPiece(
                             "Error in Huffman-encoded string.")));
 
   // The trailing EOS prefix must be at most 7 bits long.  Appending one octet
   // with value 0xff is invalid, even though 0b1111111111111 (13 bits) is a
   // prefix of EOS.
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "00002f0125a849e95ba97d7f8a25a849e95bb8e8b4bfff"));
 }
 
@@ -308,7 +313,7 @@
 
   EXPECT_CALL(handler_, OnDecodingCompleted());
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0000d1dfccd45f108621e9aec2a11f5c8294e75f000554524143455f1000"));
 }
 
@@ -321,11 +326,11 @@
   EXPECT_CALL(handler_,
               OnDecodingErrorDetected(Eq("Static table entry not found.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode("0000ff23ff24"));
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("0000ff23ff24"));
 }
 
 TEST_P(QpackDecoderTest, DynamicTable) {
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode(
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode(
       "3fe107"          // Set dynamic table capacity to 1024.
       "6294e703626172"  // Add literal entry with name "foo" and value "bar".
       "80035a5a5a"      // Add entry with name of dynamic table entry index 0
@@ -354,7 +359,7 @@
       .InSequence(s);
   EXPECT_CALL(handler_, OnDecodingCompleted()).InSequence(s);
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0500"  // Required Insert Count 4 and Delta Base 0.
               // Base is 4 + 0 = 4.
       "83"    // Dynamic table entry with relative index 3, absolute index 0.
@@ -375,7 +380,7 @@
       .InSequence(s);
   EXPECT_CALL(handler_, OnDecodingCompleted()).InSequence(s);
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0502"  // Required Insert Count 4 and Delta Base 2.
               // Base is 4 + 2 = 6.
       "85"    // Dynamic table entry with relative index 5, absolute index 0.
@@ -396,7 +401,7 @@
       .InSequence(s);
   EXPECT_CALL(handler_, OnDecodingCompleted()).InSequence(s);
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0582"  // Required Insert Count 4 and Delta Base 2 with sign bit set.
               // Base is 4 - 2 - 1 = 1.
       "80"    // Dynamic table entry with relative index 0, absolute index 0.
@@ -409,28 +414,28 @@
 
 TEST_P(QpackDecoderTest, DecreasingDynamicTableCapacityEvictsEntries) {
   // Set dynamic table capacity to 1024.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3fe107"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
   // Add literal entry with name "foo" and value "bar".
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("6294e703626172"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
 
   EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("bar")));
   EXPECT_CALL(handler_, OnDecodingCompleted());
   EXPECT_CALL(decoder_stream_sender_delegate_,
               WriteStreamData(Eq(kHeaderAcknowledgement)));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0200"   // Required Insert Count 1 and Delta Base 0.
                // Base is 1 + 0 = 1.
       "80"));  // Dynamic table entry with relative index 0, absolute index 0.
 
   // Change dynamic table capacity to 32 bytes, smaller than the entry.
   // This must cause the entry to be evicted.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3f01"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3f01"));
 
   EXPECT_CALL(handler_, OnDecodingErrorDetected(
                             Eq("Dynamic table entry already evicted.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0200"   // Required Insert Count 1 and Delta Base 0.
                // Base is 1 + 0 = 1.
       "80"));  // Dynamic table entry with relative index 0, absolute index 0.
@@ -441,9 +446,9 @@
               OnEncoderStreamError(Eq("Error inserting literal entry.")));
 
   // Set dynamic table capacity to 34.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3f03"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3f03"));
   // Add literal entry with name "foo" and value "bar", size is 32 + 3 + 3 = 38.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("6294e703626172"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
 }
 
 TEST_P(QpackDecoderTest, EncoderStreamErrorInvalidStaticTableEntry) {
@@ -451,14 +456,14 @@
               OnEncoderStreamError(Eq("Invalid static table entry.")));
 
   // Address invalid static table entry index 99.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("ff2400"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("ff2400"));
 }
 
 TEST_P(QpackDecoderTest, EncoderStreamErrorInvalidDynamicTableEntry) {
   EXPECT_CALL(encoder_stream_error_delegate_,
               OnEncoderStreamError(Eq("Invalid relative index.")));
 
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode(
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode(
       "3fe107"          // Set dynamic table capacity to 1024.
       "6294e703626172"  // Add literal entry with name "foo" and value "bar".
       "8100"));  // Address dynamic table entry with relative index 1.  Such
@@ -470,7 +475,7 @@
   EXPECT_CALL(encoder_stream_error_delegate_,
               OnEncoderStreamError(Eq("Invalid relative index.")));
 
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode(
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode(
       "3fe107"          // Set dynamic table capacity to 1024.
       "6294e703626172"  // Add literal entry with name "foo" and value "bar".
       "01"));  // Duplicate dynamic table entry with relative index 1.  Such
@@ -482,18 +487,19 @@
   EXPECT_CALL(encoder_stream_error_delegate_,
               OnEncoderStreamError(Eq("Encoded integer too large.")));
 
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3fffffffffffffffffffff"));
+  DecodeEncoderStreamData(
+      quiche::QuicheTextUtils::HexDecode("3fffffffffffffffffffff"));
 }
 
 TEST_P(QpackDecoderTest, InvalidDynamicEntryWhenBaseIsZero) {
   EXPECT_CALL(handler_, OnDecodingErrorDetected(Eq("Invalid relative index.")));
 
   // Set dynamic table capacity to 1024.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3fe107"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
   // Add literal entry with name "foo" and value "bar".
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("6294e703626172"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0280"   // Required Insert Count is 1.  Base 1 - 1 - 0 = 0 is explicitly
                // permitted by the spec.
       "80"));  // However, addressing entry with relative index 0 would point to
@@ -505,18 +511,18 @@
 
   // Required Insert Count 1, Delta Base 1 with sign bit set, Base would
   // be 1 - 1 - 1 = -1, but it is not allowed to be negative.
-  DecodeHeaderBlock(QuicTextUtils::HexDecode("0281"));
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("0281"));
 }
 
 TEST_P(QpackDecoderTest, InvalidDynamicEntryByRelativeIndex) {
   // Set dynamic table capacity to 1024.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3fe107"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
   // Add literal entry with name "foo" and value "bar".
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("6294e703626172"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
 
   EXPECT_CALL(handler_, OnDecodingErrorDetected(Eq("Invalid relative index.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0200"   // Required Insert Count 1 and Delta Base 0.
                // Base is 1 + 0 = 1.
       "81"));  // Indexed Header Field instruction addressing relative index 1.
@@ -524,7 +530,7 @@
 
   EXPECT_CALL(handler_, OnDecodingErrorDetected(Eq("Invalid relative index.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0200"     // Required Insert Count 1 and Delta Base 0.
                  // Base is 1 + 0 = 1.
       "4100"));  // Literal Header Field with Name Reference instruction
@@ -534,18 +540,18 @@
 
 TEST_P(QpackDecoderTest, EvictedDynamicTableEntry) {
   // Update dynamic table capacity to 128.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3f61"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3f61"));
 
   // Add literal entry with name "foo" and value "bar", size 32 + 3 + 3 = 38.
   // This fits in the table three times.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("6294e703626172"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
   // Duplicate entry four times.  This evicts the first two instances.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("00000000"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("00000000"));
 
   EXPECT_CALL(handler_, OnDecodingErrorDetected(
                             Eq("Dynamic table entry already evicted.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0500"   // Required Insert Count 4 and Delta Base 0.
                // Base is 4 + 0 = 4.
       "82"));  // Indexed Header Field instruction addressing relative index 2.
@@ -554,7 +560,7 @@
   EXPECT_CALL(handler_, OnDecodingErrorDetected(
                             Eq("Dynamic table entry already evicted.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0500"     // Required Insert Count 4 and Delta Base 0.
                  // Base is 4 + 0 = 4.
       "4200"));  // Literal Header Field with Name Reference instruction
@@ -564,7 +570,7 @@
   EXPECT_CALL(handler_, OnDecodingErrorDetected(
                             Eq("Dynamic table entry already evicted.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0380"   // Required Insert Count 2 and Delta Base 0 with sign bit set.
                // Base is 2 - 0 - 1 = 1
       "10"));  // Indexed Header Field instruction addressing dynamic table
@@ -574,7 +580,7 @@
   EXPECT_CALL(handler_, OnDecodingErrorDetected(
                             Eq("Dynamic table entry already evicted.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0380"     // Required Insert Count 2 and Delta Base 0 with sign bit set.
                  // Base is 2 - 0 - 1 = 1
       "0000"));  // Literal Header Field With Name Reference instruction
@@ -588,12 +594,12 @@
       OnEncoderStreamError(Eq("Error updating dynamic table capacity.")));
 
   // Try to update dynamic table capacity to 2048, which exceeds the maximum.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3fe10f"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe10f"));
 }
 
 TEST_P(QpackDecoderTest, SetDynamicTableCapacity) {
   // Update dynamic table capacity to 128, which does not exceed the maximum.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3f61"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3f61"));
 }
 
 TEST_P(QpackDecoderTest, InvalidEncodedRequiredInsertCount) {
@@ -603,7 +609,7 @@
   // A value of 1 cannot be encoded as 65 even though it has the same remainder.
   EXPECT_CALL(handler_, OnDecodingErrorDetected(
                             Eq("Error decoding Required Insert Count.")));
-  DecodeHeaderBlock(QuicTextUtils::HexDecode("4100"));
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("4100"));
 }
 
 // Regression test for https://crbug.com/970218:  Decoder must stop processing
@@ -612,7 +618,7 @@
   EXPECT_CALL(handler_, OnDecodingErrorDetected(
                             Eq("Error decoding Required Insert Count.")));
   // Header Block Prefix followed by some extra data.
-  DecodeHeaderBlock(QuicTextUtils::HexDecode("410000"));
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode("410000"));
 }
 
 TEST_P(QpackDecoderTest, WrappedRequiredInsertCount) {
@@ -620,12 +626,12 @@
   // MaxEntries is 1024 / 32 = 32.
 
   // Set dynamic table capacity to 1024.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3fe107"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
   // Add literal entry with name "foo" and a 600 byte long value.  This will fit
   // in the dynamic table once but not twice.
   DecodeEncoderStreamData(
-      QuicTextUtils::HexDecode("6294e7"     // Name "foo".
-                               "7fd903"));  // Value length 600.
+      quiche::QuicheTextUtils::HexDecode("6294e7"     // Name "foo".
+                                         "7fd903"));  // Value length 600.
   std::string header_value(600, 'Z');
   DecodeEncoderStreamData(header_value);
 
@@ -640,7 +646,7 @@
               WriteStreamData(Eq(kHeaderAcknowledgement)));
 
   // Send header block with Required Insert Count = 201.
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0a00"   // Encoded Required Insert Count 10, Required Insert Count 201,
                // Delta Base 0, Base 201.
       "80"));  // Emit dynamic table entry with relative index 0.
@@ -648,31 +654,31 @@
 
 TEST_P(QpackDecoderTest, NonZeroRequiredInsertCountButNoDynamicEntries) {
   // Set dynamic table capacity to 1024.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3fe107"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
   // Add literal entry with name "foo" and value "bar".
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("6294e703626172"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
 
   EXPECT_CALL(handler_, OnHeaderDecoded(Eq(":method"), Eq("GET")));
   EXPECT_CALL(handler_,
               OnDecodingErrorDetected(Eq("Required Insert Count too large.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0200"   // Required Insert Count is 1.
       "d1"));  // But the only instruction references the static table.
 }
 
 TEST_P(QpackDecoderTest, AddressEntryNotAllowedByRequiredInsertCount) {
   // Set dynamic table capacity to 1024.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3fe107"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
   // Add literal entry with name "foo" and value "bar".
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("6294e703626172"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
 
   EXPECT_CALL(
       handler_,
       OnDecodingErrorDetected(
           Eq("Absolute Index must be smaller than Required Insert Count.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0201"   // Required Insert Count 1 and Delta Base 1.
                // Base is 1 + 1 = 2.
       "80"));  // Indexed Header Field instruction addressing dynamic table
@@ -684,7 +690,7 @@
       OnDecodingErrorDetected(
           Eq("Absolute Index must be smaller than Required Insert Count.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0201"     // Required Insert Count 1 and Delta Base 1.
                  // Base is 1 + 1 = 2.
       "4000"));  // Literal Header Field with Name Reference instruction
@@ -697,7 +703,7 @@
       OnDecodingErrorDetected(
           Eq("Absolute Index must be smaller than Required Insert Count.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0200"   // Required Insert Count 1 and Delta Base 0.
                // Base is 1 + 0 = 1.
       "10"));  // Indexed Header Field with Post-Base Index instruction
@@ -710,7 +716,7 @@
       OnDecodingErrorDetected(
           Eq("Absolute Index must be smaller than Required Insert Count.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0200"     // Required Insert Count 1 and Delta Base 0.
                  // Base is 1 + 0 = 1.
       "0000"));  // Literal Header Field with Post-Base Name Reference
@@ -721,19 +727,19 @@
 
 TEST_P(QpackDecoderTest, PromisedRequiredInsertCountLargerThanActual) {
   // Set dynamic table capacity to 1024.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3fe107"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
   // Add literal entry with name "foo" and value "bar".
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("6294e703626172"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
   // Duplicate entry twice so that decoding of header blocks with Required
   // Insert Count not exceeding 3 is not blocked.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("00"));
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("00"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("00"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("00"));
 
   EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("bar")));
   EXPECT_CALL(handler_,
               OnDecodingErrorDetected(Eq("Required Insert Count too large.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0300"   // Required Insert Count 2 and Delta Base 0.
                // Base is 2 + 0 = 2.
       "81"));  // Indexed Header Field instruction addressing dynamic table
@@ -745,7 +751,7 @@
   EXPECT_CALL(handler_,
               OnDecodingErrorDetected(Eq("Required Insert Count too large.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0300"     // Required Insert Count 2 and Delta Base 0.
                  // Base is 2 + 0 = 2.
       "4100"));  // Literal Header Field with Name Reference instruction
@@ -757,7 +763,7 @@
   EXPECT_CALL(handler_,
               OnDecodingErrorDetected(Eq("Required Insert Count too large.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0481"   // Required Insert Count 3 and Delta Base 1 with sign bit set.
                // Base is 3 - 1 - 1 = 1.
       "10"));  // Indexed Header Field with Post-Base Index instruction
@@ -769,7 +775,7 @@
   EXPECT_CALL(handler_,
               OnDecodingErrorDetected(Eq("Required Insert Count too large.")));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0481"     // Required Insert Count 3 and Delta Base 1 with sign bit set.
                  // Base is 3 - 1 - 1 = 1.
       "0000"));  // Literal Header Field with Post-Base Name Reference
@@ -779,7 +785,7 @@
 }
 
 TEST_P(QpackDecoderTest, BlockedDecoding) {
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0200"   // Required Insert Count 1 and Delta Base 0.
                // Base is 1 + 0 = 1.
       "80"));  // Indexed Header Field instruction addressing dynamic table
@@ -791,14 +797,14 @@
               WriteStreamData(Eq(kHeaderAcknowledgement)));
 
   // Set dynamic table capacity to 1024.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3fe107"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
   // Add literal entry with name "foo" and value "bar".
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("6294e703626172"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
 }
 
 TEST_P(QpackDecoderTest, BlockedDecodingUnblockedBeforeEndOfHeaderBlock) {
   StartDecoding();
-  DecodeData(QuicTextUtils::HexDecode(
+  DecodeData(quiche::QuicheTextUtils::HexDecode(
       "0200"   // Required Insert Count 1 and Delta Base 0.
                // Base is 1 + 0 = 1.
       "80"     // Indexed Header Field instruction addressing dynamic table
@@ -806,7 +812,7 @@
       "d1"));  // Static table entry with index 17.
 
   // Set dynamic table capacity to 1024.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3fe107"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
 
   // Add literal entry with name "foo" and value "bar".  Decoding is now
   // unblocked because dynamic table Insert Count reached the Required Insert
@@ -814,14 +820,14 @@
   // the already consumed part of the header block.
   EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("bar")));
   EXPECT_CALL(handler_, OnHeaderDecoded(Eq(":method"), Eq("GET")));
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("6294e703626172"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
   Mock::VerifyAndClearExpectations(&handler_);
 
   // Rest of header block is processed by QpackProgressiveDecoder
   // in the unblocked state.
   EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("bar")));
   EXPECT_CALL(handler_, OnHeaderDecoded(Eq(":scheme"), Eq("https")));
-  DecodeData(QuicTextUtils::HexDecode(
+  DecodeData(quiche::QuicheTextUtils::HexDecode(
       "80"     // Indexed Header Field instruction addressing dynamic table
                // entry with relative index 0, absolute index 0.
       "d7"));  // Static table entry with index 23.
@@ -837,7 +843,7 @@
 TEST_P(QpackDecoderTest,
        BlockedDecodingUnblockedAndErrorBeforeEndOfHeaderBlock) {
   StartDecoding();
-  DecodeData(QuicTextUtils::HexDecode(
+  DecodeData(quiche::QuicheTextUtils::HexDecode(
       "0200"   // Required Insert Count 1 and Delta Base 0.
                // Base is 1 + 0 = 1.
       "80"     // Indexed Header Field instruction addressing dynamic table
@@ -845,7 +851,7 @@
       "81"));  // Relative index 1 is equal to Base, therefore invalid.
 
   // Set dynamic table capacity to 1024.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3fe107"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3fe107"));
 
   // Add literal entry with name "foo" and value "bar".  Decoding is now
   // unblocked because dynamic table Insert Count reached the Required Insert
@@ -853,7 +859,7 @@
   // the already consumed part of the header block.
   EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("bar")));
   EXPECT_CALL(handler_, OnDecodingErrorDetected(Eq("Invalid relative index.")));
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("6294e703626172"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
 }
 
 // Make sure that Required Insert Count is compared to Insert Count,
@@ -861,19 +867,19 @@
 TEST_P(QpackDecoderTest, BlockedDecodingAndEvictedEntries) {
   // Update dynamic table capacity to 128.
   // At most three non-empty entries fit in the dynamic table.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("3f61"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("3f61"));
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0700"   // Required Insert Count 6 and Delta Base 0.
                // Base is 6 + 0 = 6.
       "80"));  // Indexed Header Field instruction addressing dynamic table
                // entry with relative index 0, absolute index 5.
 
   // Add literal entry with name "foo" and value "bar".
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("6294e703626172"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e703626172"));
 
   // Duplicate entry four times.  This evicts the first two instances.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("00000000"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("00000000"));
 
   EXPECT_CALL(handler_, OnHeaderDecoded(Eq("foo"), Eq("baz")));
   EXPECT_CALL(handler_, OnDecodingCompleted());
@@ -882,13 +888,13 @@
 
   // Add literal entry with name "foo" and value "bar".
   // Insert Count is now 6, reaching Required Insert Count of the header block.
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode("6294e70362617a"));
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode("6294e70362617a"));
 }
 
 TEST_P(QpackDecoderTest, TooManyBlockedStreams) {
   // Required Insert Count 1 and Delta Base 0.
   // Without any dynamic table entries received, decoding is blocked.
-  std::string data = QuicTextUtils::HexDecode("0200");
+  std::string data = quiche::QuicheTextUtils::HexDecode("0200");
 
   auto progressive_decoder1 = CreateProgressiveDecoder(/* stream_id = */ 1);
   progressive_decoder1->Decode(data);
@@ -901,7 +907,7 @@
 }
 
 TEST_P(QpackDecoderTest, InsertCountIncrement) {
-  DecodeEncoderStreamData(QuicTextUtils::HexDecode(
+  DecodeEncoderStreamData(quiche::QuicheTextUtils::HexDecode(
       "3fe107"          // Set dynamic table capacity to 1024.
       "6294e703626172"  // Add literal entry with name "foo" and value "bar".
       "00"));           // Duplicate entry.
@@ -913,11 +919,11 @@
   // Known Insert Count to one.  Decoder should send an Insert Count Increment
   // instruction with increment of one to update Known Insert Count to two.
   EXPECT_CALL(decoder_stream_sender_delegate_,
-              WriteStreamData(Eq(QuicTextUtils::HexDecode(
+              WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode(
                   "81"       // Header Acknowledgement on stream 1
                   "01"))));  // Insert Count Increment with increment of one
 
-  DecodeHeaderBlock(QuicTextUtils::HexDecode(
+  DecodeHeaderBlock(quiche::QuicheTextUtils::HexDecode(
       "0200"   // Required Insert Count 1 and Delta Base 0.
                // Base is 1 + 0 = 1.
       "80"));  // Dynamic table entry with relative index 0, absolute index 0.
diff --git a/quic/core/qpack/qpack_encoder.cc b/quic/core/qpack/qpack_encoder.cc
index 59e172e..2b30e98 100644
--- a/quic/core/qpack/qpack_encoder.cc
+++ b/quic/core/qpack/qpack_encoder.cc
@@ -12,7 +12,8 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_required_insert_count.h"
 #include "net/third_party/quiche/src/quic/core/qpack/value_splitting_header_list.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/common/platform/api/quiche_str_cat.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -57,7 +58,7 @@
 QpackEncoder::EncodeLiteralHeaderFieldWithNameReference(
     bool is_static,
     uint64_t index,
-    QuicStringPiece value,
+    quiche::QuicheStringPiece value,
     QpackBlockingManager::IndexSet* referred_indices) {
   // Add |index| to |*referred_indices| only if entry is in the dynamic table.
   if (!is_static) {
@@ -69,8 +70,8 @@
 
 // static
 QpackInstructionWithValues QpackEncoder::EncodeLiteralHeaderField(
-    QuicStringPiece name,
-    QuicStringPiece value) {
+    quiche::QuicheStringPiece name,
+    quiche::QuicheStringPiece value) {
   return QpackInstructionWithValues::LiteralHeaderField(name, value);
 }
 
@@ -104,8 +105,8 @@
 
   for (const auto& header : ValueSplittingHeaderList(&header_list)) {
     // These strings are owned by |header_list|.
-    QuicStringPiece name = header.first;
-    QuicStringPiece value = header.second;
+    quiche::QuicheStringPiece name = header.first;
+    quiche::QuicheStringPiece value = header.second;
 
     bool is_static;
     uint64_t index;
@@ -397,7 +398,7 @@
 
   if (blocking_manager_.known_received_count() >
       header_table_.inserted_entry_count()) {
-    decoder_stream_error_delegate_->OnDecoderStreamError(QuicStrCat(
+    decoder_stream_error_delegate_->OnDecoderStreamError(quiche::QuicheStrCat(
         "Increment value ", increment, " raises known received count to ",
         blocking_manager_.known_received_count(),
         " exceeding inserted entry count ",
@@ -408,8 +409,8 @@
 void QpackEncoder::OnHeaderAcknowledgement(QuicStreamId stream_id) {
   if (!blocking_manager_.OnHeaderAcknowledgement(stream_id)) {
     decoder_stream_error_delegate_->OnDecoderStreamError(
-        QuicStrCat("Header Acknowledgement received for stream ", stream_id,
-                   " with no outstanding header blocks."));
+        quiche::QuicheStrCat("Header Acknowledgement received for stream ",
+                             stream_id, " with no outstanding header blocks."));
   }
 }
 
@@ -417,7 +418,7 @@
   blocking_manager_.OnStreamCancellation(stream_id);
 }
 
-void QpackEncoder::OnErrorDetected(QuicStringPiece error_message) {
+void QpackEncoder::OnErrorDetected(quiche::QuicheStringPiece error_message) {
   decoder_stream_error_delegate_->OnDecoderStreamError(error_message);
 }
 
diff --git a/quic/core/qpack/qpack_encoder.h b/quic/core/qpack/qpack_encoder.h
index e635e3b..0f1d14c 100644
--- a/quic/core/qpack/qpack_encoder.h
+++ b/quic/core/qpack/qpack_encoder.h
@@ -18,7 +18,7 @@
 #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_exported_stats.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 spdy {
 
@@ -45,7 +45,8 @@
    public:
     virtual ~DecoderStreamErrorDelegate() {}
 
-    virtual void OnDecoderStreamError(QuicStringPiece error_message) = 0;
+    virtual void OnDecoderStreamError(
+        quiche::QuicheStringPiece error_message) = 0;
   };
 
   QpackEncoder(DecoderStreamErrorDelegate* decoder_stream_error_delegate);
@@ -77,7 +78,7 @@
   void OnInsertCountIncrement(uint64_t increment) override;
   void OnHeaderAcknowledgement(QuicStreamId stream_id) override;
   void OnStreamCancellation(QuicStreamId stream_id) override;
-  void OnErrorDetected(QuicStringPiece error_message) override;
+  void OnErrorDetected(quiche::QuicheStringPiece error_message) override;
 
   // delegate must be set if dynamic table capacity is not zero.
   void set_qpack_stream_sender_delegate(QpackStreamSenderDelegate* delegate) {
@@ -110,13 +111,13 @@
   static QpackInstructionWithValues EncodeLiteralHeaderFieldWithNameReference(
       bool is_static,
       uint64_t index,
-      QuicStringPiece value,
+      quiche::QuicheStringPiece value,
       QpackBlockingManager::IndexSet* referred_indices);
 
   // Generate literal header field instruction.
   static QpackInstructionWithValues EncodeLiteralHeaderField(
-      QuicStringPiece name,
-      QuicStringPiece value);
+      quiche::QuicheStringPiece name,
+      quiche::QuicheStringPiece value);
 
   // Performs first pass of two-pass encoding: represent each header field in
   // |*header_list| as a reference to an existing entry, the name of an existing
@@ -127,8 +128,8 @@
   // sets |*encoder_stream_sent_byte_count| to the number of bytes sent on the
   // encoder stream to insert dynamic table entries.  Returns list of header
   // field representations, with all dynamic table entries referred to with
-  // absolute indices.  Returned Instructions object may have QuicStringPieces
-  // pointing to strings owned by |*header_list|.
+  // absolute indices.  Returned Instructions object may have
+  // quiche::QuicheStringPieces pointing to strings owned by |*header_list|.
   Instructions FirstPassEncode(QuicStreamId stream_id,
                                const spdy::SpdyHeaderBlock& header_list,
                                QpackBlockingManager::IndexSet* referred_indices,
diff --git a/quic/core/qpack/qpack_encoder_stream_receiver.cc b/quic/core/qpack/qpack_encoder_stream_receiver.cc
index c46cc3c..56ee232 100644
--- a/quic/core/qpack/qpack_encoder_stream_receiver.cc
+++ b/quic/core/qpack/qpack_encoder_stream_receiver.cc
@@ -7,6 +7,7 @@
 #include "net/third_party/quiche/src/http2/decoder/decode_buffer.h"
 #include "net/third_party/quiche/src/http2/decoder/decode_status.h"
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_instructions.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -17,7 +18,7 @@
   DCHECK(delegate_);
 }
 
-void QpackEncoderStreamReceiver::Decode(QuicStringPiece data) {
+void QpackEncoderStreamReceiver::Decode(quiche::QuicheStringPiece data) {
   if (data.empty() || error_detected_) {
     return;
   }
@@ -50,7 +51,8 @@
   return true;
 }
 
-void QpackEncoderStreamReceiver::OnError(QuicStringPiece error_message) {
+void QpackEncoderStreamReceiver::OnError(
+    quiche::QuicheStringPiece error_message) {
   DCHECK(!error_detected_);
 
   error_detected_ = true;
diff --git a/quic/core/qpack/qpack_encoder_stream_receiver.h b/quic/core/qpack/qpack_encoder_stream_receiver.h
index b393b54..80622e5 100644
--- a/quic/core/qpack/qpack_encoder_stream_receiver.h
+++ b/quic/core/qpack/qpack_encoder_stream_receiver.h
@@ -11,7 +11,7 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_instruction_decoder.h"
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_stream_receiver.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 {
 
@@ -29,16 +29,17 @@
     // 5.2.1. Insert With Name Reference
     virtual void OnInsertWithNameReference(bool is_static,
                                            uint64_t name_index,
-                                           QuicStringPiece value) = 0;
+                                           quiche::QuicheStringPiece value) = 0;
     // 5.2.2. Insert Without Name Reference
-    virtual void OnInsertWithoutNameReference(QuicStringPiece name,
-                                              QuicStringPiece value) = 0;
+    virtual void OnInsertWithoutNameReference(
+        quiche::QuicheStringPiece name,
+        quiche::QuicheStringPiece value) = 0;
     // 5.2.3. Duplicate
     virtual void OnDuplicate(uint64_t index) = 0;
     // 5.2.4. Set Dynamic Table Capacity
     virtual void OnSetDynamicTableCapacity(uint64_t capacity) = 0;
     // Decoding error
-    virtual void OnErrorDetected(QuicStringPiece error_message) = 0;
+    virtual void OnErrorDetected(quiche::QuicheStringPiece error_message) = 0;
   };
 
   explicit QpackEncoderStreamReceiver(Delegate* delegate);
@@ -52,11 +53,11 @@
   // Decode data and call appropriate Delegate method after each decoded
   // instruction.  Once an error occurs, Delegate::OnErrorDetected() is called,
   // and all further data is ignored.
-  void Decode(QuicStringPiece data) override;
+  void Decode(quiche::QuicheStringPiece data) override;
 
   // QpackInstructionDecoder::Delegate implementation.
   bool OnInstructionDecoded(const QpackInstruction* instruction) override;
-  void OnError(QuicStringPiece error_message) override;
+  void OnError(quiche::QuicheStringPiece error_message) override;
 
  private:
   QpackInstructionDecoder instruction_decoder_;
diff --git a/quic/core/qpack/qpack_encoder_stream_receiver_test.cc b/quic/core/qpack/qpack_encoder_stream_receiver_test.cc
index f012390..b5edd5f 100644
--- a/quic/core/qpack/qpack_encoder_stream_receiver_test.cc
+++ b/quic/core/qpack/qpack_encoder_stream_receiver_test.cc
@@ -5,7 +5,8 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_encoder_stream_receiver.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 testing::Eq;
 using testing::StrictMock;
@@ -21,12 +22,13 @@
   MOCK_METHOD3(OnInsertWithNameReference,
                void(bool is_static,
                     uint64_t name_index,
-                    QuicStringPiece value));
+                    quiche::QuicheStringPiece value));
   MOCK_METHOD2(OnInsertWithoutNameReference,
-               void(QuicStringPiece name, QuicStringPiece value));
+               void(quiche::QuicheStringPiece name,
+                    quiche::QuicheStringPiece value));
   MOCK_METHOD1(OnDuplicate, void(uint64_t index));
   MOCK_METHOD1(OnSetDynamicTableCapacity, void(uint64_t capacity));
-  MOCK_METHOD1(OnErrorDetected, void(QuicStringPiece error_message));
+  MOCK_METHOD1(OnErrorDetected, void(quiche::QuicheStringPiece error_message));
 };
 
 class QpackEncoderStreamReceiverTest : public QuicTest {
@@ -34,7 +36,7 @@
   QpackEncoderStreamReceiverTest() : stream_(&delegate_) {}
   ~QpackEncoderStreamReceiverTest() override = default;
 
-  void Decode(QuicStringPiece data) { stream_.Decode(data); }
+  void Decode(quiche::QuicheStringPiece data) { stream_.Decode(data); }
   StrictMock<MockDelegate>* delegate() { return &delegate_; }
 
  private:
@@ -54,7 +56,7 @@
   EXPECT_CALL(*delegate(),
               OnInsertWithNameReference(false, 42, Eq(std::string(127, 'Z'))));
 
-  Decode(QuicTextUtils::HexDecode(
+  Decode(quiche::QuicheTextUtils::HexDecode(
       "c500"
       "c28294e7"
       "bf4a03626172"
@@ -67,13 +69,13 @@
 TEST_F(QpackEncoderStreamReceiverTest, InsertWithNameReferenceIndexTooLarge) {
   EXPECT_CALL(*delegate(), OnErrorDetected(Eq("Encoded integer too large.")));
 
-  Decode(QuicTextUtils::HexDecode("bfffffffffffffffffffffff"));
+  Decode(quiche::QuicheTextUtils::HexDecode("bfffffffffffffffffffffff"));
 }
 
 TEST_F(QpackEncoderStreamReceiverTest, InsertWithNameReferenceValueTooLong) {
   EXPECT_CALL(*delegate(), OnErrorDetected(Eq("Encoded integer too large.")));
 
-  Decode(QuicTextUtils::HexDecode("c57fffffffffffffffffffff"));
+  Decode(quiche::QuicheTextUtils::HexDecode("c57fffffffffffffffffffff"));
 }
 
 TEST_F(QpackEncoderStreamReceiverTest, InsertWithoutNameReference) {
@@ -89,7 +91,7 @@
               OnInsertWithoutNameReference(Eq(std::string(31, 'Z')),
                                            Eq(std::string(127, 'Z'))));
 
-  Decode(QuicTextUtils::HexDecode(
+  Decode(quiche::QuicheTextUtils::HexDecode(
       "4000"
       "4362617203626172"
       "6294e78294e7"
@@ -105,7 +107,7 @@
        InsertWithoutNameReferenceNameTooLongForVarintDecoder) {
   EXPECT_CALL(*delegate(), OnErrorDetected(Eq("Encoded integer too large.")));
 
-  Decode(QuicTextUtils::HexDecode("5fffffffffffffffffffff"));
+  Decode(quiche::QuicheTextUtils::HexDecode("5fffffffffffffffffffff"));
 }
 
 // Name Length value can be decoded by varint decoder but exceeds 1 MB limit.
@@ -113,7 +115,7 @@
        InsertWithoutNameReferenceNameExceedsLimit) {
   EXPECT_CALL(*delegate(), OnErrorDetected(Eq("String literal too long.")));
 
-  Decode(QuicTextUtils::HexDecode("5fffff7f"));
+  Decode(quiche::QuicheTextUtils::HexDecode("5fffff7f"));
 }
 
 // Value Length value is too large for varint decoder to decode.
@@ -121,7 +123,7 @@
        InsertWithoutNameReferenceValueTooLongForVarintDecoder) {
   EXPECT_CALL(*delegate(), OnErrorDetected(Eq("Encoded integer too large.")));
 
-  Decode(QuicTextUtils::HexDecode("436261727fffffffffffffffffffff"));
+  Decode(quiche::QuicheTextUtils::HexDecode("436261727fffffffffffffffffffff"));
 }
 
 // Value Length value can be decoded by varint decoder but exceeds 1 MB limit.
@@ -129,7 +131,7 @@
        InsertWithoutNameReferenceValueExceedsLimit) {
   EXPECT_CALL(*delegate(), OnErrorDetected(Eq("String literal too long.")));
 
-  Decode(QuicTextUtils::HexDecode("436261727fffff7f"));
+  Decode(quiche::QuicheTextUtils::HexDecode("436261727fffff7f"));
 }
 
 TEST_F(QpackEncoderStreamReceiverTest, Duplicate) {
@@ -138,13 +140,13 @@
   // Large index requires two extension bytes.
   EXPECT_CALL(*delegate(), OnDuplicate(500));
 
-  Decode(QuicTextUtils::HexDecode("111fd503"));
+  Decode(quiche::QuicheTextUtils::HexDecode("111fd503"));
 }
 
 TEST_F(QpackEncoderStreamReceiverTest, DuplicateIndexTooLarge) {
   EXPECT_CALL(*delegate(), OnErrorDetected(Eq("Encoded integer too large.")));
 
-  Decode(QuicTextUtils::HexDecode("1fffffffffffffffffffff"));
+  Decode(quiche::QuicheTextUtils::HexDecode("1fffffffffffffffffffff"));
 }
 
 TEST_F(QpackEncoderStreamReceiverTest, SetDynamicTableCapacity) {
@@ -153,13 +155,13 @@
   // Large capacity requires two extension bytes.
   EXPECT_CALL(*delegate(), OnSetDynamicTableCapacity(500));
 
-  Decode(QuicTextUtils::HexDecode("313fd503"));
+  Decode(quiche::QuicheTextUtils::HexDecode("313fd503"));
 }
 
 TEST_F(QpackEncoderStreamReceiverTest, SetDynamicTableCapacityTooLarge) {
   EXPECT_CALL(*delegate(), OnErrorDetected(Eq("Encoded integer too large.")));
 
-  Decode(QuicTextUtils::HexDecode("3fffffffffffffffffffff"));
+  Decode(quiche::QuicheTextUtils::HexDecode("3fffffffffffffffffffff"));
 }
 
 }  // namespace
diff --git a/quic/core/qpack/qpack_encoder_stream_sender.cc b/quic/core/qpack/qpack_encoder_stream_sender.cc
index 5182864..19311b6 100644
--- a/quic/core/qpack/qpack_encoder_stream_sender.cc
+++ b/quic/core/qpack/qpack_encoder_stream_sender.cc
@@ -10,6 +10,7 @@
 
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_instructions.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"
 
 namespace quic {
 
@@ -18,7 +19,7 @@
 void QpackEncoderStreamSender::SendInsertWithNameReference(
     bool is_static,
     uint64_t name_index,
-    QuicStringPiece value) {
+    quiche::QuicheStringPiece value) {
   instruction_encoder_.Encode(
       QpackInstructionWithValues::InsertWithNameReference(is_static, name_index,
                                                           value),
@@ -26,8 +27,8 @@
 }
 
 void QpackEncoderStreamSender::SendInsertWithoutNameReference(
-    QuicStringPiece name,
-    QuicStringPiece value) {
+    quiche::QuicheStringPiece name,
+    quiche::QuicheStringPiece value) {
   instruction_encoder_.Encode(
       QpackInstructionWithValues::InsertWithoutNameReference(name, value),
       &buffer_);
diff --git a/quic/core/qpack/qpack_encoder_stream_sender.h b/quic/core/qpack/qpack_encoder_stream_sender.h
index de9e8f1..5701db5 100644
--- a/quic/core/qpack/qpack_encoder_stream_sender.h
+++ b/quic/core/qpack/qpack_encoder_stream_sender.h
@@ -11,7 +11,7 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_stream_sender_delegate.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 {
 
@@ -29,10 +29,10 @@
   // 5.2.1. Insert With Name Reference
   void SendInsertWithNameReference(bool is_static,
                                    uint64_t name_index,
-                                   QuicStringPiece value);
+                                   quiche::QuicheStringPiece value);
   // 5.2.2. Insert Without Name Reference
-  void SendInsertWithoutNameReference(QuicStringPiece name,
-                                      QuicStringPiece value);
+  void SendInsertWithoutNameReference(quiche::QuicheStringPiece name,
+                                      quiche::QuicheStringPiece value);
   // 5.2.3. Duplicate
   void SendDuplicate(uint64_t index);
   // 5.2.4. Set Dynamic Table Capacity
diff --git a/quic/core/qpack/qpack_encoder_stream_sender_test.cc b/quic/core/qpack/qpack_encoder_stream_sender_test.cc
index 0a42df2..b3fd5f9 100644
--- a/quic/core/qpack/qpack_encoder_stream_sender_test.cc
+++ b/quic/core/qpack/qpack_encoder_stream_sender_test.cc
@@ -5,8 +5,8 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_encoder_stream_sender.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/common/platform/api/quiche_text_utils.h"
 
 using ::testing::Eq;
 using ::testing::StrictMock;
@@ -28,26 +28,27 @@
 
 TEST_F(QpackEncoderStreamSenderTest, InsertWithNameReference) {
   // Static, index fits in prefix, empty value.
-  std::string expected_encoded_data = QuicTextUtils::HexDecode("c500");
+  std::string expected_encoded_data =
+      quiche::QuicheTextUtils::HexDecode("c500");
   EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
   stream_.SendInsertWithNameReference(true, 5, "");
   EXPECT_EQ(expected_encoded_data.size(), stream_.Flush());
 
   // Static, index fits in prefix, Huffman encoded value.
-  expected_encoded_data = QuicTextUtils::HexDecode("c28294e7");
+  expected_encoded_data = quiche::QuicheTextUtils::HexDecode("c28294e7");
   EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
   stream_.SendInsertWithNameReference(true, 2, "foo");
   EXPECT_EQ(expected_encoded_data.size(), stream_.Flush());
 
   // Not static, index does not fit in prefix, not Huffman encoded value.
-  expected_encoded_data = QuicTextUtils::HexDecode("bf4a03626172");
+  expected_encoded_data = quiche::QuicheTextUtils::HexDecode("bf4a03626172");
   EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
   stream_.SendInsertWithNameReference(false, 137, "bar");
   EXPECT_EQ(expected_encoded_data.size(), stream_.Flush());
 
   // Value length does not fit in prefix.
   // 'Z' would be Huffman encoded to 8 bits, so no Huffman encoding is used.
-  expected_encoded_data = QuicTextUtils::HexDecode(
+  expected_encoded_data = quiche::QuicheTextUtils::HexDecode(
       "aa7f005a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"
       "5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"
       "5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"
@@ -59,26 +60,28 @@
 
 TEST_F(QpackEncoderStreamSenderTest, InsertWithoutNameReference) {
   // Empty name and value.
-  std::string expected_encoded_data = QuicTextUtils::HexDecode("4000");
+  std::string expected_encoded_data =
+      quiche::QuicheTextUtils::HexDecode("4000");
   EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
   stream_.SendInsertWithoutNameReference("", "");
   EXPECT_EQ(expected_encoded_data.size(), stream_.Flush());
 
   // Huffman encoded short strings.
-  expected_encoded_data = QuicTextUtils::HexDecode("6294e78294e7");
+  expected_encoded_data = quiche::QuicheTextUtils::HexDecode("6294e78294e7");
   EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
   stream_.SendInsertWithoutNameReference("foo", "foo");
   EXPECT_EQ(expected_encoded_data.size(), stream_.Flush());
 
   // Not Huffman encoded short strings.
-  expected_encoded_data = QuicTextUtils::HexDecode("4362617203626172");
+  expected_encoded_data =
+      quiche::QuicheTextUtils::HexDecode("4362617203626172");
   EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
   stream_.SendInsertWithoutNameReference("bar", "bar");
   EXPECT_EQ(expected_encoded_data.size(), stream_.Flush());
 
   // Not Huffman encoded long strings; length does not fit on prefix.
   // 'Z' would be Huffman encoded to 8 bits, so no Huffman encoding is used.
-  expected_encoded_data = QuicTextUtils::HexDecode(
+  expected_encoded_data = quiche::QuicheTextUtils::HexDecode(
       "5f005a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a7f"
       "005a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"
       "5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a"
@@ -92,13 +95,13 @@
 
 TEST_F(QpackEncoderStreamSenderTest, Duplicate) {
   // Small index fits in prefix.
-  std::string expected_encoded_data = QuicTextUtils::HexDecode("11");
+  std::string expected_encoded_data = quiche::QuicheTextUtils::HexDecode("11");
   EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
   stream_.SendDuplicate(17);
   EXPECT_EQ(expected_encoded_data.size(), stream_.Flush());
 
   // Large index requires two extension bytes.
-  expected_encoded_data = QuicTextUtils::HexDecode("1fd503");
+  expected_encoded_data = quiche::QuicheTextUtils::HexDecode("1fd503");
   EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
   stream_.SendDuplicate(500);
   EXPECT_EQ(expected_encoded_data.size(), stream_.Flush());
@@ -106,13 +109,13 @@
 
 TEST_F(QpackEncoderStreamSenderTest, SetDynamicTableCapacity) {
   // Small capacity fits in prefix.
-  std::string expected_encoded_data = QuicTextUtils::HexDecode("31");
+  std::string expected_encoded_data = quiche::QuicheTextUtils::HexDecode("31");
   EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
   stream_.SendSetDynamicTableCapacity(17);
   EXPECT_EQ(expected_encoded_data.size(), stream_.Flush());
 
   // Large capacity requires two extension bytes.
-  expected_encoded_data = QuicTextUtils::HexDecode("3fd503");
+  expected_encoded_data = quiche::QuicheTextUtils::HexDecode("3fd503");
   EXPECT_CALL(delegate_, WriteStreamData(Eq(expected_encoded_data)));
   stream_.SendSetDynamicTableCapacity(500);
   EXPECT_EQ(expected_encoded_data.size(), stream_.Flush());
@@ -132,7 +135,7 @@
   // Duplicate entry.
   stream_.SendDuplicate(17);
 
-  std::string expected_encoded_data = QuicTextUtils::HexDecode(
+  std::string expected_encoded_data = quiche::QuicheTextUtils::HexDecode(
       "c500"          // Insert entry with static name reference.
       "c28294e7"      // Insert entry with static name reference.
       "6294e78294e7"  // Insert literal entry.
diff --git a/quic/core/qpack/qpack_encoder_test.cc b/quic/core/qpack/qpack_encoder_test.cc
index 6b92e4b..212257c 100644
--- a/quic/core/qpack/qpack_encoder_test.cc
+++ b/quic/core/qpack/qpack_encoder_test.cc
@@ -8,11 +8,12 @@
 #include <string>
 
 #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_encoder_test_utils.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"
+#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;
@@ -48,7 +49,7 @@
   spdy::SpdyHeaderBlock header_list;
   std::string output = Encode(header_list);
 
-  EXPECT_EQ(QuicTextUtils::HexDecode("0000"), output);
+  EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("0000"), output);
 }
 
 TEST_F(QpackEncoderTest, EmptyName) {
@@ -56,7 +57,7 @@
   header_list[""] = "foo";
   std::string output = Encode(header_list);
 
-  EXPECT_EQ(QuicTextUtils::HexDecode("0000208294e7"), output);
+  EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("0000208294e7"), output);
 }
 
 TEST_F(QpackEncoderTest, EmptyValue) {
@@ -64,7 +65,7 @@
   header_list["foo"] = "";
   std::string output = Encode(header_list);
 
-  EXPECT_EQ(QuicTextUtils::HexDecode("00002a94e700"), output);
+  EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("00002a94e700"), output);
 }
 
 TEST_F(QpackEncoderTest, EmptyNameAndValue) {
@@ -72,7 +73,7 @@
   header_list[""] = "";
   std::string output = Encode(header_list);
 
-  EXPECT_EQ(QuicTextUtils::HexDecode("00002000"), output);
+  EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("00002000"), output);
 }
 
 TEST_F(QpackEncoderTest, Simple) {
@@ -80,7 +81,7 @@
   header_list["foo"] = "bar";
   std::string output = Encode(header_list);
 
-  EXPECT_EQ(QuicTextUtils::HexDecode("00002a94e703626172"), output);
+  EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("00002a94e703626172"), output);
 }
 
 TEST_F(QpackEncoderTest, Multiple) {
@@ -91,7 +92,7 @@
   std::string output = Encode(header_list);
 
   EXPECT_EQ(
-      QuicTextUtils::HexDecode(
+      quiche::QuicheTextUtils::HexDecode(
           "0000"                // prefix
           "2a94e703626172"      // foo: bar
           "27005a5a5a5a5a5a5a"  // 7 octet long header name, the smallest number
@@ -113,7 +114,7 @@
     header_list["location"] = "";
 
     std::string output = Encode(header_list);
-    EXPECT_EQ(QuicTextUtils::HexDecode("0000d1dfcc"), output);
+    EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("0000d1dfcc"), output);
   }
   {
     spdy::SpdyHeaderBlock header_list;
@@ -122,8 +123,9 @@
     header_list["location"] = "foo";
 
     std::string output = Encode(header_list);
-    EXPECT_EQ(QuicTextUtils::HexDecode("0000d45f108621e9aec2a11f5c8294e7"),
-              output);
+    EXPECT_EQ(
+        quiche::QuicheTextUtils::HexDecode("0000d45f108621e9aec2a11f5c8294e7"),
+        output);
   }
   {
     spdy::SpdyHeaderBlock header_list;
@@ -131,7 +133,8 @@
     header_list["accept-encoding"] = "";
 
     std::string output = Encode(header_list);
-    EXPECT_EQ(QuicTextUtils::HexDecode("00005f000554524143455f1000"), output);
+    EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("00005f000554524143455f1000"),
+              output);
   }
 }
 
@@ -142,19 +145,19 @@
   QpackEncoder encoder(&decoder_stream_error_delegate_);
   encoder.set_qpack_stream_sender_delegate(&encoder_stream_sender_delegate_);
   encoder.decoder_stream_receiver()->Decode(
-      QuicTextUtils::HexDecode("ffffffffffffffffffffff"));
+      quiche::QuicheTextUtils::HexDecode("ffffffffffffffffffffff"));
 }
 
 TEST_F(QpackEncoderTest, SplitAlongNullCharacter) {
   spdy::SpdyHeaderBlock header_list;
-  header_list["foo"] = QuicStringPiece("bar\0bar\0baz", 11);
+  header_list["foo"] = quiche::QuicheStringPiece("bar\0bar\0baz", 11);
   std::string output = Encode(header_list);
 
-  EXPECT_EQ(QuicTextUtils::HexDecode("0000"            // prefix
-                                     "2a94e703626172"  // foo: bar
-                                     "2a94e703626172"  // foo: bar
-                                     "2a94e70362617a"  // foo: baz
-                                     ),
+  EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("0000"            // prefix
+                                               "2a94e703626172"  // foo: bar
+                                               "2a94e703626172"  // foo: bar
+                                               "2a94e70362617a"  // foo: baz
+                                               ),
             output);
 }
 
@@ -212,8 +215,9 @@
   encoder_.SetMaximumDynamicTableCapacity(4096);
 
   // Set Dynamic Table Capacity instruction.
-  EXPECT_CALL(encoder_stream_sender_delegate_,
-              WriteStreamData(Eq(QuicTextUtils::HexDecode("3fe11f"))));
+  EXPECT_CALL(
+      encoder_stream_sender_delegate_,
+      WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("3fe11f"))));
   encoder_.SetDynamicTableCapacity(4096);
 
   spdy::SpdyHeaderBlock header_list;
@@ -223,7 +227,7 @@
   header_list["cookie"] = "baz";              // name matches static entry
 
   // Insert three entries into the dynamic table.
-  std::string insert_entries = QuicTextUtils::HexDecode(
+  std::string insert_entries = quiche::QuicheTextUtils::HexDecode(
       "62"          // insert without name reference
       "94e7"        // Huffman-encoded name "foo"
       "03626172"    // value "bar"
@@ -234,7 +238,7 @@
   EXPECT_CALL(encoder_stream_sender_delegate_,
               WriteStreamData(Eq(insert_entries)));
 
-  EXPECT_EQ(QuicTextUtils::HexDecode(
+  EXPECT_EQ(quiche::QuicheTextUtils::HexDecode(
                 "0400"      // prefix
                 "828180"),  // dynamic entries with relative index 0, 1, and 2
             Encode(header_list));
@@ -249,7 +253,7 @@
 
   // Set Dynamic Table Capacity instruction.
   EXPECT_CALL(encoder_stream_sender_delegate_,
-              WriteStreamData(Eq(QuicTextUtils::HexDecode("3f07"))));
+              WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("3f07"))));
   encoder_.SetDynamicTableCapacity(QpackEntry::Size("foo", "bar"));
 
   spdy::SpdyHeaderBlock header_list;
@@ -260,21 +264,22 @@
   header_list["bar"] = "baz";                 // no match
 
   // Insert one entry into the dynamic table.
-  std::string insert_entry = QuicTextUtils::HexDecode(
+  std::string insert_entry = quiche::QuicheTextUtils::HexDecode(
       "62"          // insert without name reference
       "94e7"        // Huffman-encoded name "foo"
       "03626172");  // value "bar"
   EXPECT_CALL(encoder_stream_sender_delegate_,
               WriteStreamData(Eq(insert_entry)));
 
-  EXPECT_EQ(QuicTextUtils::HexDecode("0200"  // prefix
-                                     "80"    // dynamic entry 0
-                                     "40"  // reference to dynamic entry 0 name
-                                     "0362617a"  // with literal value "baz"
-                                     "55"  // reference to static entry 5 name
-                                     "0362617a"    // with literal value "baz"
-                                     "23626172"    // literal name "bar"
-                                     "0362617a"),  // with literal value "baz"
+  EXPECT_EQ(quiche::QuicheTextUtils::HexDecode(
+                "0200"        // prefix
+                "80"          // dynamic entry 0
+                "40"          // reference to dynamic entry 0 name
+                "0362617a"    // with literal value "baz"
+                "55"          // reference to static entry 5 name
+                "0362617a"    // with literal value "baz"
+                "23626172"    // literal name "bar"
+                "0362617a"),  // with literal value "baz"
             Encode(header_list));
 
   EXPECT_EQ(insert_entry.size(), encoder_stream_sent_byte_count_);
@@ -285,23 +290,24 @@
   encoder_.SetMaximumDynamicTableCapacity(4096);
 
   // Set Dynamic Table Capacity instruction.
-  EXPECT_CALL(encoder_stream_sender_delegate_,
-              WriteStreamData(Eq(QuicTextUtils::HexDecode("3fe11f"))));
+  EXPECT_CALL(
+      encoder_stream_sender_delegate_,
+      WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("3fe11f"))));
   encoder_.SetDynamicTableCapacity(4096);
 
   spdy::SpdyHeaderBlock header_list1;
   header_list1["foo"] = "bar";
 
   // Insert one entry into the dynamic table.
-  std::string insert_entry1 = QuicTextUtils::HexDecode(
+  std::string insert_entry1 = quiche::QuicheTextUtils::HexDecode(
       "62"          // insert without name reference
       "94e7"        // Huffman-encoded name "foo"
       "03626172");  // value "bar"
   EXPECT_CALL(encoder_stream_sender_delegate_,
               WriteStreamData(Eq(insert_entry1)));
 
-  EXPECT_EQ(QuicTextUtils::HexDecode("0200"  // prefix
-                                     "80"),  // dynamic entry 0
+  EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("0200"  // prefix
+                                               "80"),  // dynamic entry 0
             encoder_.EncodeHeaderList(/* stream_id = */ 1, header_list1,
                                       &encoder_stream_sent_byte_count_));
   EXPECT_EQ(insert_entry1.size(), encoder_stream_sent_byte_count_);
@@ -314,15 +320,16 @@
   header_list2["cookie"] = "baz";              // name matches static entry
   header_list2["bar"] = "baz";                 // no match
 
-  EXPECT_EQ(QuicTextUtils::HexDecode("0000"        // prefix
-                                     "2a94e7"      // literal name "foo"
-                                     "03626172"    // with literal value "bar"
-                                     "2a94e7"      // literal name "foo"
-                                     "0362617a"    // with literal value "baz"
-                                     "55"          // name of static entry 5
-                                     "0362617a"    // with literal value "baz"
-                                     "23626172"    // literal name "bar"
-                                     "0362617a"),  // with literal value "baz"
+  EXPECT_EQ(quiche::QuicheTextUtils::HexDecode(
+                "0000"        // prefix
+                "2a94e7"      // literal name "foo"
+                "03626172"    // with literal value "bar"
+                "2a94e7"      // literal name "foo"
+                "0362617a"    // with literal value "baz"
+                "55"          // name of static entry 5
+                "0362617a"    // with literal value "baz"
+                "23626172"    // literal name "bar"
+                "0362617a"),  // with literal value "baz"
             encoder_.EncodeHeaderList(/* stream_id = */ 2, header_list2,
                                       &encoder_stream_sent_byte_count_));
   EXPECT_EQ(0u, encoder_stream_sent_byte_count_);
@@ -332,7 +339,7 @@
   encoder_.OnInsertCountIncrement(1);
 
   // Insert three entries into the dynamic table.
-  std::string insert_entries = QuicTextUtils::HexDecode(
+  std::string insert_entries = quiche::QuicheTextUtils::HexDecode(
       "80"          // insert with name reference, dynamic index 0
       "0362617a"    // value "baz"
       "c5"          // insert with name reference, static index 5
@@ -343,22 +350,23 @@
   EXPECT_CALL(encoder_stream_sender_delegate_,
               WriteStreamData(Eq(insert_entries)));
 
-  EXPECT_EQ(QuicTextUtils::HexDecode("0500"        // prefix
-                                     "83828180"),  // dynamic entries
+  EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("0500"        // prefix
+                                               "83828180"),  // dynamic entries
             encoder_.EncodeHeaderList(/* stream_id = */ 3, header_list2,
                                       &encoder_stream_sent_byte_count_));
   EXPECT_EQ(insert_entries.size(), encoder_stream_sent_byte_count_);
 
   // Stream 3 is blocked.  Stream 4 is not allowed to block, but it can
   // reference already acknowledged dynamic entry 0.
-  EXPECT_EQ(QuicTextUtils::HexDecode("0200"        // prefix
-                                     "80"          // dynamic entry 0
-                                     "2a94e7"      // literal name "foo"
-                                     "0362617a"    // with literal value "baz"
-                                     "2c21cfd4c5"  // literal name "cookie"
-                                     "0362617a"    // with literal value "baz"
-                                     "23626172"    // literal name "bar"
-                                     "0362617a"),  // with literal value "baz"
+  EXPECT_EQ(quiche::QuicheTextUtils::HexDecode(
+                "0200"        // prefix
+                "80"          // dynamic entry 0
+                "2a94e7"      // literal name "foo"
+                "0362617a"    // with literal value "baz"
+                "2c21cfd4c5"  // literal name "cookie"
+                "0362617a"    // with literal value "baz"
+                "23626172"    // literal name "bar"
+                "0362617a"),  // with literal value "baz"
             encoder_.EncodeHeaderList(/* stream_id = */ 4, header_list2,
                                       &encoder_stream_sent_byte_count_));
   EXPECT_EQ(0u, encoder_stream_sent_byte_count_);
@@ -369,10 +377,11 @@
 
   // Stream 5 is not allowed to block, but it can reference already acknowledged
   // dynamic entries 0, 1, and 2.
-  EXPECT_EQ(QuicTextUtils::HexDecode("0400"        // prefix
-                                     "828180"      // dynamic entries
-                                     "23626172"    // literal name "bar"
-                                     "0362617a"),  // with literal value "baz"
+  EXPECT_EQ(quiche::QuicheTextUtils::HexDecode(
+                "0400"        // prefix
+                "828180"      // dynamic entries
+                "23626172"    // literal name "bar"
+                "0362617a"),  // with literal value "baz"
             encoder_.EncodeHeaderList(/* stream_id = */ 5, header_list2,
                                       &encoder_stream_sent_byte_count_));
   EXPECT_EQ(0u, encoder_stream_sent_byte_count_);
@@ -381,8 +390,8 @@
   // Stream 3 is not blocked any longer.
   encoder_.OnHeaderAcknowledgement(3);
 
-  EXPECT_EQ(QuicTextUtils::HexDecode("0500"        // prefix
-                                     "83828180"),  // dynamic entries
+  EXPECT_EQ(quiche::QuicheTextUtils::HexDecode("0500"        // prefix
+                                               "83828180"),  // dynamic entries
             encoder_.EncodeHeaderList(/* stream_id = */ 6, header_list2,
                                       &encoder_stream_sent_byte_count_));
   EXPECT_EQ(0u, encoder_stream_sent_byte_count_);
@@ -419,10 +428,10 @@
   // Insert ten entries into the dynamic table.
   EXPECT_CALL(encoder_stream_sender_delegate_, WriteStreamData(_));
 
-  EXPECT_EQ(
-      QuicTextUtils::HexDecode("0b00"                    // prefix
-                               "89888786858483828180"),  // dynamic entries
-      Encode(header_list1));
+  EXPECT_EQ(quiche::QuicheTextUtils::HexDecode(
+                "0b00"                    // prefix
+                "89888786858483828180"),  // dynamic entries
+            Encode(header_list1));
 
   // Entry is identical to oldest one, which is draining.  It will be
   // duplicated and referenced.
@@ -431,10 +440,11 @@
 
   // Duplicate oldest entry.
   EXPECT_CALL(encoder_stream_sender_delegate_,
-              WriteStreamData(Eq(QuicTextUtils::HexDecode("09"))));
+              WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("09"))));
 
-  EXPECT_EQ(QuicTextUtils::HexDecode("0c00"  // prefix
-                                     "80"),  // most recent dynamic table entry
+  EXPECT_EQ(quiche::QuicheTextUtils::HexDecode(
+                "0c00"  // prefix
+                "80"),  // most recent dynamic table entry
             Encode(header_list2));
 
   spdy::SpdyHeaderBlock header_list3;
@@ -445,12 +455,13 @@
   // no room to insert new entry, it will be encoded with string literals.
   header_list3.AppendValueOrAddHeader("two", "bar");
 
-  EXPECT_EQ(QuicTextUtils::HexDecode("0000"        // prefix
-                                     "2374776f"    // literal name "two"
-                                     "8294e7"      // literal value "foo"
-                                     "2374776f"    // literal name "two"
-                                     "03626172"),  // literal value "bar"
-            Encode(header_list3));
+  EXPECT_EQ(
+      quiche::QuicheTextUtils::HexDecode("0000"        // prefix
+                                         "2374776f"    // literal name "two"
+                                         "8294e7"      // literal value "foo"
+                                         "2374776f"    // literal name "two"
+                                         "03626172"),  // literal value "bar"
+      Encode(header_list3));
 }
 
 TEST_F(QpackEncoderTest, DynamicTableCapacityLessThanMaximum) {
@@ -458,7 +469,7 @@
 
   // Set Dynamic Table Capacity instruction.
   EXPECT_CALL(encoder_stream_sender_delegate_,
-              WriteStreamData(Eq(QuicTextUtils::HexDecode("3e"))));
+              WriteStreamData(Eq(quiche::QuicheTextUtils::HexDecode("3e"))));
   encoder_.SetDynamicTableCapacity(30);
 
   QpackHeaderTable* header_table = QpackEncoderPeer::header_table(&encoder_);
diff --git a/quic/core/qpack/qpack_header_table.cc b/quic/core/qpack/qpack_header_table.cc
index 4cafa19..472db89 100644
--- a/quic/core/qpack/qpack_header_table.cc
+++ b/quic/core/qpack/qpack_header_table.cc
@@ -6,6 +6,7 @@
 
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_static_table.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"
 
 namespace quic {
 
@@ -50,8 +51,8 @@
 }
 
 QpackHeaderTable::MatchType QpackHeaderTable::FindHeaderField(
-    QuicStringPiece name,
-    QuicStringPiece value,
+    quiche::QuicheStringPiece name,
+    quiche::QuicheStringPiece value,
     bool* is_static,
     uint64_t* index) const {
   QpackEntry query(name, value);
@@ -95,8 +96,9 @@
   return MatchType::kNoMatch;
 }
 
-const QpackEntry* QpackHeaderTable::InsertEntry(QuicStringPiece name,
-                                                QuicStringPiece value) {
+const QpackEntry* QpackHeaderTable::InsertEntry(
+    quiche::QuicheStringPiece name,
+    quiche::QuicheStringPiece value) {
   const uint64_t entry_size = QpackEntry::Size(name, value);
   if (entry_size > dynamic_table_capacity_) {
     return nullptr;
diff --git a/quic/core/qpack/qpack_header_table.h b/quic/core/qpack/qpack_header_table.h
index dd5ca3b..e3fb975 100644
--- a/quic/core/qpack/qpack_header_table.h
+++ b/quic/core/qpack/qpack_header_table.h
@@ -11,7 +11,7 @@
 #include <vector>
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_entry.h"
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_header_table.h"
 
@@ -70,15 +70,16 @@
   // Returns the absolute index of an entry with matching name and value if such
   // exists, otherwise one with matching name is such exists.  |index| is zero
   // based for both the static and the dynamic table.
-  MatchType FindHeaderField(QuicStringPiece name,
-                            QuicStringPiece value,
+  MatchType FindHeaderField(quiche::QuicheStringPiece name,
+                            quiche::QuicheStringPiece value,
                             bool* is_static,
                             uint64_t* index) const;
 
   // Insert (name, value) into the dynamic table.  May evict entries.  Returns a
   // pointer to the inserted owned entry on success.  Returns nullptr if entry
   // is larger than the capacity of the dynamic table.
-  const QpackEntry* InsertEntry(QuicStringPiece name, QuicStringPiece value);
+  const QpackEntry* InsertEntry(quiche::QuicheStringPiece name,
+                                quiche::QuicheStringPiece value);
 
   // Returns the size of the largest entry that could be inserted into the
   // dynamic table without evicting entry |index|.  |index| might be larger than
diff --git a/quic/core/qpack/qpack_header_table_test.cc b/quic/core/qpack/qpack_header_table_test.cc
index 5638aff..071c65c 100644
--- a/quic/core/qpack/qpack_header_table_test.cc
+++ b/quic/core/qpack/qpack_header_table_test.cc
@@ -9,6 +9,7 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_static_table.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.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"
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_entry.h"
 
 using ::testing::Mock;
@@ -39,8 +40,8 @@
 
   void ExpectEntryAtIndex(bool is_static,
                           uint64_t index,
-                          QuicStringPiece expected_name,
-                          QuicStringPiece expected_value) const {
+                          quiche::QuicheStringPiece expected_name,
+                          quiche::QuicheStringPiece expected_value) const {
     const auto* entry = table_.LookupEntry(is_static, index);
     ASSERT_TRUE(entry);
     EXPECT_EQ(expected_name, entry->name());
@@ -51,8 +52,8 @@
     EXPECT_FALSE(table_.LookupEntry(is_static, index));
   }
 
-  void ExpectMatch(QuicStringPiece name,
-                   QuicStringPiece value,
+  void ExpectMatch(quiche::QuicheStringPiece name,
+                   quiche::QuicheStringPiece value,
                    QpackHeaderTable::MatchType expected_match_type,
                    bool expected_is_static,
                    uint64_t expected_index) const {
@@ -69,7 +70,8 @@
     EXPECT_EQ(expected_index, index) << name << ": " << value;
   }
 
-  void ExpectNoMatch(QuicStringPiece name, QuicStringPiece value) const {
+  void ExpectNoMatch(quiche::QuicheStringPiece name,
+                     quiche::QuicheStringPiece value) const {
     bool is_static = false;
     uint64_t index = 0;
 
@@ -80,11 +82,13 @@
         << name << ": " << value;
   }
 
-  void InsertEntry(QuicStringPiece name, QuicStringPiece value) {
+  void InsertEntry(quiche::QuicheStringPiece name,
+                   quiche::QuicheStringPiece value) {
     EXPECT_TRUE(table_.InsertEntry(name, value));
   }
 
-  void ExpectToFailInsertingEntry(QuicStringPiece name, QuicStringPiece value) {
+  void ExpectToFailInsertingEntry(quiche::QuicheStringPiece name,
+                                  quiche::QuicheStringPiece value) {
     EXPECT_FALSE(table_.InsertEntry(name, value));
   }
 
diff --git a/quic/core/qpack/qpack_instruction_decoder.cc b/quic/core/qpack/qpack_instruction_decoder.cc
index fede8e3..1f85d7f 100644
--- a/quic/core/qpack/qpack_instruction_decoder.cc
+++ b/quic/core/qpack/qpack_instruction_decoder.cc
@@ -9,6 +9,7 @@
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.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"
 
 namespace quic {
 
@@ -32,7 +33,7 @@
       error_detected_(false),
       state_(State::kStartInstruction) {}
 
-bool QpackInstructionDecoder::Decode(QuicStringPiece data) {
+bool QpackInstructionDecoder::Decode(quiche::QuicheStringPiece data) {
   DCHECK(!data.empty());
   DCHECK(!error_detected_);
 
@@ -76,8 +77,8 @@
 
     DCHECK_LE(bytes_consumed, data.size());
 
-    data = QuicStringPiece(data.data() + bytes_consumed,
-                           data.size() - bytes_consumed);
+    data = quiche::QuicheStringPiece(data.data() + bytes_consumed,
+                                     data.size() - bytes_consumed);
 
     // Stop processing if no more data but next state would require it.
     if (data.empty() && (state_ != State::kStartField) &&
@@ -93,7 +94,8 @@
   return state_ == State::kStartInstruction;
 }
 
-bool QpackInstructionDecoder::DoStartInstruction(QuicStringPiece data) {
+bool QpackInstructionDecoder::DoStartInstruction(
+    quiche::QuicheStringPiece data) {
   DCHECK(!data.empty());
 
   instruction_ = LookupOpcode(data[0]);
@@ -131,7 +133,7 @@
   }
 }
 
-bool QpackInstructionDecoder::DoReadBit(QuicStringPiece data) {
+bool QpackInstructionDecoder::DoReadBit(quiche::QuicheStringPiece data) {
   DCHECK(!data.empty());
 
   switch (field_->type) {
@@ -161,7 +163,7 @@
   }
 }
 
-bool QpackInstructionDecoder::DoVarintStart(QuicStringPiece data,
+bool QpackInstructionDecoder::DoVarintStart(quiche::QuicheStringPiece data,
                                             size_t* bytes_consumed) {
   DCHECK(!data.empty());
   DCHECK(field_->type == QpackInstructionFieldType::kVarint ||
@@ -190,7 +192,7 @@
   }
 }
 
-bool QpackInstructionDecoder::DoVarintResume(QuicStringPiece data,
+bool QpackInstructionDecoder::DoVarintResume(quiche::QuicheStringPiece data,
                                              size_t* bytes_consumed) {
   DCHECK(!data.empty());
   DCHECK(field_->type == QpackInstructionFieldType::kVarint ||
@@ -263,7 +265,7 @@
   return true;
 }
 
-bool QpackInstructionDecoder::DoReadString(QuicStringPiece data,
+bool QpackInstructionDecoder::DoReadString(quiche::QuicheStringPiece data,
                                            size_t* bytes_consumed) {
   DCHECK(!data.empty());
   DCHECK(field_->type == QpackInstructionFieldType::kName ||
@@ -321,7 +323,7 @@
   return nullptr;
 }
 
-void QpackInstructionDecoder::OnError(QuicStringPiece error_message) {
+void QpackInstructionDecoder::OnError(quiche::QuicheStringPiece error_message) {
   DCHECK(!error_detected_);
 
   error_detected_ = true;
diff --git a/quic/core/qpack/qpack_instruction_decoder.h b/quic/core/qpack/qpack_instruction_decoder.h
index 4c21773..08eb665 100644
--- a/quic/core/qpack/qpack_instruction_decoder.h
+++ b/quic/core/qpack/qpack_instruction_decoder.h
@@ -13,7 +13,7 @@
 #include "net/third_party/quiche/src/http2/hpack/varint/hpack_varint_decoder.h"
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_instructions.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 {
 
@@ -42,7 +42,7 @@
     // No more data is processed afterwards.
     // Implementations are allowed to destroy the QpackInstructionDecoder
     // instance synchronously.
-    virtual void OnError(QuicStringPiece error_message) = 0;
+    virtual void OnError(quiche::QuicheStringPiece error_message) = 0;
   };
 
   // Both |*language| and |*delegate| must outlive this object.
@@ -54,7 +54,7 @@
   // Provide a data fragment to decode.  Must not be called after an error has
   // occurred.  Must not be called with empty |data|.  Return true on success,
   // false on error (in which case Delegate::OnError() is called synchronously).
-  bool Decode(QuicStringPiece data);
+  bool Decode(quiche::QuicheStringPiece data);
 
   // Returns true if no decoding has taken place yet or if the last instruction
   // has been entirely parsed.
@@ -94,13 +94,13 @@
   // data and set |*bytes_consumed| to the number of octets processed.  Some
   // take input data but do not consume any bytes.  Some do not take any
   // arguments because they only change internal state.
-  bool DoStartInstruction(QuicStringPiece data);
+  bool DoStartInstruction(quiche::QuicheStringPiece data);
   bool DoStartField();
-  bool DoReadBit(QuicStringPiece data);
-  bool DoVarintStart(QuicStringPiece data, size_t* bytes_consumed);
-  bool DoVarintResume(QuicStringPiece data, size_t* bytes_consumed);
+  bool DoReadBit(quiche::QuicheStringPiece data);
+  bool DoVarintStart(quiche::QuicheStringPiece data, size_t* bytes_consumed);
+  bool DoVarintResume(quiche::QuicheStringPiece data, size_t* bytes_consumed);
   bool DoVarintDone();
-  bool DoReadString(QuicStringPiece data, size_t* bytes_consumed);
+  bool DoReadString(quiche::QuicheStringPiece data, size_t* bytes_consumed);
   bool DoReadStringDone();
 
   // Identify instruction based on opcode encoded in |byte|.
@@ -108,7 +108,7 @@
   const QpackInstruction* LookupOpcode(uint8_t byte) const;
 
   // Stops decoding and calls Delegate::OnError().
-  void OnError(QuicStringPiece error_message);
+  void OnError(quiche::QuicheStringPiece error_message);
 
   // Describes the language used for decoding.
   const QpackLanguage* const language_;
diff --git a/quic/core/qpack/qpack_instruction_decoder_test.cc b/quic/core/qpack/qpack_instruction_decoder_test.cc
index c066827..99cda08 100644
--- a/quic/core/qpack/qpack_instruction_decoder_test.cc
+++ b/quic/core/qpack/qpack_instruction_decoder_test.cc
@@ -9,8 +9,9 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_instructions.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/quic/platform/api/quic_text_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 using ::testing::_;
 using ::testing::Eq;
@@ -61,7 +62,7 @@
   ~MockDelegate() override = default;
 
   MOCK_METHOD1(OnInstructionDecoded, bool(const QpackInstruction* instruction));
-  MOCK_METHOD1(OnError, void(QuicStringPiece error_message));
+  MOCK_METHOD1(OnError, void(quiche::QuicheStringPiece error_message));
 };
 
 class QpackInstructionDecoderTest : public QuicTestWithParam<FragmentMode> {
@@ -76,8 +77,10 @@
     // Destroy QpackInstructionDecoder on error to test that it does not crash.
     // See https://crbug.com/1025209.
     ON_CALL(delegate_, OnError(_))
-        .WillByDefault(Invoke(
-            [this](QuicStringPiece /* error_message */) { decoder_.reset(); }));
+        .WillByDefault(
+            Invoke([this](quiche::QuicheStringPiece /* error_message */) {
+              decoder_.reset();
+            }));
   }
 
   // Decode one full instruction with fragment sizes dictated by
@@ -86,7 +89,7 @@
   // verifies that AtInstructionBoundary() returns true before and after the
   // instruction, and returns false while decoding is in progress.
   // Assumes that delegate methods destroy |decoder_| if they return false.
-  void DecodeInstruction(QuicStringPiece data) {
+  void DecodeInstruction(quiche::QuicheStringPiece data) {
     EXPECT_TRUE(decoder_->AtInstructionBoundary());
 
     FragmentSizeGenerator fragment_size_generator =
@@ -123,14 +126,14 @@
 
 TEST_P(QpackInstructionDecoderTest, SBitAndVarint2) {
   EXPECT_CALL(delegate_, OnInstructionDecoded(TestInstruction1()));
-  DecodeInstruction(QuicTextUtils::HexDecode("7f01ff65"));
+  DecodeInstruction(quiche::QuicheTextUtils::HexDecode("7f01ff65"));
 
   EXPECT_TRUE(decoder_->s_bit());
   EXPECT_EQ(64u, decoder_->varint());
   EXPECT_EQ(356u, decoder_->varint2());
 
   EXPECT_CALL(delegate_, OnInstructionDecoded(TestInstruction1()));
-  DecodeInstruction(QuicTextUtils::HexDecode("05c8"));
+  DecodeInstruction(quiche::QuicheTextUtils::HexDecode("05c8"));
 
   EXPECT_FALSE(decoder_->s_bit());
   EXPECT_EQ(5u, decoder_->varint());
@@ -139,19 +142,19 @@
 
 TEST_P(QpackInstructionDecoderTest, NameAndValue) {
   EXPECT_CALL(delegate_, OnInstructionDecoded(TestInstruction2()));
-  DecodeInstruction(QuicTextUtils::HexDecode("83666f6f03626172"));
+  DecodeInstruction(quiche::QuicheTextUtils::HexDecode("83666f6f03626172"));
 
   EXPECT_EQ("foo", decoder_->name());
   EXPECT_EQ("bar", decoder_->value());
 
   EXPECT_CALL(delegate_, OnInstructionDecoded(TestInstruction2()));
-  DecodeInstruction(QuicTextUtils::HexDecode("8000"));
+  DecodeInstruction(quiche::QuicheTextUtils::HexDecode("8000"));
 
   EXPECT_EQ("", decoder_->name());
   EXPECT_EQ("", decoder_->value());
 
   EXPECT_CALL(delegate_, OnInstructionDecoded(TestInstruction2()));
-  DecodeInstruction(QuicTextUtils::HexDecode("c294e7838c767f"));
+  DecodeInstruction(quiche::QuicheTextUtils::HexDecode("c294e7838c767f"));
 
   EXPECT_EQ("foo", decoder_->name());
   EXPECT_EQ("bar", decoder_->value());
@@ -159,12 +162,13 @@
 
 TEST_P(QpackInstructionDecoderTest, InvalidHuffmanEncoding) {
   EXPECT_CALL(delegate_, OnError(Eq("Error in Huffman-encoded string.")));
-  DecodeInstruction(QuicTextUtils::HexDecode("c1ff"));
+  DecodeInstruction(quiche::QuicheTextUtils::HexDecode("c1ff"));
 }
 
 TEST_P(QpackInstructionDecoderTest, InvalidVarintEncoding) {
   EXPECT_CALL(delegate_, OnError(Eq("Encoded integer too large.")));
-  DecodeInstruction(QuicTextUtils::HexDecode("ffffffffffffffffffffff"));
+  DecodeInstruction(
+      quiche::QuicheTextUtils::HexDecode("ffffffffffffffffffffff"));
 }
 
 TEST_P(QpackInstructionDecoderTest, DelegateSignalsError) {
@@ -186,8 +190,8 @@
             return false;
           }));
 
-  EXPECT_FALSE(
-      decoder_->Decode(QuicTextUtils::HexDecode("01000200030004000500")));
+  EXPECT_FALSE(decoder_->Decode(
+      quiche::QuicheTextUtils::HexDecode("01000200030004000500")));
 }
 
 // QpackInstructionDecoder must not crash if it is destroyed from a
@@ -200,7 +204,7 @@
             decoder_.reset();
             return false;
           }));
-  DecodeInstruction(QuicTextUtils::HexDecode("0100"));
+  DecodeInstruction(quiche::QuicheTextUtils::HexDecode("0100"));
 }
 
 }  // namespace
diff --git a/quic/core/qpack/qpack_instruction_encoder.cc b/quic/core/qpack/qpack_instruction_encoder.cc
index a87489d..41e2d76 100644
--- a/quic/core/qpack/qpack_instruction_encoder.cc
+++ b/quic/core/qpack/qpack_instruction_encoder.cc
@@ -10,6 +10,7 @@
 #include "net/third_party/quiche/src/http2/hpack/varint/hpack_varint_encoder.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_string_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -127,8 +128,8 @@
   state_ = State::kWriteString;
 }
 
-void QpackInstructionEncoder::DoStartString(QuicStringPiece name,
-                                            QuicStringPiece value) {
+void QpackInstructionEncoder::DoStartString(quiche::QuicheStringPiece name,
+                                            quiche::QuicheStringPiece value) {
   DCHECK(field_->type == QpackInstructionFieldType::kName ||
          field_->type == QpackInstructionFieldType::kValue);
 
diff --git a/quic/core/qpack/qpack_instruction_encoder.h b/quic/core/qpack/qpack_instruction_encoder.h
index 04b2888..2a955f8 100644
--- a/quic/core/qpack/qpack_instruction_encoder.h
+++ b/quic/core/qpack/qpack_instruction_encoder.h
@@ -10,7 +10,7 @@
 
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_instructions.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 {
 
@@ -52,7 +52,8 @@
   void DoStartField();
   void DoSBit(bool s_bit);
   void DoVarintEncode(uint64_t varint, uint64_t varint2, std::string* output);
-  void DoStartString(QuicStringPiece name, QuicStringPiece value);
+  void DoStartString(quiche::QuicheStringPiece name,
+                     quiche::QuicheStringPiece value);
   void DoWriteString(std::string* output);
 
 
@@ -63,7 +64,7 @@
   // If Huffman encoding is used, points to a substring of
   // |huffman_encoded_string_|.
   // Otherwise points to a substring of |name_| or |value_|.
-  QuicStringPiece string_to_write_;
+  quiche::QuicheStringPiece string_to_write_;
 
   // Storage for a single byte that contains multiple fields, that is, multiple
   // states are writing it.
diff --git a/quic/core/qpack/qpack_instruction_encoder_test.cc b/quic/core/qpack/qpack_instruction_encoder_test.cc
index 79dfe2a..6f3337c 100644
--- a/quic/core/qpack/qpack_instruction_encoder_test.cc
+++ b/quic/core/qpack/qpack_instruction_encoder_test.cc
@@ -6,7 +6,8 @@
 
 #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/quic/platform/api/quic_text_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
 
 namespace quic {
 namespace test {
@@ -36,12 +37,12 @@
   }
 
   static void set_name(QpackInstructionWithValues* instruction_with_values,
-                       QuicStringPiece name) {
+                       quiche::QuicheStringPiece name) {
     instruction_with_values->name_ = name;
   }
 
   static void set_value(QpackInstructionWithValues* instruction_with_values,
-                        QuicStringPiece value) {
+                        quiche::QuicheStringPiece value) {
     instruction_with_values->value_ = value;
   }
 };
@@ -61,9 +62,12 @@
 
   // Compare substring appended to |output_| since last EncodedSegmentMatches()
   // call against hex-encoded argument.
-  bool EncodedSegmentMatches(QuicStringPiece hex_encoded_expected_substring) {
-    auto recently_encoded = QuicStringPiece(output_).substr(verified_position_);
-    auto expected = QuicTextUtils::HexDecode(hex_encoded_expected_substring);
+  bool EncodedSegmentMatches(
+      quiche::QuicheStringPiece hex_encoded_expected_substring) {
+    auto recently_encoded =
+        quiche::QuicheStringPiece(output_).substr(verified_position_);
+    auto expected =
+        quiche::QuicheTextUtils::HexDecode(hex_encoded_expected_substring);
     verified_position_ = output_.size();
     return recently_encoded == expected;
   }
diff --git a/quic/core/qpack/qpack_instructions.cc b/quic/core/qpack/qpack_instructions.cc
index a6a7529..1e5d112 100644
--- a/quic/core/qpack/qpack_instructions.cc
+++ b/quic/core/qpack/qpack_instructions.cc
@@ -7,6 +7,7 @@
 #include <limits>
 
 #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 {
 
@@ -203,7 +204,7 @@
 QpackInstructionWithValues QpackInstructionWithValues::InsertWithNameReference(
     bool is_static,
     uint64_t name_index,
-    QuicStringPiece value) {
+    quiche::QuicheStringPiece value) {
   QpackInstructionWithValues instruction_with_values;
   instruction_with_values.instruction_ = InsertWithNameReferenceInstruction();
   instruction_with_values.s_bit_ = is_static;
@@ -215,8 +216,9 @@
 
 // static
 QpackInstructionWithValues
-QpackInstructionWithValues::InsertWithoutNameReference(QuicStringPiece name,
-                                                       QuicStringPiece value) {
+QpackInstructionWithValues::InsertWithoutNameReference(
+    quiche::QuicheStringPiece name,
+    quiche::QuicheStringPiece value) {
   QpackInstructionWithValues instruction_with_values;
   instruction_with_values.instruction_ =
       InsertWithoutNameReferenceInstruction();
@@ -305,7 +307,7 @@
 QpackInstructionWithValues::LiteralHeaderFieldNameReference(
     bool is_static,
     uint64_t index,
-    QuicStringPiece value) {
+    quiche::QuicheStringPiece value) {
   QpackInstructionWithValues instruction_with_values;
   instruction_with_values.instruction_ =
       QpackLiteralHeaderFieldNameReferenceInstruction();
@@ -318,8 +320,8 @@
 
 // static
 QpackInstructionWithValues QpackInstructionWithValues::LiteralHeaderField(
-    QuicStringPiece name,
-    QuicStringPiece value) {
+    quiche::QuicheStringPiece name,
+    quiche::QuicheStringPiece value) {
   QpackInstructionWithValues instruction_with_values;
   instruction_with_values.instruction_ = QpackLiteralHeaderFieldInstruction();
   instruction_with_values.name_ = name;
diff --git a/quic/core/qpack/qpack_instructions.h b/quic/core/qpack/qpack_instructions.h
index 0ff18bf..d63a1e2 100644
--- a/quic/core/qpack/qpack_instructions.h
+++ b/quic/core/qpack/qpack_instructions.h
@@ -11,7 +11,7 @@
 #include <vector>
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -151,10 +151,10 @@
   static QpackInstructionWithValues InsertWithNameReference(
       bool is_static,
       uint64_t name_index,
-      QuicStringPiece value);
+      quiche::QuicheStringPiece value);
   static QpackInstructionWithValues InsertWithoutNameReference(
-      QuicStringPiece name,
-      QuicStringPiece value);
+      quiche::QuicheStringPiece name,
+      quiche::QuicheStringPiece value);
   static QpackInstructionWithValues Duplicate(uint64_t index);
   static QpackInstructionWithValues SetDynamicTableCapacity(uint64_t capacity);
 
@@ -172,16 +172,17 @@
   static QpackInstructionWithValues LiteralHeaderFieldNameReference(
       bool is_static,
       uint64_t index,
-      QuicStringPiece value);
-  static QpackInstructionWithValues LiteralHeaderField(QuicStringPiece name,
-                                                       QuicStringPiece value);
+      quiche::QuicheStringPiece value);
+  static QpackInstructionWithValues LiteralHeaderField(
+      quiche::QuicheStringPiece name,
+      quiche::QuicheStringPiece value);
 
   const QpackInstruction* instruction() const { return instruction_; }
   bool s_bit() const { return s_bit_; }
   uint64_t varint() const { return varint_; }
   uint64_t varint2() const { return varint2_; }
-  QuicStringPiece name() const { return name_; }
-  QuicStringPiece value() const { return value_; }
+  quiche::QuicheStringPiece name() const { return name_; }
+  quiche::QuicheStringPiece value() const { return value_; }
 
   // Used by QpackEncoder, because in the first pass it stores absolute indices,
   // which are converted into relative indices in the second pass after base is
@@ -198,8 +199,8 @@
   bool s_bit_;
   uint64_t varint_;
   uint64_t varint2_;
-  QuicStringPiece name_;
-  QuicStringPiece value_;
+  quiche::QuicheStringPiece name_;
+  quiche::QuicheStringPiece value_;
 };
 
 }  // namespace quic
diff --git a/quic/core/qpack/qpack_offline_decoder_bin.cc b/quic/core/qpack/qpack_offline_decoder_bin.cc
index 327816e..c1c002f 100644
--- a/quic/core/qpack/qpack_offline_decoder_bin.cc
+++ b/quic/core/qpack/qpack_offline_decoder_bin.cc
@@ -7,8 +7,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_string_piece.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_offline_decoder.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 int main(int argc, char* argv[]) {
   const char* usage =
@@ -25,8 +25,8 @@
   size_t i;
   size_t success_count = 0;
   for (i = 0; 2 * i < args.size(); ++i) {
-    const quic::QuicStringPiece input_filename(args[2 * i]);
-    const quic::QuicStringPiece expected_headers_filename(args[2 * i + 1]);
+    const quiche::QuicheStringPiece input_filename(args[2 * i]);
+    const quiche::QuicheStringPiece expected_headers_filename(args[2 * i + 1]);
 
     // Every file represents a different connection,
     // therefore every file needs a fresh decoding context.
diff --git a/quic/core/qpack/qpack_progressive_decoder.cc b/quic/core/qpack/qpack_progressive_decoder.cc
index c9e19d2..cf20bde 100644
--- a/quic/core/qpack/qpack_progressive_decoder.cc
+++ b/quic/core/qpack/qpack_progressive_decoder.cc
@@ -12,6 +12,7 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_instructions.h"
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_required_insert_count.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"
 
 namespace quic {
 
@@ -45,7 +46,7 @@
   }
 }
 
-void QpackProgressiveDecoder::Decode(QuicStringPiece data) {
+void QpackProgressiveDecoder::Decode(quiche::QuicheStringPiece data) {
   DCHECK(decoding_);
 
   if (data.empty() || error_detected_) {
@@ -113,7 +114,7 @@
   return DoLiteralHeaderFieldInstruction();
 }
 
-void QpackProgressiveDecoder::OnError(QuicStringPiece error_message) {
+void QpackProgressiveDecoder::OnError(quiche::QuicheStringPiece error_message) {
   DCHECK(!error_detected_);
 
   error_detected_ = true;
diff --git a/quic/core/qpack/qpack_progressive_decoder.h b/quic/core/qpack/qpack_progressive_decoder.h
index 6599c1a..f9c0224 100644
--- a/quic/core/qpack/qpack_progressive_decoder.h
+++ b/quic/core/qpack/qpack_progressive_decoder.h
@@ -14,7 +14,7 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_instruction_decoder.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 {
 
@@ -32,8 +32,8 @@
 
     // Called when a new header name-value pair is decoded.  Multiple values for
     // a given name will be emitted as multiple calls to OnHeader.
-    virtual void OnHeaderDecoded(QuicStringPiece name,
-                                 QuicStringPiece value) = 0;
+    virtual void OnHeaderDecoded(quiche::QuicheStringPiece name,
+                                 quiche::QuicheStringPiece value) = 0;
 
     // Called when the header block is completely decoded.
     // Indicates the total number of bytes in this block.
@@ -46,7 +46,8 @@
     // Called when a decoding error has occurred.  No other methods will be
     // called afterwards.  Implementations are allowed to destroy
     // the QpackProgressiveDecoder instance synchronously.
-    virtual void OnDecodingErrorDetected(QuicStringPiece error_message) = 0;
+    virtual void OnDecodingErrorDetected(
+        quiche::QuicheStringPiece error_message) = 0;
   };
 
   // Interface for keeping track of blocked streams for the purpose of enforcing
@@ -89,7 +90,7 @@
   ~QpackProgressiveDecoder() override;
 
   // Provide a data fragment to decode.
-  void Decode(QuicStringPiece data);
+  void Decode(quiche::QuicheStringPiece data);
 
   // Signal that the entire header block has been received and passed in
   // through Decode().  No methods must be called afterwards.
@@ -97,7 +98,7 @@
 
   // QpackInstructionDecoder::Delegate implementation.
   bool OnInstructionDecoded(const QpackInstruction* instruction) override;
-  void OnError(QuicStringPiece error_message) override;
+  void OnError(quiche::QuicheStringPiece error_message) override;
 
   // QpackHeaderTable::Observer implementation.
   void OnInsertCountReachedThreshold() override;
diff --git a/quic/core/qpack/qpack_receive_stream.cc b/quic/core/qpack/qpack_receive_stream.cc
index 5920398..a5df828 100644
--- a/quic/core/qpack/qpack_receive_stream.cc
+++ b/quic/core/qpack/qpack_receive_stream.cc
@@ -5,6 +5,7 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_receive_stream.h"
 
 #include "net/third_party/quiche/src/quic/core/quic_session.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 QpackReceiveStream::QpackReceiveStream(PendingStream* pending,
@@ -25,7 +26,7 @@
   while (!reading_stopped() && sequencer()->GetReadableRegion(&iov)) {
     DCHECK(!sequencer()->IsClosed());
 
-    receiver_->Decode(QuicStringPiece(
+    receiver_->Decode(quiche::QuicheStringPiece(
         reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
     sequencer()->MarkConsumed(iov.iov_len);
   }
diff --git a/quic/core/qpack/qpack_receive_stream_test.cc b/quic/core/qpack/qpack_receive_stream_test.cc
index af02f64..6aeeeae 100644
--- a/quic/core/qpack/qpack_receive_stream_test.cc
+++ b/quic/core/qpack/qpack_receive_stream_test.cc
@@ -8,6 +8,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/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"
 
 namespace quic {
 namespace test {
@@ -61,7 +62,7 @@
                           : GetNthServerInitiatedUnidirectionalStreamId(
                                 session_.transport_version(), 3);
     char type[] = {0x03};
-    QuicStreamFrame data1(id, false, 0, QuicStringPiece(type, 1));
+    QuicStreamFrame data1(id, false, 0, quiche::QuicheStringPiece(type, 1));
     session_.OnStreamFrame(data1);
     qpack_receive_stream_ =
         QuicSpdySessionPeer::GetQpackDecoderReceiveStream(&session_);
diff --git a/quic/core/qpack/qpack_round_trip_test.cc b/quic/core/qpack/qpack_round_trip_test.cc
index f0dc797..8625baa 100644
--- a/quic/core/qpack/qpack_round_trip_test.cc
+++ b/quic/core/qpack/qpack_round_trip_test.cc
@@ -5,11 +5,11 @@
 #include <string>
 #include <tuple>
 
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_decoder_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_encoder_test_utils.h"
 #include "net/third_party/quiche/src/quic/test_tools/qpack/qpack_test_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_header_block.h"
 
 using ::testing::Values;
@@ -126,7 +126,7 @@
 
 TEST_P(QpackRoundTripTest, ValueHasNullCharacter) {
   spdy::SpdyHeaderBlock header_list;
-  header_list["foo"] = QuicStringPiece("bar\0bar\0baz", 11);
+  header_list["foo"] = quiche::QuicheStringPiece("bar\0bar\0baz", 11);
 
   spdy::SpdyHeaderBlock output = EncodeThenDecode(header_list);
   EXPECT_EQ(header_list, output);
diff --git a/quic/core/qpack/qpack_send_stream.cc b/quic/core/qpack/qpack_send_stream.cc
index 50fe687..23f9db2 100644
--- a/quic/core/qpack/qpack_send_stream.cc
+++ b/quic/core/qpack/qpack_send_stream.cc
@@ -6,6 +6,7 @@
 
 #include "net/third_party/quiche/src/quic/core/quic_session.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 QpackSendStream::QpackSendStream(QuicStreamId id,
@@ -23,7 +24,7 @@
       ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
 }
 
-void QpackSendStream::WriteStreamData(QuicStringPiece data) {
+void QpackSendStream::WriteStreamData(quiche::QuicheStringPiece data) {
   QuicConnection::ScopedPacketFlusher flusher(session()->connection());
   MaybeSendStreamType();
   WriteOrBufferData(data, false, nullptr);
@@ -34,8 +35,8 @@
     char type[sizeof(http3_stream_type_)];
     QuicDataWriter writer(QUIC_ARRAYSIZE(type), type);
     writer.WriteVarInt62(http3_stream_type_);
-    WriteOrBufferData(QuicStringPiece(writer.data(), writer.length()), false,
-                      nullptr);
+    WriteOrBufferData(quiche::QuicheStringPiece(writer.data(), writer.length()),
+                      false, nullptr);
     stream_type_sent_ = true;
   }
 }
diff --git a/quic/core/qpack/qpack_send_stream.h b/quic/core/qpack/qpack_send_stream.h
index 09c6020..bc2d9c0 100644
--- a/quic/core/qpack/qpack_send_stream.h
+++ b/quic/core/qpack/qpack_send_stream.h
@@ -10,7 +10,7 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_stream_sender_delegate.h"
 #include "net/third_party/quiche/src/quic/core/quic_stream.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
-#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -40,7 +40,7 @@
 
   // Writes the instructions to peer. The stream type will be sent
   // before the first instruction so that the peer can open an qpack stream.
-  void WriteStreamData(QuicStringPiece data) override;
+  void WriteStreamData(quiche::QuicheStringPiece data) override;
 
   // TODO(b/112770235): Remove this method once QuicStreamIdManager supports
   // creating HTTP/3 unidirectional streams dynamically.
diff --git a/quic/core/qpack/qpack_send_stream_test.cc b/quic/core/qpack/qpack_send_stream_test.cc
index 9529f51..e1f32bb 100644
--- a/quic/core/qpack/qpack_send_stream_test.cc
+++ b/quic/core/qpack/qpack_send_stream_test.cc
@@ -9,6 +9,8 @@
 #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_str_cat.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -35,7 +37,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"));
 }
@@ -97,10 +99,10 @@
   std::string data = "data";
   EXPECT_CALL(session_, WritevData(_, _, 1, _, _));
   EXPECT_CALL(session_, WritevData(_, _, data.length(), _, _));
-  qpack_send_stream_->WriteStreamData(QuicStringPiece(data));
+  qpack_send_stream_->WriteStreamData(quiche::QuicheStringPiece(data));
 
   EXPECT_CALL(session_, WritevData(_, _, data.length(), _, _));
-  qpack_send_stream_->WriteStreamData(QuicStringPiece(data));
+  qpack_send_stream_->WriteStreamData(quiche::QuicheStringPiece(data));
   EXPECT_CALL(session_, WritevData(_, _, _, _, _)).Times(0);
   qpack_send_stream_->MaybeSendStreamType();
 }
diff --git a/quic/core/qpack/qpack_static_table_test.cc b/quic/core/qpack/qpack_static_table_test.cc
index 1742502..a8e7ac2 100644
--- a/quic/core/qpack/qpack_static_table_test.cc
+++ b/quic/core/qpack/qpack_static_table_test.cc
@@ -7,8 +7,8 @@
 #include <set>
 
 #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/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 
@@ -32,7 +32,7 @@
   EXPECT_EQ(QpackStaticTableVector().size(), static_index.size());
 
   auto static_name_index = table.GetStaticNameIndex();
-  std::set<QuicStringPiece> names;
+  std::set<quiche::QuicheStringPiece> names;
   for (auto entry : static_index) {
     names.insert(entry->name());
   }
diff --git a/quic/core/qpack/qpack_stream_receiver.h b/quic/core/qpack/qpack_stream_receiver.h
index 48f5aa30..01c2d5f 100644
--- a/quic/core/qpack/qpack_stream_receiver.h
+++ b/quic/core/qpack/qpack_stream_receiver.h
@@ -6,7 +6,7 @@
 #define QUICHE_QUIC_CORE_QPACK_QPACK_STREAM_RECEIVER_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 {
 
@@ -16,7 +16,7 @@
   virtual ~QpackStreamReceiver() = default;
 
   // Decode data.
-  virtual void Decode(QuicStringPiece data) = 0;
+  virtual void Decode(quiche::QuicheStringPiece data) = 0;
 };
 
 }  // namespace quic
diff --git a/quic/core/qpack/qpack_stream_sender_delegate.h b/quic/core/qpack/qpack_stream_sender_delegate.h
index 616df98..524b756 100644
--- a/quic/core/qpack/qpack_stream_sender_delegate.h
+++ b/quic/core/qpack/qpack_stream_sender_delegate.h
@@ -6,7 +6,7 @@
 #define QUICHE_QUIC_CORE_QPACK_QPACK_STREAM_SENDER_DELEGATE_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 {
 
@@ -16,7 +16,7 @@
   virtual ~QpackStreamSenderDelegate() = default;
 
   // Write data on the unidirectional stream.
-  virtual void WriteStreamData(QuicStringPiece data) = 0;
+  virtual void WriteStreamData(quiche::QuicheStringPiece data) = 0;
 };
 
 }  // namespace quic
diff --git a/quic/core/qpack/value_splitting_header_list.cc b/quic/core/qpack/value_splitting_header_list.cc
index c1387b9..65d1b99 100644
--- a/quic/core/qpack/value_splitting_header_list.cc
+++ b/quic/core/qpack/value_splitting_header_list.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "net/third_party/quiche/src/quic/core/qpack/value_splitting_header_list.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace {
@@ -36,7 +37,7 @@
 
 const ValueSplittingHeaderList::const_iterator&
 ValueSplittingHeaderList::const_iterator::operator++() {
-  if (value_end_ == QuicStringPiece::npos) {
+  if (value_end_ == quiche::QuicheStringPiece::npos) {
     // This was the last frament within |*header_list_iterator_|,
     // move on to the next header element of |header_list_|.
     ++header_list_iterator_;
@@ -60,14 +61,15 @@
 }
 
 void ValueSplittingHeaderList::const_iterator::UpdateHeaderField() {
-  DCHECK(value_start_ != QuicStringPiece::npos);
+  DCHECK(value_start_ != quiche::QuicheStringPiece::npos);
 
   if (header_list_iterator_ == header_list_->end()) {
     return;
   }
 
-  const QuicStringPiece name = header_list_iterator_->first;
-  const QuicStringPiece original_value = header_list_iterator_->second;
+  const quiche::QuicheStringPiece name = header_list_iterator_->first;
+  const quiche::QuicheStringPiece original_value =
+      header_list_iterator_->second;
 
   if (name == kCookieKey) {
     value_end_ = original_value.find(kCookieSeparator, value_start_);
@@ -75,12 +77,12 @@
     value_end_ = original_value.find(kNonCookieSeparator, value_start_);
   }
 
-  const QuicStringPiece value =
+  const quiche::QuicheStringPiece value =
       original_value.substr(value_start_, value_end_ - value_start_);
   header_field_ = std::make_pair(name, value);
 
   // Skip character after ';' separator if it is a space.
-  if (name == kCookieKey && value_end_ != QuicStringPiece::npos &&
+  if (name == kCookieKey && value_end_ != quiche::QuicheStringPiece::npos &&
       value_end_ + 1 < original_value.size() &&
       original_value[value_end_ + 1] == kOptionalSpaceAfterCookieSeparator) {
     ++value_end_;
diff --git a/quic/core/qpack/value_splitting_header_list.h b/quic/core/qpack/value_splitting_header_list.h
index fee3043..446548a 100644
--- a/quic/core/qpack/value_splitting_header_list.h
+++ b/quic/core/qpack/value_splitting_header_list.h
@@ -6,7 +6,7 @@
 #define QUICHE_QUIC_CORE_QPACK_VALUE_SPLITTING_HEADER_LIST_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 {
@@ -40,8 +40,8 @@
 
     const spdy::SpdyHeaderBlock* const header_list_;
     spdy::SpdyHeaderBlock::const_iterator header_list_iterator_;
-    QuicStringPiece::size_type value_start_;
-    QuicStringPiece::size_type value_end_;
+    quiche::QuicheStringPiece::size_type value_start_;
+    quiche::QuicheStringPiece::size_type value_end_;
     value_type header_field_;
   };
 
diff --git a/quic/core/qpack/value_splitting_header_list_test.cc b/quic/core/qpack/value_splitting_header_list_test.cc
index bab5238..ef69aad 100644
--- a/quic/core/qpack/value_splitting_header_list_test.cc
+++ b/quic/core/qpack/value_splitting_header_list_test.cc
@@ -6,6 +6,7 @@
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace quic {
 namespace test {
@@ -16,7 +17,7 @@
 
 TEST(ValueSplittingHeaderListTest, Comparison) {
   spdy::SpdyHeaderBlock block;
-  block["foo"] = QuicStringPiece("bar\0baz", 7);
+  block["foo"] = quiche::QuicheStringPiece("bar\0baz", 7);
   block["baz"] = "qux";
   block["cookie"] = "foo; bar";
 
@@ -84,7 +85,7 @@
 TEST(ValueSplittingHeaderListTest, Split) {
   struct {
     const char* name;
-    QuicStringPiece value;
+    quiche::QuicheStringPiece value;
     std::vector<const char*> expected_values;
   } kTestData[]{
       // Empty value.
@@ -130,9 +131,9 @@
 
 TEST(ValueSplittingHeaderListTest, MultipleFields) {
   spdy::SpdyHeaderBlock block;
-  block["foo"] = QuicStringPiece("bar\0baz\0", 8);
+  block["foo"] = quiche::QuicheStringPiece("bar\0baz\0", 8);
   block["cookie"] = "foo; bar";
-  block["bar"] = QuicStringPiece("qux\0foo", 7);
+  block["bar"] = quiche::QuicheStringPiece("qux\0foo", 7);
 
   ValueSplittingHeaderList headers(&block);
   EXPECT_THAT(headers, ElementsAre(Pair("foo", "bar"), Pair("foo", "baz"),