diff --git a/http2/decoder/decode_buffer.h b/http2/decoder/decode_buffer.h
index 24f252e..e6604f1 100644
--- a/http2/decoder/decode_buffer.h
+++ b/http2/decoder/decode_buffer.h
@@ -19,7 +19,7 @@
 
 #include "net/third_party/quiche/src/http2/platform/api/http2_export.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 class DecodeBufferSubset;
@@ -35,7 +35,7 @@
     const size_t kMaxDecodeBufferLength = 1 << 25;
     DCHECK_LE(len, kMaxDecodeBufferLength);
   }
-  explicit DecodeBuffer(Http2StringPiece s)
+  explicit DecodeBuffer(quiche::QuicheStringPiece s)
       : DecodeBuffer(s.data(), s.size()) {}
   // Constructor for character arrays, typically in tests. For example:
   //    const char input[] = { 0x11 };
diff --git a/http2/decoder/decode_http2_structures_test.cc b/http2/decoder/decode_http2_structures_test.cc
index 48b79bd..37246c4 100644
--- a/http2/decoder/decode_http2_structures_test.cc
+++ b/http2/decoder/decode_http2_structures_test.cc
@@ -17,9 +17,9 @@
 #include "net/third_party/quiche/src/http2/http2_constants.h"
 #include "net/third_party/quiche/src/http2/http2_structures_test_util.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
 #include "net/third_party/quiche/src/http2/test_tools/http2_random.h"
 #include "net/third_party/quiche/src/http2/tools/http2_frame_builder.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 using ::testing::AssertionResult;
 
@@ -28,8 +28,9 @@
 namespace {
 
 template <typename T, size_t N>
-Http2StringPiece ToStringPiece(T (&data)[N]) {
-  return Http2StringPiece(reinterpret_cast<const char*>(data), N * sizeof(T));
+quiche::QuicheStringPiece ToStringPiece(T (&data)[N]) {
+  return quiche::QuicheStringPiece(reinterpret_cast<const char*>(data),
+                                   N * sizeof(T));
 }
 
 template <class S>
@@ -52,7 +53,8 @@
 
   // Fully decodes the Structure at the start of data, and confirms it matches
   // *expected (if provided).
-  void DecodeLeadingStructure(const S* expected, Http2StringPiece data) {
+  void DecodeLeadingStructure(const S* expected,
+                              quiche::QuicheStringPiece data) {
     ASSERT_LE(S::EncodedSize(), data.size());
     DecodeBuffer db(data);
     Randomize(&structure_);
@@ -65,7 +67,7 @@
 
   template <size_t N>
   void DecodeLeadingStructure(const char (&data)[N]) {
-    DecodeLeadingStructure(nullptr, Http2StringPiece(data, N));
+    DecodeLeadingStructure(nullptr, quiche::QuicheStringPiece(data, N));
   }
 
   // Encode the structure |in_s| into bytes, then decode the bytes
@@ -291,7 +293,7 @@
     };
     DecodeLeadingStructure(kData);
     if (!HasFailure()) {
-      EXPECT_EQ(Http2StringPiece(kData, 8),
+      EXPECT_EQ(quiche::QuicheStringPiece(kData, 8),
                 ToStringPiece(structure_.opaque_bytes));
     }
   }
@@ -302,7 +304,7 @@
     };
     DecodeLeadingStructure(kData);
     if (!HasFailure()) {
-      EXPECT_EQ(Http2StringPiece(kData, 8),
+      EXPECT_EQ(quiche::QuicheStringPiece(kData, 8),
                 ToStringPiece(structure_.opaque_bytes));
     }
   }
@@ -312,7 +314,7 @@
     };
     DecodeLeadingStructure(kData);
     if (!HasFailure()) {
-      EXPECT_EQ(Http2StringPiece(kData, 8),
+      EXPECT_EQ(quiche::QuicheStringPiece(kData, 8),
                 ToStringPiece(structure_.opaque_bytes));
     }
   }
diff --git a/http2/decoder/http2_frame_decoder_test.cc b/http2/decoder/http2_frame_decoder_test.cc
index 7ed67f3..20e39eb 100644
--- a/http2/decoder/http2_frame_decoder_test.cc
+++ b/http2/decoder/http2_frame_decoder_test.cc
@@ -13,12 +13,12 @@
 #include "net/third_party/quiche/src/http2/http2_constants.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_reconstruct_object.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_test_helpers.h"
 #include "net/third_party/quiche/src/http2/test_tools/frame_parts.h"
 #include "net/third_party/quiche/src/http2/test_tools/frame_parts_collector_listener.h"
 #include "net/third_party/quiche/src/http2/test_tools/http2_random.h"
 #include "net/third_party/quiche/src/http2/tools/random_decoder_test.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 using ::testing::AssertionResult;
 using ::testing::AssertionSuccess;
@@ -120,8 +120,9 @@
     VERIFY_AND_RETURN_SUCCESS(expected.VerifyEquals(*collector_.frame(0)));
   }
 
-  AssertionResult DecodePayloadAndValidateSeveralWays(Http2StringPiece payload,
-                                                      Validator validator) {
+  AssertionResult DecodePayloadAndValidateSeveralWays(
+      quiche::QuicheStringPiece payload,
+      Validator validator) {
     DecodeBuffer db(payload);
     bool start_decoding_requires_non_empty = false;
     return DecodeAndValidateSeveralWays(&db, start_decoding_requires_non_empty,
@@ -133,7 +134,7 @@
   // payload will be decoded several times with different partitionings
   // of the payload, and after each the validator will be called.
   AssertionResult DecodePayloadAndValidateSeveralWays(
-      Http2StringPiece payload,
+      quiche::QuicheStringPiece payload,
       const FrameParts& expected) {
     auto validator = [&expected, this](const DecodeBuffer& input,
                                        DecodeStatus status) -> AssertionResult {
@@ -164,16 +165,16 @@
   AssertionResult DecodePayloadAndValidateSeveralWays(
       const char (&buf)[N],
       const FrameParts& expected) {
-    return DecodePayloadAndValidateSeveralWays(Http2StringPiece(buf, N),
-                                               expected);
+    return DecodePayloadAndValidateSeveralWays(
+        quiche::QuicheStringPiece(buf, N), expected);
   }
 
   template <size_t N>
   AssertionResult DecodePayloadAndValidateSeveralWays(
       const char (&buf)[N],
       const Http2FrameHeader& header) {
-    return DecodePayloadAndValidateSeveralWays(Http2StringPiece(buf, N),
-                                               FrameParts(header));
+    return DecodePayloadAndValidateSeveralWays(
+        quiche::QuicheStringPiece(buf, N), FrameParts(header));
   }
 
   template <size_t N>
diff --git a/http2/decoder/http2_structure_decoder_test.cc b/http2/decoder/http2_structure_decoder_test.cc
index 2545109..09db43e 100644
--- a/http2/decoder/http2_structure_decoder_test.cc
+++ b/http2/decoder/http2_structure_decoder_test.cc
@@ -30,10 +30,10 @@
 #include "net/third_party/quiche/src/http2/http2_structures_test_util.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_reconstruct_object.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_test_helpers.h"
 #include "net/third_party/quiche/src/http2/tools/http2_frame_builder.h"
 #include "net/third_party/quiche/src/http2/tools/random_decoder_test.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 using ::testing::AssertionFailure;
 using ::testing::AssertionResult;
@@ -95,7 +95,7 @@
   // Fully decodes the Structure at the start of data, and confirms it matches
   // *expected (if provided).
   AssertionResult DecodeLeadingStructure(const S* expected,
-                                         Http2StringPiece data) {
+                                         quiche::QuicheStringPiece data) {
     VERIFY_LE(S::EncodedSize(), data.size());
     DecodeBuffer original(data);
 
@@ -147,7 +147,7 @@
   template <size_t N>
   AssertionResult DecodeLeadingStructure(const char (&data)[N]) {
     VERIFY_AND_RETURN_SUCCESS(
-        DecodeLeadingStructure(nullptr, Http2StringPiece(data, N)));
+        DecodeLeadingStructure(nullptr, quiche::QuicheStringPiece(data, N)));
   }
 
   template <size_t N>
diff --git a/http2/decoder/payload_decoders/payload_decoder_base_test_util.cc b/http2/decoder/payload_decoders/payload_decoder_base_test_util.cc
index ba6d04a..8e94f03 100644
--- a/http2/decoder/payload_decoders/payload_decoder_base_test_util.cc
+++ b/http2/decoder/payload_decoders/payload_decoder_base_test_util.cc
@@ -75,7 +75,7 @@
 
 ::testing::AssertionResult
 PayloadDecoderBaseTest::DecodePayloadAndValidateSeveralWays(
-    Http2StringPiece payload,
+    quiche::QuicheStringPiece payload,
     Validator validator) {
   VERIFY_TRUE(frame_header_is_set_);
   // Cap the payload to be decoded at the declared payload length. This is
@@ -85,7 +85,8 @@
   // Note that it is OK if the payload is too short; the validator may be
   // designed to check for that.
   if (payload.size() > frame_header_.payload_length) {
-    payload = Http2StringPiece(payload.data(), frame_header_.payload_length);
+    payload =
+        quiche::QuicheStringPiece(payload.data(), frame_header_.payload_length);
   }
   DecodeBuffer db(payload);
   ResetDecodeSpeedCounters();
diff --git a/http2/decoder/payload_decoders/payload_decoder_base_test_util.h b/http2/decoder/payload_decoders/payload_decoder_base_test_util.h
index 5de0d1b..faa99fd 100644
--- a/http2/decoder/payload_decoders/payload_decoder_base_test_util.h
+++ b/http2/decoder/payload_decoders/payload_decoder_base_test_util.h
@@ -21,10 +21,10 @@
 #include "net/third_party/quiche/src/http2/http2_structures.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_reconstruct_object.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
 #include "net/third_party/quiche/src/http2/test_tools/frame_parts.h"
 #include "net/third_party/quiche/src/http2/tools/http2_frame_builder.h"
 #include "net/third_party/quiche/src/http2/tools/random_decoder_test.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 namespace test {
@@ -82,7 +82,7 @@
   // Given the specified payload (without the common frame header), decode
   // it with several partitionings of the payload.
   ::testing::AssertionResult DecodePayloadAndValidateSeveralWays(
-      Http2StringPiece payload,
+      quiche::QuicheStringPiece payload,
       Validator validator);
 
   // TODO(jamessynge): Add helper method for verifying these are both non-zero,
@@ -191,7 +191,7 @@
   // will be decoded several times with different partitionings of the payload,
   // and after each the validator will be called.
   AssertionResult DecodePayloadAndValidateSeveralWays(
-      Http2StringPiece payload,
+      quiche::QuicheStringPiece payload,
       const FrameParts& expected) {
     auto validator = [&expected, this]() -> AssertionResult {
       VERIFY_FALSE(listener_.IsInProgress());
@@ -210,7 +210,7 @@
   // std::nullptr_t (not extra validation).
   template <typename WrappedValidator>
   ::testing::AssertionResult VerifyDetectsFrameSizeError(
-      Http2StringPiece payload,
+      quiche::QuicheStringPiece payload,
       const Http2FrameHeader& header,
       WrappedValidator wrapped_validator) {
     set_frame_header(header);
@@ -249,7 +249,7 @@
   // randomly selected flag bits not excluded by FlagsAffectingPayloadDecoding.
   ::testing::AssertionResult VerifyDetectsMultipleFrameSizeErrors(
       uint8_t required_flags,
-      Http2StringPiece unpadded_payload,
+      quiche::QuicheStringPiece unpadded_payload,
       ApproveSize approve_size,
       int total_pad_length) {
     // required_flags should come from those that are defined for the frame
@@ -307,7 +307,7 @@
   // As above, but for frames without padding.
   ::testing::AssertionResult VerifyDetectsFrameSizeError(
       uint8_t required_flags,
-      Http2StringPiece unpadded_payload,
+      quiche::QuicheStringPiece unpadded_payload,
       const ApproveSize& approve_size) {
     Http2FrameType frame_type = DecoderPeer::FrameType();
     uint8_t known_flags = KnownFlagsMaskForFrameType(frame_type);
@@ -386,7 +386,7 @@
   // amount of missing padding is as specified. header.IsPadded must be true,
   // and the payload must be empty or the PadLength field must be too large.
   ::testing::AssertionResult VerifyDetectsPaddingTooLong(
-      Http2StringPiece payload,
+      quiche::QuicheStringPiece payload,
       const Http2FrameHeader& header,
       size_t expected_missing_length) {
     set_frame_header(header);
diff --git a/http2/hpack/decoder/hpack_block_collector.cc b/http2/hpack/decoder/hpack_block_collector.cc
index 3490ca7..325a60c 100644
--- a/http2/hpack/decoder/hpack_block_collector.cc
+++ b/http2/hpack/decoder/hpack_block_collector.cc
@@ -112,7 +112,7 @@
     HpackEntryType expected_type,
     size_t expected_index,
     bool expected_value_huffman,
-    Http2StringPiece expected_value) const {
+    quiche::QuicheStringPiece expected_value) const {
   VERIFY_TRUE(pending_entry_.IsClear());
   VERIFY_EQ(1u, entries_.size());
   VERIFY_TRUE(entries_.front().ValidateLiteralValueHeader(
@@ -122,9 +122,9 @@
 AssertionResult HpackBlockCollector::ValidateSoleLiteralNameValueHeader(
     HpackEntryType expected_type,
     bool expected_name_huffman,
-    Http2StringPiece expected_name,
+    quiche::QuicheStringPiece expected_name,
     bool expected_value_huffman,
-    Http2StringPiece expected_value) const {
+    quiche::QuicheStringPiece expected_value) const {
   VERIFY_TRUE(pending_entry_.IsClear());
   VERIFY_EQ(1u, entries_.size());
   VERIFY_TRUE(entries_.front().ValidateLiteralNameValueHeader(
diff --git a/http2/hpack/decoder/hpack_block_collector.h b/http2/hpack/decoder/hpack_block_collector.h
index 0d8f811..8246de4 100644
--- a/http2/hpack/decoder/hpack_block_collector.h
+++ b/http2/hpack/decoder/hpack_block_collector.h
@@ -23,8 +23,8 @@
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_entry_decoder_listener.h"
 #include "net/third_party/quiche/src/http2/hpack/http2_hpack_constants.h"
 #include "net/third_party/quiche/src/http2/hpack/tools/hpack_block_builder.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
 #include "net/third_party/quiche/src/http2/test_tools/http2_random.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 namespace test {
@@ -97,16 +97,16 @@
       HpackEntryType expected_type,
       size_t expected_index,
       bool expected_value_huffman,
-      Http2StringPiece expected_value) const;
+      quiche::QuicheStringPiece expected_value) const;
 
   // Return AssertionSuccess if there is just one entry, and it is a Header
   // with a literal name and literal value.
   ::testing::AssertionResult ValidateSoleLiteralNameValueHeader(
       HpackEntryType expected_type,
       bool expected_name_huffman,
-      Http2StringPiece expected_name,
+      quiche::QuicheStringPiece expected_name,
       bool expected_value_huffman,
-      Http2StringPiece expected_value) const;
+      quiche::QuicheStringPiece expected_value) const;
 
   bool IsNotPending() const { return pending_entry_.IsClear(); }
   bool IsClear() const { return IsNotPending() && entries_.empty(); }
diff --git a/http2/hpack/decoder/hpack_block_decoder_test.cc b/http2/hpack/decoder/hpack_block_decoder_test.cc
index 4988b5c..aeb6c48 100644
--- a/http2/hpack/decoder/hpack_block_decoder_test.cc
+++ b/http2/hpack/decoder/hpack_block_decoder_test.cc
@@ -15,10 +15,10 @@
 #include "net/third_party/quiche/src/http2/hpack/http2_hpack_constants.h"
 #include "net/third_party/quiche/src/http2/hpack/tools/hpack_block_builder.h"
 #include "net/third_party/quiche/src/http2/hpack/tools/hpack_example.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_test_helpers.h"
 #include "net/third_party/quiche/src/http2/test_tools/http2_random.h"
 #include "net/third_party/quiche/src/http2/tools/random_decoder_test.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 using ::testing::AssertionSuccess;
 
@@ -66,7 +66,7 @@
   }
 
   AssertionResult DecodeHpackExampleAndValidateSeveralWays(
-      Http2StringPiece hpack_example,
+      quiche::QuicheStringPiece hpack_example,
       Validator validator) {
     std::string input = HpackExampleToStringOrDie(hpack_example);
     DecodeBuffer db(input);
diff --git a/http2/hpack/decoder/hpack_decoder.cc b/http2/hpack/decoder/hpack_decoder.cc
index f2f8584..1421c7c 100644
--- a/http2/hpack/decoder/hpack_decoder.cc
+++ b/http2/hpack/decoder/hpack_decoder.cc
@@ -109,7 +109,7 @@
   return Http2EstimateMemoryUsage(entry_buffer_);
 }
 
-void HpackDecoder::ReportError(Http2StringPiece error_message) {
+void HpackDecoder::ReportError(quiche::QuicheStringPiece error_message) {
   HTTP2_DVLOG(3) << "HpackDecoder::ReportError is new="
                  << (!error_detected_ ? "true" : "false")
                  << ", error_message: " << error_message;
diff --git a/http2/hpack/decoder/hpack_decoder.h b/http2/hpack/decoder/hpack_decoder.h
index e173bc6..663fef6 100644
--- a/http2/hpack/decoder/hpack_decoder.h
+++ b/http2/hpack/decoder/hpack_decoder.h
@@ -30,7 +30,7 @@
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_decoder_tables.h"
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_whole_entry_buffer.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_export.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 namespace test {
@@ -102,7 +102,7 @@
   friend class test::HpackDecoderPeer;
 
   // Reports an error to the listener IF this is the first error detected.
-  void ReportError(Http2StringPiece error_message);
+  void ReportError(quiche::QuicheStringPiece error_message);
 
   // The decompressor state, as defined by HPACK (i.e. the static and dynamic
   // tables).
diff --git a/http2/hpack/decoder/hpack_decoder_listener.cc b/http2/hpack/decoder/hpack_decoder_listener.cc
index 8afa8aa..60341a0 100644
--- a/http2/hpack/decoder/hpack_decoder_listener.cc
+++ b/http2/hpack/decoder/hpack_decoder_listener.cc
@@ -18,7 +18,7 @@
                                         const HpackString& value) {}
 void HpackDecoderNoOpListener::OnHeaderListEnd() {}
 void HpackDecoderNoOpListener::OnHeaderErrorDetected(
-    Http2StringPiece error_message) {}
+    quiche::QuicheStringPiece error_message) {}
 
 // static
 HpackDecoderNoOpListener* HpackDecoderNoOpListener::NoOpListener() {
diff --git a/http2/hpack/decoder/hpack_decoder_listener.h b/http2/hpack/decoder/hpack_decoder_listener.h
index fa68591..2db8157 100644
--- a/http2/hpack/decoder/hpack_decoder_listener.h
+++ b/http2/hpack/decoder/hpack_decoder_listener.h
@@ -11,7 +11,7 @@
 #include "net/third_party/quiche/src/http2/hpack/hpack_string.h"
 #include "net/third_party/quiche/src/http2/hpack/http2_hpack_constants.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_export.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 
@@ -39,7 +39,8 @@
 
   // OnHeaderErrorDetected is called if an error is detected while decoding.
   // error_message may be used in a GOAWAY frame as the Opaque Data.
-  virtual void OnHeaderErrorDetected(Http2StringPiece error_message) = 0;
+  virtual void OnHeaderErrorDetected(
+      quiche::QuicheStringPiece error_message) = 0;
 };
 
 // A no-op implementation of HpackDecoderListener, useful for ignoring
@@ -55,7 +56,7 @@
                 const HpackString& name,
                 const HpackString& value) override;
   void OnHeaderListEnd() override;
-  void OnHeaderErrorDetected(Http2StringPiece error_message) override;
+  void OnHeaderErrorDetected(quiche::QuicheStringPiece error_message) override;
 
   // Returns a listener that ignores all the calls.
   static HpackDecoderNoOpListener* NoOpListener();
diff --git a/http2/hpack/decoder/hpack_decoder_state.cc b/http2/hpack/decoder/hpack_decoder_state.cc
index 921d48c..c01ae74 100644
--- a/http2/hpack/decoder/hpack_decoder_state.cc
+++ b/http2/hpack/decoder/hpack_decoder_state.cc
@@ -185,7 +185,8 @@
   lowest_header_table_size_ = final_header_table_size_;
 }
 
-void HpackDecoderState::OnHpackDecodeError(Http2StringPiece error_message) {
+void HpackDecoderState::OnHpackDecodeError(
+    quiche::QuicheStringPiece error_message) {
   HTTP2_DVLOG(2) << "HpackDecoderState::OnHpackDecodeError " << error_message;
   if (!error_detected_) {
     ReportError(error_message);
@@ -206,7 +207,7 @@
   }
 }
 
-void HpackDecoderState::ReportError(Http2StringPiece error_message) {
+void HpackDecoderState::ReportError(quiche::QuicheStringPiece error_message) {
   HTTP2_DVLOG(2) << "HpackDecoderState::ReportError is new="
                  << (!error_detected_ ? "true" : "false")
                  << ", error_message: " << error_message;
diff --git a/http2/hpack/decoder/hpack_decoder_state.h b/http2/hpack/decoder/hpack_decoder_state.h
index fd34179..0139b31 100644
--- a/http2/hpack/decoder/hpack_decoder_state.h
+++ b/http2/hpack/decoder/hpack_decoder_state.h
@@ -22,7 +22,7 @@
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_whole_entry_listener.h"
 #include "net/third_party/quiche/src/http2/hpack/http2_hpack_constants.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_export.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 namespace test {
@@ -76,7 +76,7 @@
                              HpackDecoderStringBuffer* name_buffer,
                              HpackDecoderStringBuffer* value_buffer) override;
   void OnDynamicTableSizeUpdate(size_t size) override;
-  void OnHpackDecodeError(Http2StringPiece error_message) override;
+  void OnHpackDecodeError(quiche::QuicheStringPiece error_message) override;
 
   // OnHeaderBlockEnd notifies this object that an entire HPACK block has been
   // decoded, which might have extended into CONTINUATION blocks.
@@ -94,7 +94,7 @@
   friend class test::HpackDecoderStatePeer;
 
   // Reports an error to the listener IF this is the first error detected.
-  void ReportError(Http2StringPiece error_message);
+  void ReportError(quiche::QuicheStringPiece error_message);
 
   // The static and dynamic HPACK tables.
   HpackDecoderTables decoder_tables_;
diff --git a/http2/hpack/decoder/hpack_decoder_state_test.cc b/http2/hpack/decoder/hpack_decoder_state_test.cc
index cbc4224..743d0d9 100644
--- a/http2/hpack/decoder/hpack_decoder_state_test.cc
+++ b/http2/hpack/decoder/hpack_decoder_state_test.cc
@@ -15,8 +15,8 @@
 #include "net/third_party/quiche/src/http2/hpack/http2_hpack_constants.h"
 #include "net/third_party/quiche/src/http2/http2_constants.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_test_helpers.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 using ::testing::AssertionResult;
 using ::testing::AssertionSuccess;
@@ -44,7 +44,8 @@
                     const HpackString& name,
                     const HpackString& value));
   MOCK_METHOD0(OnHeaderListEnd, void());
-  MOCK_METHOD1(OnHeaderErrorDetected, void(Http2StringPiece error_message));
+  MOCK_METHOD1(OnHeaderErrorDetected,
+               void(quiche::QuicheStringPiece error_message));
 };
 
 enum StringBacking { STATIC, UNBUFFERED, BUFFERED };
@@ -517,8 +518,8 @@
 
 TEST_F(HpackDecoderStateTest, ErrorsSuppressCallbacks) {
   SendStartAndVerifyCallback();
-  EXPECT_CALL(listener_,
-              OnHeaderErrorDetected(Http2StringPiece("Huffman decode error.")));
+  EXPECT_CALL(listener_, OnHeaderErrorDetected(quiche::QuicheStringPiece(
+                             "Huffman decode error.")));
   decoder_state_.OnHpackDecodeError("Huffman decode error.");
 
   // Further decoded entries are ignored.
diff --git a/http2/hpack/decoder/hpack_decoder_string_buffer.cc b/http2/hpack/decoder/hpack_decoder_string_buffer.cc
index 6a20008..d38ea9f 100644
--- a/http2/hpack/decoder/hpack_decoder_string_buffer.cc
+++ b/http2/hpack/decoder/hpack_decoder_string_buffer.cc
@@ -60,7 +60,8 @@
   state_ = State::RESET;
 }
 
-void HpackDecoderStringBuffer::Set(Http2StringPiece value, bool is_static) {
+void HpackDecoderStringBuffer::Set(quiche::QuicheStringPiece value,
+                                   bool is_static) {
   HTTP2_DVLOG(2) << "HpackDecoderStringBuffer::Set";
   DCHECK_EQ(state_, State::RESET);
   value_ = value;
@@ -100,7 +101,7 @@
     backing_ = Backing::RESET;
     // OnData is not called for empty (zero length) strings, so make sure that
     // value_ is cleared.
-    value_ = Http2StringPiece();
+    value_ = quiche::QuicheStringPiece();
   }
 }
 
@@ -113,7 +114,7 @@
 
   if (is_huffman_encoded_) {
     DCHECK_EQ(backing_, Backing::BUFFERED);
-    return decoder_.Decode(Http2StringPiece(data, len), &buffer_);
+    return decoder_.Decode(quiche::QuicheStringPiece(data, len), &buffer_);
   }
 
   if (backing_ == Backing::RESET) {
@@ -121,7 +122,7 @@
     // don't copy the string. If we later find that the HPACK entry is split
     // across input buffers, then we'll copy the string into buffer_.
     if (remaining_len_ == 0) {
-      value_ = Http2StringPiece(data, len);
+      value_ = quiche::QuicheStringPiece(data, len);
       backing_ = Backing::UNBUFFERED;
       return true;
     }
@@ -187,7 +188,7 @@
   return IsBuffered() ? buffer_.size() : 0;
 }
 
-Http2StringPiece HpackDecoderStringBuffer::str() const {
+quiche::QuicheStringPiece HpackDecoderStringBuffer::str() const {
   HTTP2_DVLOG(3) << "HpackDecoderStringBuffer::str";
   DCHECK_EQ(state_, State::COMPLETE);
   return value_;
diff --git a/http2/hpack/decoder/hpack_decoder_string_buffer.h b/http2/hpack/decoder/hpack_decoder_string_buffer.h
index d8dce6c..94c46d5 100644
--- a/http2/hpack/decoder/hpack_decoder_string_buffer.h
+++ b/http2/hpack/decoder/hpack_decoder_string_buffer.h
@@ -16,7 +16,7 @@
 
 #include "net/third_party/quiche/src/http2/hpack/huffman/hpack_huffman_decoder.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_export.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 
@@ -32,7 +32,7 @@
   HpackDecoderStringBuffer& operator=(const HpackDecoderStringBuffer&) = delete;
 
   void Reset();
-  void Set(Http2StringPiece value, bool is_static);
+  void Set(quiche::QuicheStringPiece value, bool is_static);
 
   // Note that for Huffman encoded strings the length of the string after
   // decoding may be larger (expected), the same or even smaller; the latter
@@ -47,11 +47,11 @@
   // Accessors for the completely collected string (i.e. Set or OnEnd has just
   // been called, and no reset of the state has occurred).
 
-  // Returns a Http2StringPiece pointing to the backing store for the string,
+  // Returns a QuicheStringPiece pointing to the backing store for the string,
   // either the internal buffer or the original transport buffer (e.g. for a
   // literal value that wasn't Huffman encoded, and that wasn't split across
   // transport buffers).
-  Http2StringPiece str() const;
+  quiche::QuicheStringPiece str() const;
 
   // Returns the completely collected string by value, using std::move in an
   // effort to avoid unnecessary copies. ReleaseString() must not be called
@@ -72,10 +72,10 @@
   // (e.g. if Huffman encoded, buffer_ is storage for the decoded string).
   std::string buffer_;
 
-  // The Http2StringPiece to be returned by HpackDecoderStringBuffer::str(). If
+  // The QuicheStringPiece to be returned by HpackDecoderStringBuffer::str(). If
   // a string has been collected, but not buffered, value_ points to that
   // string.
-  Http2StringPiece value_;
+  quiche::QuicheStringPiece value_;
 
   // The decoder to use if the string is Huffman encoded.
   HpackHuffmanDecoder decoder_;
diff --git a/http2/hpack/decoder/hpack_decoder_string_buffer_test.cc b/http2/hpack/decoder/hpack_decoder_string_buffer_test.cc
index ec807c8..9c30db7 100644
--- a/http2/hpack/decoder/hpack_decoder_string_buffer_test.cc
+++ b/http2/hpack/decoder/hpack_decoder_string_buffer_test.cc
@@ -47,7 +47,7 @@
 };
 
 TEST_F(HpackDecoderStringBufferTest, SetStatic) {
-  Http2StringPiece data("static string");
+  quiche::QuicheStringPiece data("static string");
 
   EXPECT_EQ(state(), State::RESET);
   EXPECT_TRUE(VerifyLogHasSubstrs({"state=RESET"}));
@@ -72,7 +72,7 @@
 }
 
 TEST_F(HpackDecoderStringBufferTest, PlainWhole) {
-  Http2StringPiece data("some text.");
+  quiche::QuicheStringPiece data("some text.");
 
   HTTP2_LOG(INFO) << buf_;
   EXPECT_EQ(state(), State::RESET);
@@ -93,8 +93,8 @@
   EXPECT_TRUE(VerifyLogHasSubstrs(
       {"state=COMPLETE", "backing=UNBUFFERED", "value: some text."}));
 
-  // We expect that the string buffer points to the passed in Http2StringPiece's
-  // backing store.
+  // We expect that the string buffer points to the passed in
+  // QuicheStringPiece's backing store.
   EXPECT_EQ(data.data(), buf_.str().data());
 
   // Now force it to buffer the string, after which it will still have the same
@@ -110,9 +110,9 @@
 }
 
 TEST_F(HpackDecoderStringBufferTest, PlainSplit) {
-  Http2StringPiece data("some text.");
-  Http2StringPiece part1 = data.substr(0, 1);
-  Http2StringPiece part2 = data.substr(1);
+  quiche::QuicheStringPiece data("some text.");
+  quiche::QuicheStringPiece part1 = data.substr(0, 1);
+  quiche::QuicheStringPiece part2 = data.substr(1);
 
   EXPECT_EQ(state(), State::RESET);
   buf_.OnStart(/*huffman_encoded*/ false, data.size());
@@ -138,7 +138,7 @@
   EXPECT_EQ(buf_.BufferedLength(), data.size());
   HTTP2_LOG(INFO) << buf_;
 
-  Http2StringPiece buffered = buf_.str();
+  quiche::QuicheStringPiece buffered = buf_.str();
   EXPECT_EQ(data, buffered);
   EXPECT_NE(data.data(), buffered.data());
 
@@ -153,7 +153,7 @@
 
 TEST_F(HpackDecoderStringBufferTest, HuffmanWhole) {
   std::string encoded = Http2HexDecode("f1e3c2e5f23a6ba0ab90f4ff");
-  Http2StringPiece decoded("www.example.com");
+  quiche::QuicheStringPiece decoded("www.example.com");
 
   EXPECT_EQ(state(), State::RESET);
   buf_.OnStart(/*huffman_encoded*/ true, encoded.size());
@@ -180,7 +180,7 @@
   std::string encoded = Http2HexDecode("f1e3c2e5f23a6ba0ab90f4ff");
   std::string part1 = encoded.substr(0, 5);
   std::string part2 = encoded.substr(5);
-  Http2StringPiece decoded("www.example.com");
+  quiche::QuicheStringPiece decoded("www.example.com");
 
   EXPECT_EQ(state(), State::RESET);
   buf_.OnStart(/*huffman_encoded*/ true, encoded.size());
diff --git a/http2/hpack/decoder/hpack_decoder_test.cc b/http2/hpack/decoder/hpack_decoder_test.cc
index 9734bdd..f2ff8c2 100644
--- a/http2/hpack/decoder/hpack_decoder_test.cc
+++ b/http2/hpack/decoder/hpack_decoder_test.cc
@@ -70,7 +70,8 @@
                     const HpackString& name,
                     const HpackString& value));
   MOCK_METHOD0(OnHeaderListEnd, void());
-  MOCK_METHOD1(OnHeaderErrorDetected, void(Http2StringPiece error_message));
+  MOCK_METHOD1(OnHeaderErrorDetected,
+               void(quiche::QuicheStringPiece error_message));
 };
 
 class HpackDecoderTest : public ::testing::TestWithParam<bool>,
@@ -119,7 +120,7 @@
 
   // OnHeaderErrorDetected is called if an error is detected while decoding.
   // error_message may be used in a GOAWAY frame as the Opaque Data.
-  void OnHeaderErrorDetected(Http2StringPiece error_message) override {
+  void OnHeaderErrorDetected(quiche::QuicheStringPiece error_message) override {
     ASSERT_TRUE(saw_start_);
     error_messages_.push_back(std::string(error_message));
     // No further callbacks should be made at this point, so replace 'this' as
@@ -129,7 +130,7 @@
         HpackDecoderPeer::GetDecoderState(&decoder_), &mock_listener_);
   }
 
-  AssertionResult DecodeBlock(Http2StringPiece block) {
+  AssertionResult DecodeBlock(quiche::QuicheStringPiece block) {
     HTTP2_VLOG(1) << "HpackDecoderTest::DecodeBlock";
 
     VERIFY_FALSE(decoder_.error_detected());
diff --git a/http2/hpack/decoder/hpack_entry_collector.cc b/http2/hpack/decoder/hpack_entry_collector.cc
index 7706bd6..80d4f92 100644
--- a/http2/hpack/decoder/hpack_entry_collector.cc
+++ b/http2/hpack/decoder/hpack_entry_collector.cc
@@ -166,7 +166,7 @@
     HpackEntryType expected_type,
     size_t expected_index,
     bool expected_value_huffman,
-    Http2StringPiece expected_value) const {
+    quiche::QuicheStringPiece expected_value) const {
   VERIFY_TRUE(started_);
   VERIFY_TRUE(ended_);
   VERIFY_EQ(expected_type, header_type_);
@@ -179,9 +179,9 @@
 AssertionResult HpackEntryCollector::ValidateLiteralNameValueHeader(
     HpackEntryType expected_type,
     bool expected_name_huffman,
-    Http2StringPiece expected_name,
+    quiche::QuicheStringPiece expected_name,
     bool expected_value_huffman,
-    Http2StringPiece expected_value) const {
+    quiche::QuicheStringPiece expected_value) const {
   VERIFY_TRUE(started_);
   VERIFY_TRUE(ended_);
   VERIFY_EQ(expected_type, header_type_);
diff --git a/http2/hpack/decoder/hpack_entry_collector.h b/http2/hpack/decoder/hpack_entry_collector.h
index 6b27b7b..abf9d97 100644
--- a/http2/hpack/decoder/hpack_entry_collector.h
+++ b/http2/hpack/decoder/hpack_entry_collector.h
@@ -20,7 +20,7 @@
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_string_collector.h"
 #include "net/third_party/quiche/src/http2/hpack/http2_hpack_constants.h"
 #include "net/third_party/quiche/src/http2/hpack/tools/hpack_block_builder.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 namespace test {
@@ -85,16 +85,16 @@
       HpackEntryType expected_type,
       size_t expected_index,
       bool expected_value_huffman,
-      Http2StringPiece expected_value) const;
+      quiche::QuicheStringPiece expected_value) const;
 
   // Returns success if collected a Header with an literal name and literal
   // value.
   ::testing::AssertionResult ValidateLiteralNameValueHeader(
       HpackEntryType expected_type,
       bool expected_name_huffman,
-      Http2StringPiece expected_name,
+      quiche::QuicheStringPiece expected_name,
       bool expected_value_huffman,
-      Http2StringPiece expected_value) const;
+      quiche::QuicheStringPiece expected_value) const;
 
   // Returns success if collected a Dynamic Table Size Update,
   // with the specified size.
diff --git a/http2/hpack/decoder/hpack_string_collector.cc b/http2/hpack/decoder/hpack_string_collector.cc
index e903755..0b18178 100644
--- a/http2/hpack/decoder/hpack_string_collector.cc
+++ b/http2/hpack/decoder/hpack_string_collector.cc
@@ -66,7 +66,7 @@
 }
 
 void HpackStringCollector::OnStringData(const char* data, size_t length) {
-  Http2StringPiece sp(data, length);
+  quiche::QuicheStringPiece sp(data, length);
   EXPECT_TRUE(IsInProgress()) << ToString();
   EXPECT_LE(sp.size(), len) << ToString();
   Http2StrAppend(&s, sp);
@@ -80,7 +80,7 @@
 }
 
 ::testing::AssertionResult HpackStringCollector::Collected(
-    Http2StringPiece str,
+    quiche::QuicheStringPiece str,
     bool is_huffman_encoded) const {
   VERIFY_TRUE(HasEnded());
   VERIFY_EQ(str.size(), len);
diff --git a/http2/hpack/decoder/hpack_string_collector.h b/http2/hpack/decoder/hpack_string_collector.h
index d56abee..8326a57 100644
--- a/http2/hpack/decoder/hpack_string_collector.h
+++ b/http2/hpack/decoder/hpack_string_collector.h
@@ -14,7 +14,7 @@
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_string_decoder_listener.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 namespace test {
@@ -40,7 +40,7 @@
   void OnStringData(const char* data, size_t length) override;
   void OnStringEnd() override;
 
-  ::testing::AssertionResult Collected(Http2StringPiece str,
+  ::testing::AssertionResult Collected(quiche::QuicheStringPiece str,
                                        bool is_huffman_encoded) const;
 
   std::string ToString() const;
diff --git a/http2/hpack/decoder/hpack_string_decoder_test.cc b/http2/hpack/decoder/hpack_string_decoder_test.cc
index ceeebca..6c81b57 100644
--- a/http2/hpack/decoder/hpack_string_decoder_test.cc
+++ b/http2/hpack/decoder/hpack_string_decoder_test.cc
@@ -10,10 +10,10 @@
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_string_collector.h"
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_string_decoder_listener.h"
 #include "net/third_party/quiche/src/http2/hpack/tools/hpack_block_builder.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_test_helpers.h"
 #include "net/third_party/quiche/src/http2/test_tools/http2_random.h"
 #include "net/third_party/quiche/src/http2/tools/random_decoder_test.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 using ::testing::AssertionResult;
 
@@ -43,13 +43,13 @@
     return decoder_.Resume(b, &listener_);
   }
 
-  AssertionResult Collected(Http2StringPiece s, bool huffman_encoded) {
+  AssertionResult Collected(quiche::QuicheStringPiece s, bool huffman_encoded) {
     HTTP2_VLOG(1) << collector_;
     return collector_.Collected(s, huffman_encoded);
   }
 
   // expected_str is a std::string rather than a const std::string& or
-  // Http2StringPiece so that the lambda makes a copy of the string, and thus
+  // QuicheStringPiece so that the lambda makes a copy of the string, and thus
   // the string to be passed to Collected outlives the call to MakeValidator.
   Validator MakeValidator(const std::string& expected_str,
                           bool expected_huffman) {
@@ -111,7 +111,7 @@
   {
     Validator validator =
         ValidateDoneAndOffset(11, MakeValidator("start end.", kUncompressed));
-    Http2StringPiece data("\x0astart end.");
+    quiche::QuicheStringPiece data("\x0astart end.");
     DecodeBuffer b(data);
     EXPECT_TRUE(
         DecodeAndValidateSeveralWays(&b, kMayReturnZeroOnFirst, validator));
diff --git a/http2/hpack/decoder/hpack_whole_entry_buffer.cc b/http2/hpack/decoder/hpack_whole_entry_buffer.cc
index dea6698..1f1f4f0 100644
--- a/http2/hpack/decoder/hpack_whole_entry_buffer.cc
+++ b/http2/hpack/decoder/hpack_whole_entry_buffer.cc
@@ -67,7 +67,7 @@
 void HpackWholeEntryBuffer::OnNameData(const char* data, size_t len) {
   HTTP2_DVLOG(2) << "HpackWholeEntryBuffer::OnNameData: len=" << len
                  << " data:\n"
-                 << Http2HexDump(Http2StringPiece(data, len));
+                 << Http2HexDump(quiche::QuicheStringPiece(data, len));
   DCHECK_EQ(maybe_name_index_, 0u);
   if (!error_detected_ && !name_.OnData(data, len)) {
     ReportError("Error decoding HPACK entry name.");
@@ -100,7 +100,7 @@
 void HpackWholeEntryBuffer::OnValueData(const char* data, size_t len) {
   HTTP2_DVLOG(2) << "HpackWholeEntryBuffer::OnValueData: len=" << len
                  << " data:\n"
-                 << Http2HexDump(Http2StringPiece(data, len));
+                 << Http2HexDump(quiche::QuicheStringPiece(data, len));
   if (!error_detected_ && !value_.OnData(data, len)) {
     ReportError("Error decoding HPACK entry value.");
   }
@@ -131,7 +131,8 @@
   listener_->OnDynamicTableSizeUpdate(size);
 }
 
-void HpackWholeEntryBuffer::ReportError(Http2StringPiece error_message) {
+void HpackWholeEntryBuffer::ReportError(
+    quiche::QuicheStringPiece error_message) {
   if (!error_detected_) {
     HTTP2_DVLOG(1) << "HpackWholeEntryBuffer::ReportError: " << error_message;
     error_detected_ = true;
diff --git a/http2/hpack/decoder/hpack_whole_entry_buffer.h b/http2/hpack/decoder/hpack_whole_entry_buffer.h
index 61bf583..814c1b4 100644
--- a/http2/hpack/decoder/hpack_whole_entry_buffer.h
+++ b/http2/hpack/decoder/hpack_whole_entry_buffer.h
@@ -17,7 +17,7 @@
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_whole_entry_listener.h"
 #include "net/third_party/quiche/src/http2/hpack/http2_hpack_constants.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_export.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 
@@ -79,7 +79,7 @@
   void OnDynamicTableSizeUpdate(size_t size) override;
 
  private:
-  void ReportError(Http2StringPiece error_message);
+  void ReportError(quiche::QuicheStringPiece error_message);
 
   HpackWholeEntryListener* listener_;
   HpackDecoderStringBuffer name_, value_;
diff --git a/http2/hpack/decoder/hpack_whole_entry_buffer_test.cc b/http2/hpack/decoder/hpack_whole_entry_buffer_test.cc
index 0265e9c..4ac82ea 100644
--- a/http2/hpack/decoder/hpack_whole_entry_buffer_test.cc
+++ b/http2/hpack/decoder/hpack_whole_entry_buffer_test.cc
@@ -37,7 +37,8 @@
                     HpackDecoderStringBuffer* name_buffer,
                     HpackDecoderStringBuffer* value_buffer));
   MOCK_METHOD1(OnDynamicTableSizeUpdate, void(size_t size));
-  MOCK_METHOD1(OnHpackDecodeError, void(Http2StringPiece error_message));
+  MOCK_METHOD1(OnHpackDecodeError,
+               void(quiche::QuicheStringPiece error_message));
 };
 
 class HpackWholeEntryBufferTest : public ::testing::Test {
diff --git a/http2/hpack/decoder/hpack_whole_entry_listener.cc b/http2/hpack/decoder/hpack_whole_entry_listener.cc
index b92e64a..69cf122 100644
--- a/http2/hpack/decoder/hpack_whole_entry_listener.cc
+++ b/http2/hpack/decoder/hpack_whole_entry_listener.cc
@@ -21,7 +21,7 @@
     HpackDecoderStringBuffer* value_buffer) {}
 void HpackWholeEntryNoOpListener::OnDynamicTableSizeUpdate(size_t size) {}
 void HpackWholeEntryNoOpListener::OnHpackDecodeError(
-    Http2StringPiece error_message) {}
+    quiche::QuicheStringPiece error_message) {}
 
 // static
 HpackWholeEntryNoOpListener* HpackWholeEntryNoOpListener::NoOpListener() {
diff --git a/http2/hpack/decoder/hpack_whole_entry_listener.h b/http2/hpack/decoder/hpack_whole_entry_listener.h
index 2e559ce..eabe34a 100644
--- a/http2/hpack/decoder/hpack_whole_entry_listener.h
+++ b/http2/hpack/decoder/hpack_whole_entry_listener.h
@@ -14,7 +14,7 @@
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_decoder_string_buffer.h"
 #include "net/third_party/quiche/src/http2/hpack/http2_hpack_constants.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_export.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 
@@ -51,7 +51,7 @@
 
   // OnHpackDecodeError is called if an error is detected while decoding.
   // error_message may be used in a GOAWAY frame as the Opaque Data.
-  virtual void OnHpackDecodeError(Http2StringPiece error_message) = 0;
+  virtual void OnHpackDecodeError(quiche::QuicheStringPiece error_message) = 0;
 };
 
 // A no-op implementation of HpackWholeEntryDecoderListener, useful for ignoring
@@ -69,7 +69,7 @@
                              HpackDecoderStringBuffer* name_buffer,
                              HpackDecoderStringBuffer* value_buffer) override;
   void OnDynamicTableSizeUpdate(size_t size) override;
-  void OnHpackDecodeError(Http2StringPiece error_message) override;
+  void OnHpackDecodeError(quiche::QuicheStringPiece error_message) override;
 
   // Returns a listener that ignores all the calls.
   static HpackWholeEntryNoOpListener* NoOpListener();
diff --git a/http2/hpack/hpack_string.cc b/http2/hpack/hpack_string.cc
index 85ba812..77ae5a3 100644
--- a/http2/hpack/hpack_string.cc
+++ b/http2/hpack/hpack_string.cc
@@ -12,32 +12,33 @@
 namespace http2 {
 
 HpackString::HpackString(const char* data) : str_(data) {}
-HpackString::HpackString(Http2StringPiece str) : str_(std::string(str)) {}
+HpackString::HpackString(quiche::QuicheStringPiece str)
+    : str_(std::string(str)) {}
 HpackString::HpackString(std::string str) : str_(std::move(str)) {}
 HpackString::HpackString(const HpackString& other) = default;
 HpackString::~HpackString() = default;
 
-Http2StringPiece HpackString::ToStringPiece() const {
+quiche::QuicheStringPiece HpackString::ToStringPiece() const {
   return str_;
 }
 
 bool HpackString::operator==(const HpackString& other) const {
   return str_ == other.str_;
 }
-bool HpackString::operator==(Http2StringPiece str) const {
+bool HpackString::operator==(quiche::QuicheStringPiece str) const {
   return str == str_;
 }
 
-bool operator==(Http2StringPiece a, const HpackString& b) {
+bool operator==(quiche::QuicheStringPiece a, const HpackString& b) {
   return b == a;
 }
-bool operator!=(Http2StringPiece a, const HpackString& b) {
+bool operator!=(quiche::QuicheStringPiece a, const HpackString& b) {
   return !(b == a);
 }
 bool operator!=(const HpackString& a, const HpackString& b) {
   return !(a == b);
 }
-bool operator!=(const HpackString& a, Http2StringPiece b) {
+bool operator!=(const HpackString& a, quiche::QuicheStringPiece b) {
   return !(a == b);
 }
 std::ostream& operator<<(std::ostream& out, const HpackString& v) {
@@ -50,7 +51,8 @@
   HTTP2_DVLOG(3) << DebugString() << " ctor";
 }
 
-HpackStringPair::HpackStringPair(Http2StringPiece name, Http2StringPiece value)
+HpackStringPair::HpackStringPair(quiche::QuicheStringPiece name,
+                                 quiche::QuicheStringPiece value)
     : name(name), value(value) {
   HTTP2_DVLOG(3) << DebugString() << " ctor";
 }
diff --git a/http2/hpack/hpack_string.h b/http2/hpack/hpack_string.h
index e1535f7..9aac58e 100644
--- a/http2/hpack/hpack_string.h
+++ b/http2/hpack/hpack_string.h
@@ -16,14 +16,14 @@
 #include <string>
 
 #include "net/third_party/quiche/src/http2/platform/api/http2_export.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 
 class HTTP2_EXPORT_PRIVATE HpackString {
  public:
   explicit HpackString(const char* data);
-  explicit HpackString(Http2StringPiece str);
+  explicit HpackString(quiche::QuicheStringPiece str);
   explicit HpackString(std::string str);
   HpackString(const HpackString& other);
 
@@ -34,27 +34,31 @@
 
   size_t size() const { return str_.size(); }
   const std::string& ToString() const { return str_; }
-  Http2StringPiece ToStringPiece() const;
+  quiche::QuicheStringPiece ToStringPiece() const;
 
   bool operator==(const HpackString& other) const;
 
-  bool operator==(Http2StringPiece str) const;
+  bool operator==(quiche::QuicheStringPiece str) const;
 
  private:
   std::string str_;
 };
 
-HTTP2_EXPORT_PRIVATE bool operator==(Http2StringPiece a, const HpackString& b);
-HTTP2_EXPORT_PRIVATE bool operator!=(Http2StringPiece a, const HpackString& b);
+HTTP2_EXPORT_PRIVATE bool operator==(quiche::QuicheStringPiece a,
+                                     const HpackString& b);
+HTTP2_EXPORT_PRIVATE bool operator!=(quiche::QuicheStringPiece a,
+                                     const HpackString& b);
 HTTP2_EXPORT_PRIVATE bool operator!=(const HpackString& a,
                                      const HpackString& b);
-HTTP2_EXPORT_PRIVATE bool operator!=(const HpackString& a, Http2StringPiece b);
+HTTP2_EXPORT_PRIVATE bool operator!=(const HpackString& a,
+                                     quiche::QuicheStringPiece b);
 HTTP2_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
                                               const HpackString& v);
 
 struct HTTP2_EXPORT_PRIVATE HpackStringPair {
   HpackStringPair(const HpackString& name, const HpackString& value);
-  HpackStringPair(Http2StringPiece name, Http2StringPiece value);
+  HpackStringPair(quiche::QuicheStringPiece name,
+                  quiche::QuicheStringPiece value);
   ~HpackStringPair();
 
   // Returns the size of a header entry with this name and value, per the RFC:
diff --git a/http2/hpack/hpack_string_test.cc b/http2/hpack/hpack_string_test.cc
index 9230ecc..0673f5e 100644
--- a/http2/hpack/hpack_string_test.cc
+++ b/http2/hpack/hpack_string_test.cc
@@ -28,7 +28,7 @@
   AssertionResult VerifyNotEqual(HpackString* actual,
                                  const std::string& not_expected_str) {
     const char* not_expected_ptr = not_expected_str.c_str();
-    Http2StringPiece not_expected_sp(not_expected_str);
+    quiche::QuicheStringPiece not_expected_sp(not_expected_str);
 
     VERIFY_NE(*actual, not_expected_ptr);
     VERIFY_NE(*actual, not_expected_sp);
@@ -56,7 +56,7 @@
     VERIFY_EQ(actual->size(), expected_str.size());
 
     const char* expected_ptr = expected_str.c_str();
-    const Http2StringPiece expected_sp(expected_str);
+    const quiche::QuicheStringPiece expected_sp(expected_str);
 
     VERIFY_EQ(*actual, expected_ptr);
     VERIFY_EQ(*actual, expected_sp);
@@ -91,12 +91,12 @@
 }
 
 TEST_F(HpackStringTest, StringPieceConstructor) {
-  Http2StringPiece sp0(kStr0);
+  quiche::QuicheStringPiece sp0(kStr0);
   HpackString hs0(sp0);
   EXPECT_TRUE(VerifyEqual(&hs0, kStr0));
   EXPECT_TRUE(VerifyNotEqual(&hs0, kStr1));
 
-  Http2StringPiece sp1(kStr1);
+  quiche::QuicheStringPiece sp1(kStr1);
   HpackString hs1(sp1);
   EXPECT_TRUE(VerifyEqual(&hs1, kStr1));
   EXPECT_TRUE(VerifyNotEqual(&hs1, kStr0));
@@ -115,7 +115,7 @@
 }
 
 TEST_F(HpackStringTest, CopyConstructor) {
-  Http2StringPiece sp0(kStr0);
+  quiche::QuicheStringPiece sp0(kStr0);
   HpackString hs0(sp0);
   HpackString hs1(hs0);
   EXPECT_EQ(hs0, hs1);
@@ -128,7 +128,7 @@
 }
 
 TEST_F(HpackStringTest, MoveConstructor) {
-  Http2StringPiece sp0(kStr0);
+  quiche::QuicheStringPiece sp0(kStr0);
   HpackString hs0(sp0);
   EXPECT_TRUE(VerifyEqual(&hs0, kStr0));
   EXPECT_TRUE(VerifyNotEqual(&hs0, ""));
diff --git a/http2/hpack/huffman/hpack_huffman_decoder.cc b/http2/hpack/huffman/hpack_huffman_decoder.cc
index 71ce855..18bff72 100644
--- a/http2/hpack/huffman/hpack_huffman_decoder.cc
+++ b/http2/hpack/huffman/hpack_huffman_decoder.cc
@@ -356,7 +356,7 @@
   count_ = 0;
 }
 
-size_t HuffmanBitBuffer::AppendBytes(Http2StringPiece input) {
+size_t HuffmanBitBuffer::AppendBytes(quiche::QuicheStringPiece input) {
   HuffmanAccumulatorBitCount free_cnt = free_count();
   size_t bytes_available = input.size();
   if (free_cnt < 8 || bytes_available == 0) {
@@ -414,7 +414,8 @@
 
 HpackHuffmanDecoder::~HpackHuffmanDecoder() = default;
 
-bool HpackHuffmanDecoder::Decode(Http2StringPiece input, std::string* output) {
+bool HpackHuffmanDecoder::Decode(quiche::QuicheStringPiece input,
+                                 std::string* output) {
   HTTP2_DVLOG(1) << "HpackHuffmanDecoder::Decode";
 
   // Fill bit_buffer_ from input.
diff --git a/http2/hpack/huffman/hpack_huffman_decoder.h b/http2/hpack/huffman/hpack_huffman_decoder.h
index 065fe85..73c0162 100644
--- a/http2/hpack/huffman/hpack_huffman_decoder.h
+++ b/http2/hpack/huffman/hpack_huffman_decoder.h
@@ -19,7 +19,7 @@
 #include <string>
 
 #include "net/third_party/quiche/src/http2/platform/api/http2_export.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 
@@ -47,7 +47,7 @@
 
   // Add as many whole bytes to the accumulator (accumulator_) as possible,
   // returning the number of bytes added.
-  size_t AppendBytes(Http2StringPiece input);
+  size_t AppendBytes(quiche::QuicheStringPiece input);
 
   // Get the bits of the accumulator.
   HuffmanAccumulator value() const { return accumulator_; }
@@ -109,7 +109,7 @@
   // will contain the leading bits of the code for that symbol, but not the
   // final bits of that code.
   // Note that output should be empty, but that it is not cleared by Decode().
-  bool Decode(Http2StringPiece input, std::string* output);
+  bool Decode(quiche::QuicheStringPiece input, std::string* output);
 
   // Is what remains in the bit_buffer_ valid at the end of an encoded string?
   // Call after passing the the final portion of a Huffman string to Decode,
diff --git a/http2/hpack/huffman/hpack_huffman_decoder_test.cc b/http2/hpack/huffman/hpack_huffman_decoder_test.cc
index f1bed3c..e5a6e28 100644
--- a/http2/hpack/huffman/hpack_huffman_decoder_test.cc
+++ b/http2/hpack/huffman/hpack_huffman_decoder_test.cc
@@ -36,7 +36,7 @@
   s.push_back('\x11');
   s.push_back('\x22');
   s.push_back('\x33');
-  Http2StringPiece sp(s);
+  quiche::QuicheStringPiece sp(s);
 
   HuffmanBitBuffer bb;
   sp.remove_prefix(bb.AppendBytes(sp));
@@ -85,7 +85,7 @@
   s.push_back('\x11');
   s.push_back('\x22');
   s.push_back('\x33');
-  Http2StringPiece sp(s);
+  quiche::QuicheStringPiece sp(s);
 
   HuffmanBitBuffer bb;
   sp.remove_prefix(bb.AppendBytes(sp));
@@ -117,7 +117,7 @@
   s.push_back('\xbb');
   s.push_back('\xcc');
   s.push_back('\xdd');
-  Http2StringPiece sp(s);
+  quiche::QuicheStringPiece sp(s);
 
   HuffmanBitBuffer bb;
   sp.remove_prefix(bb.AppendBytes(sp));
@@ -161,10 +161,10 @@
 
   DecodeStatus ResumeDecoding(DecodeBuffer* b) override {
     input_bytes_seen_ += b->Remaining();
-    Http2StringPiece sp(b->cursor(), b->Remaining());
+    quiche::QuicheStringPiece sp(b->cursor(), b->Remaining());
     if (decoder_.Decode(sp, &output_buffer_)) {
       b->AdvanceCursor(b->Remaining());
-      // Successfully decoded (or buffered) the bytes in Http2StringPiece.
+      // Successfully decoded (or buffered) the bytes in QuicheStringPiece.
       EXPECT_LE(input_bytes_seen_, input_bytes_expected_);
       // Have we reached the end of the encoded string?
       if (input_bytes_expected_ == input_bytes_seen_) {
diff --git a/http2/hpack/huffman/hpack_huffman_encoder.cc b/http2/hpack/huffman/hpack_huffman_encoder.cc
index 8a5dee9..8b3f29f 100644
--- a/http2/hpack/huffman/hpack_huffman_encoder.cc
+++ b/http2/hpack/huffman/hpack_huffman_encoder.cc
@@ -11,7 +11,7 @@
 
 namespace http2 {
 
-size_t ExactHuffmanSize(Http2StringPiece plain) {
+size_t ExactHuffmanSize(quiche::QuicheStringPiece plain) {
   size_t bits = 0;
   for (const uint8_t c : plain) {
     bits += HuffmanSpecTables::kCodeLengths[c];
@@ -19,7 +19,7 @@
   return (bits + 7) / 8;
 }
 
-size_t BoundedHuffmanSize(Http2StringPiece plain) {
+size_t BoundedHuffmanSize(quiche::QuicheStringPiece plain) {
   // TODO(jamessynge): Determine whether we should set the min size for Huffman
   // encoding much higher (i.e. if less than N, then the savings isn't worth
   // the cost of encoding and decoding). Of course, we need to decide on a
@@ -61,7 +61,7 @@
   return (bits + 7) / 8;
 }
 
-void HuffmanEncode(Http2StringPiece plain, std::string* huffman) {
+void HuffmanEncode(quiche::QuicheStringPiece plain, std::string* huffman) {
   DCHECK(huffman != nullptr);
   huffman->clear();         // Note that this doesn't release memory.
   uint64_t bit_buffer = 0;  // High-bit is next bit to output. Not clear if that
diff --git a/http2/hpack/huffman/hpack_huffman_encoder.h b/http2/hpack/huffman/hpack_huffman_encoder.h
index 247aaff..f7a8e94 100644
--- a/http2/hpack/huffman/hpack_huffman_encoder.h
+++ b/http2/hpack/huffman/hpack_huffman_encoder.h
@@ -12,13 +12,13 @@
 #include <string>
 
 #include "net/third_party/quiche/src/http2/platform/api/http2_export.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 
 // Returns the size of the Huffman encoding of |plain|, which may be greater
 // than plain.size(). Mostly present for testing.
-HTTP2_EXPORT_PRIVATE size_t ExactHuffmanSize(Http2StringPiece plain);
+HTTP2_EXPORT_PRIVATE size_t ExactHuffmanSize(quiche::QuicheStringPiece plain);
 
 // Returns the size of the Huffman encoding of |plain|, unless it is greater
 // than or equal to plain.size(), in which case a value greater than or equal to
@@ -26,13 +26,13 @@
 // it doesn't read as much of the input string in the event that the string is
 // not compressible by HuffmanEncode (i.e. when the encoding is longer than the
 // original string, it stops reading the input string as soon as it knows that).
-HTTP2_EXPORT_PRIVATE size_t BoundedHuffmanSize(Http2StringPiece plain);
+HTTP2_EXPORT_PRIVATE size_t BoundedHuffmanSize(quiche::QuicheStringPiece plain);
 
 // Encode the plain text string |plain| with the Huffman encoding defined in
 // the HPACK RFC, 7541.  |*huffman| does not have to be empty, it is cleared at
 // the beginning of this function.  This allows reusing the same string object
 // across multiple invocations.
-HTTP2_EXPORT_PRIVATE void HuffmanEncode(Http2StringPiece plain,
+HTTP2_EXPORT_PRIVATE void HuffmanEncode(quiche::QuicheStringPiece plain,
                                         std::string* huffman);
 
 }  // namespace http2
diff --git a/http2/hpack/huffman/hpack_huffman_transcoder_test.cc b/http2/hpack/huffman/hpack_huffman_transcoder_test.cc
index 9781094..b7407a3 100644
--- a/http2/hpack/huffman/hpack_huffman_transcoder_test.cc
+++ b/http2/hpack/huffman/hpack_huffman_transcoder_test.cc
@@ -11,9 +11,9 @@
 #include "net/third_party/quiche/src/http2/decoder/decode_status.h"
 #include "net/third_party/quiche/src/http2/hpack/huffman/hpack_huffman_decoder.h"
 #include "net/third_party/quiche/src/http2/hpack/huffman/hpack_huffman_encoder.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string_utils.h"
 #include "net/third_party/quiche/src/http2/tools/random_decoder_test.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 using ::testing::AssertionResult;
 using ::testing::AssertionSuccess;
@@ -52,10 +52,10 @@
 
   DecodeStatus ResumeDecoding(DecodeBuffer* b) override {
     input_bytes_seen_ += b->Remaining();
-    Http2StringPiece sp(b->cursor(), b->Remaining());
+    quiche::QuicheStringPiece sp(b->cursor(), b->Remaining());
     if (decoder_.Decode(sp, &output_buffer_)) {
       b->AdvanceCursor(b->Remaining());
-      // Successfully decoded (or buffered) the bytes in Http2StringPiece.
+      // Successfully decoded (or buffered) the bytes in QuicheStringPiece.
       EXPECT_LE(input_bytes_seen_, input_bytes_expected_);
       // Have we reached the end of the encoded string?
       if (input_bytes_expected_ == input_bytes_seen_) {
@@ -71,8 +71,8 @@
   }
 
   AssertionResult TranscodeAndValidateSeveralWays(
-      Http2StringPiece plain,
-      Http2StringPiece expected_huffman) {
+      quiche::QuicheStringPiece plain,
+      quiche::QuicheStringPiece expected_huffman) {
     std::string encoded;
     HuffmanEncode(plain, &encoded);
     if (expected_huffman.size() > 0 || plain.empty()) {
@@ -90,7 +90,8 @@
                                         ValidateDoneAndEmpty(validator));
   }
 
-  AssertionResult TranscodeAndValidateSeveralWays(Http2StringPiece plain) {
+  AssertionResult TranscodeAndValidateSeveralWays(
+      quiche::QuicheStringPiece plain) {
     return TranscodeAndValidateSeveralWays(plain, "");
   }
 
diff --git a/http2/hpack/tools/hpack_block_builder.cc b/http2/hpack/tools/hpack_block_builder.cc
index 5b2ab75..3175c1d 100644
--- a/http2/hpack/tools/hpack_block_builder.cc
+++ b/http2/hpack/tools/hpack_block_builder.cc
@@ -55,7 +55,7 @@
 }
 
 void HpackBlockBuilder::AppendString(bool is_huffman_encoded,
-                                     Http2StringPiece str) {
+                                     quiche::QuicheStringPiece str) {
   uint8_t high_bits = is_huffman_encoded ? 0x80 : 0;
   uint8_t prefix_length = 7;
   AppendHighBitsAndVarint(high_bits, prefix_length, str.size());
diff --git a/http2/hpack/tools/hpack_block_builder.h b/http2/hpack/tools/hpack_block_builder.h
index 59c3805..b96d262 100644
--- a/http2/hpack/tools/hpack_block_builder.h
+++ b/http2/hpack/tools/hpack_block_builder.h
@@ -22,14 +22,14 @@
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "net/third_party/quiche/src/http2/hpack/http2_hpack_constants.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 namespace test {
 
 class HpackBlockBuilder {
  public:
-  explicit HpackBlockBuilder(Http2StringPiece initial_contents)
+  explicit HpackBlockBuilder(quiche::QuicheStringPiece initial_contents)
       : buffer_(initial_contents.data(), initial_contents.size()) {}
   HpackBlockBuilder() {}
   ~HpackBlockBuilder() {}
@@ -51,7 +51,7 @@
   void AppendNameIndexAndLiteralValue(HpackEntryType entry_type,
                                       uint64_t name_index,
                                       bool value_is_huffman_encoded,
-                                      Http2StringPiece value) {
+                                      quiche::QuicheStringPiece value) {
     // name_index==0 would indicate that the entry includes a literal name.
     // Call AppendLiteralNameAndValue in that case.
     EXPECT_NE(0u, name_index);
@@ -61,9 +61,9 @@
 
   void AppendLiteralNameAndValue(HpackEntryType entry_type,
                                  bool name_is_huffman_encoded,
-                                 Http2StringPiece name,
+                                 quiche::QuicheStringPiece name,
                                  bool value_is_huffman_encoded,
-                                 Http2StringPiece value) {
+                                 quiche::QuicheStringPiece value) {
     AppendEntryTypeAndVarint(entry_type, 0);
     AppendString(name_is_huffman_encoded, name);
     AppendString(value_is_huffman_encoded, value);
@@ -84,7 +84,7 @@
 
   // Append a header string (i.e. a header name or value) in HPACK format.
   // Does NOT perform Huffman encoding.
-  void AppendString(bool is_huffman_encoded, Http2StringPiece str);
+  void AppendString(bool is_huffman_encoded, quiche::QuicheStringPiece str);
 
  private:
   std::string buffer_;
diff --git a/http2/hpack/tools/hpack_block_builder_test.cc b/http2/hpack/tools/hpack_block_builder_test.cc
index bba363f..21f161e 100644
--- a/http2/hpack/tools/hpack_block_builder_test.cc
+++ b/http2/hpack/tools/hpack_block_builder_test.cc
@@ -120,7 +120,8 @@
                                           '\xab', '\x90', '\xf4', '\xff'};
     b.AppendNameIndexAndLiteralValue(
         HpackEntryType::kIndexedLiteralHeader, 1, kCompressed,
-        Http2StringPiece(kHuffmanWwwExampleCom, sizeof kHuffmanWwwExampleCom));
+        quiche::QuicheStringPiece(kHuffmanWwwExampleCom,
+                                  sizeof kHuffmanWwwExampleCom));
     EXPECT_EQ(17u, b.size());
 
     // Hex dump of encoded data (copied from RFC):
@@ -140,7 +141,7 @@
     EXPECT_EQ(1u, b.size());
 
     const char kData[] = {'\x20'};
-    Http2StringPiece expected(kData, sizeof kData);
+    quiche::QuicheStringPiece expected(kData, sizeof kData);
     EXPECT_EQ(expected, b.buffer());
   }
   {
@@ -149,7 +150,7 @@
     EXPECT_EQ(3u, b.size());
 
     const char kData[] = {'\x3f', '\xe1', '\x1f'};
-    Http2StringPiece expected(kData, sizeof kData);
+    quiche::QuicheStringPiece expected(kData, sizeof kData);
     EXPECT_EQ(expected, b.buffer());
   }
   {
@@ -159,7 +160,7 @@
 
     const char kData[] = {'\x3f', '\xe1', '\x9f', '\x94',
                           '\xa5', '\x8d', '\x1d'};
-    Http2StringPiece expected(kData, sizeof kData);
+    quiche::QuicheStringPiece expected(kData, sizeof kData);
     EXPECT_EQ(expected, b.buffer());
   }
 }
diff --git a/http2/hpack/tools/hpack_example.cc b/http2/hpack/tools/hpack_example.cc
index 52d84f9..5e0e40c 100644
--- a/http2/hpack/tools/hpack_example.cc
+++ b/http2/hpack/tools/hpack_example.cc
@@ -14,7 +14,8 @@
 namespace test {
 namespace {
 
-void HpackExampleToStringOrDie(Http2StringPiece example, std::string* output) {
+void HpackExampleToStringOrDie(quiche::QuicheStringPiece example,
+                               std::string* output) {
   while (!example.empty()) {
     const char c0 = example[0];
     if (isxdigit(c0)) {
@@ -32,7 +33,7 @@
     if (!example.empty() && example[0] == '|') {
       // Start of a comment. Skip to end of line or of input.
       auto pos = example.find('\n');
-      if (pos == Http2StringPiece::npos) {
+      if (pos == quiche::QuicheStringPiece::npos) {
         // End of input.
         break;
       }
@@ -48,7 +49,7 @@
 
 }  // namespace
 
-std::string HpackExampleToStringOrDie(Http2StringPiece example) {
+std::string HpackExampleToStringOrDie(quiche::QuicheStringPiece example) {
   std::string output;
   HpackExampleToStringOrDie(example, &output);
   return output;
diff --git a/http2/hpack/tools/hpack_example.h b/http2/hpack/tools/hpack_example.h
index 0371e17..e86c116 100644
--- a/http2/hpack/tools/hpack_example.h
+++ b/http2/hpack/tools/hpack_example.h
@@ -7,7 +7,7 @@
 
 #include <string>
 
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 // Parses HPACK examples in the format seen in the HPACK specification,
 // RFC 7541. For example:
@@ -24,7 +24,7 @@
 namespace http2 {
 namespace test {
 
-std::string HpackExampleToStringOrDie(Http2StringPiece example);
+std::string HpackExampleToStringOrDie(quiche::QuicheStringPiece example);
 
 }  // namespace test
 }  // namespace http2
diff --git a/http2/hpack/varint/hpack_varint_decoder_test.cc b/http2/hpack/varint/hpack_varint_decoder_test.cc
index 07cb51b..336349c 100644
--- a/http2/hpack/varint/hpack_varint_decoder_test.cc
+++ b/http2/hpack/varint/hpack_varint_decoder_test.cc
@@ -11,9 +11,9 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_arraysize.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string_utils.h"
 #include "net/third_party/quiche/src/http2/tools/random_decoder_test.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 using ::testing::AssertionFailure;
 using ::testing::AssertionSuccess;
@@ -31,7 +31,7 @@
         suffix_(Http2HexDecode(::testing::get<1>(GetParam()))),
         prefix_length_(0) {}
 
-  void DecodeExpectSuccess(Http2StringPiece data,
+  void DecodeExpectSuccess(quiche::QuicheStringPiece data,
                            uint32_t prefix_length,
                            uint64_t expected_value) {
     Validator validator = [expected_value, this](
@@ -52,7 +52,8 @@
     EXPECT_EQ(expected_value, decoder_.value());
   }
 
-  void DecodeExpectError(Http2StringPiece data, uint32_t prefix_length) {
+  void DecodeExpectError(quiche::QuicheStringPiece data,
+                         uint32_t prefix_length) {
     Validator validator = [](const DecodeBuffer& db,
                              DecodeStatus status) -> AssertionResult {
       VERIFY_EQ(DecodeStatus::kDecodeError, status);
@@ -63,7 +64,7 @@
   }
 
  private:
-  AssertionResult Decode(Http2StringPiece data,
+  AssertionResult Decode(quiche::QuicheStringPiece data,
                          uint32_t prefix_length,
                          const Validator validator) {
     prefix_length_ = prefix_length;
diff --git a/http2/hpack/varint/hpack_varint_round_trip_test.cc b/http2/hpack/varint/hpack_varint_round_trip_test.cc
index a5318fb..58fc2c3 100644
--- a/http2/hpack/varint/hpack_varint_round_trip_test.cc
+++ b/http2/hpack/varint/hpack_varint_round_trip_test.cc
@@ -16,9 +16,9 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "net/third_party/quiche/src/http2/hpack/tools/hpack_block_builder.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string_utils.h"
 #include "net/third_party/quiche/src/http2/tools/random_decoder_test.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 using ::testing::AssertionFailure;
 using ::testing::AssertionSuccess;
@@ -291,7 +291,7 @@
 }
 
 TEST_F(HpackVarintRoundTripTest, FromSpec1337) {
-  DecodeBuffer b(Http2StringPiece("\x1f\x9a\x0a"));
+  DecodeBuffer b(quiche::QuicheStringPiece("\x1f\x9a\x0a"));
   uint32_t prefix_length = 5;
   uint8_t p = b.DecodeUInt8();
   EXPECT_EQ(1u, b.Offset());
diff --git a/http2/http2_constants.cc b/http2/http2_constants.cc
index 38f8ab5..37df919 100644
--- a/http2/http2_constants.cc
+++ b/http2/http2_constants.cc
@@ -5,8 +5,8 @@
 #include "net/third_party/quiche/src/http2/http2_constants.h"
 
 #include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_string_utils.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 
@@ -46,7 +46,8 @@
   std::string s;
   // Closure to append flag name |v| to the std::string |s|,
   // and to clear |bit| from |flags|.
-  auto append_and_clear = [&s, &flags](Http2StringPiece v, uint8_t bit) {
+  auto append_and_clear = [&s, &flags](quiche::QuicheStringPiece v,
+                                       uint8_t bit) {
     if (!s.empty()) {
       s.push_back('|');
     }
diff --git a/http2/platform/api/http2_string_piece.h b/http2/platform/api/http2_string_piece.h
deleted file mode 100644
index 92fb3ef..0000000
--- a/http2/platform/api/http2_string_piece.h
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright (c) 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_HTTP2_PLATFORM_API_HTTP2_STRING_PIECE_H_
-#define QUICHE_HTTP2_PLATFORM_API_HTTP2_STRING_PIECE_H_
-
-#include "net/http2/platform/impl/http2_string_piece_impl.h"
-
-namespace http2 {
-
-using Http2StringPiece = Http2StringPieceImpl;
-
-}  // namespace http2
-
-#endif  // QUICHE_HTTP2_PLATFORM_API_HTTP2_STRING_PIECE_H_
diff --git a/http2/platform/api/http2_string_utils.h b/http2/platform/api/http2_string_utils.h
index 1db9d66..4a4e0b8 100644
--- a/http2/platform/api/http2_string_utils.h
+++ b/http2/platform/api/http2_string_utils.h
@@ -9,8 +9,8 @@
 #include <type_traits>
 #include <utility>
 
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
 #include "net/http2/platform/impl/http2_string_utils_impl.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 
@@ -33,15 +33,15 @@
   return Http2HexEncodeImpl(bytes, size);
 }
 
-inline std::string Http2HexDecode(Http2StringPiece data) {
+inline std::string Http2HexDecode(quiche::QuicheStringPiece data) {
   return Http2HexDecodeImpl(data);
 }
 
-inline std::string Http2HexDump(Http2StringPiece data) {
+inline std::string Http2HexDump(quiche::QuicheStringPiece data) {
   return Http2HexDumpImpl(data);
 }
 
-inline std::string Http2HexEscape(Http2StringPiece data) {
+inline std::string Http2HexEscape(quiche::QuicheStringPiece data) {
   return Http2HexEscapeImpl(data);
 }
 
diff --git a/http2/platform/api/http2_string_utils_test.cc b/http2/platform/api/http2_string_utils_test.cc
index 6ffc4b4..6f04c9c 100644
--- a/http2/platform/api/http2_string_utils_test.cc
+++ b/http2/platform/api/http2_string_utils_test.cc
@@ -7,7 +7,7 @@
 #include <cstdint>
 
 #include "testing/gtest/include/gtest/gtest.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 namespace test {
@@ -20,14 +20,14 @@
   // Single string-like argument.
   const char kFoo[] = "foo";
   const std::string string_foo(kFoo);
-  const Http2StringPiece stringpiece_foo(string_foo);
+  const quiche::QuicheStringPiece stringpiece_foo(string_foo);
   EXPECT_EQ("foo", Http2StrCat(kFoo));
   EXPECT_EQ("foo", Http2StrCat(string_foo));
   EXPECT_EQ("foo", Http2StrCat(stringpiece_foo));
 
   // Two string-like arguments.
   const char kBar[] = "bar";
-  const Http2StringPiece stringpiece_bar(kBar);
+  const quiche::QuicheStringPiece stringpiece_bar(kBar);
   const std::string string_bar(kBar);
   EXPECT_EQ("foobar", Http2StrCat(kFoo, kBar));
   EXPECT_EQ("foobar", Http2StrCat(kFoo, string_bar));
@@ -79,7 +79,7 @@
   // Single string-like argument.
   const char kFoo[] = "foo";
   const std::string string_foo(kFoo);
-  const Http2StringPiece stringpiece_foo(string_foo);
+  const quiche::QuicheStringPiece stringpiece_foo(string_foo);
   Http2StrAppend(&output, kFoo);
   EXPECT_EQ("foo", output);
   Http2StrAppend(&output, string_foo);
@@ -95,7 +95,7 @@
 
   // Two string-like arguments.
   const char kBar[] = "bar";
-  const Http2StringPiece stringpiece_bar(kBar);
+  const quiche::QuicheStringPiece stringpiece_bar(kBar);
   const std::string string_bar(kBar);
   Http2StrAppend(&output, kFoo, kBar);
   EXPECT_EQ("foobar", output);
diff --git a/http2/test_tools/frame_parts.cc b/http2/test_tools/frame_parts.cc
index d9dffa1..32d3a97 100644
--- a/http2/test_tools/frame_parts.cc
+++ b/http2/test_tools/frame_parts.cc
@@ -51,14 +51,15 @@
   HTTP2_VLOG(1) << "FrameParts, header: " << frame_header_;
 }
 
-FrameParts::FrameParts(const Http2FrameHeader& header, Http2StringPiece payload)
+FrameParts::FrameParts(const Http2FrameHeader& header,
+                       quiche::QuicheStringPiece payload)
     : FrameParts(header) {
   HTTP2_VLOG(1) << "FrameParts with payload.size() = " << payload.size();
   this->payload_.append(payload.data(), payload.size());
   opt_payload_length_ = payload.size();
 }
 FrameParts::FrameParts(const Http2FrameHeader& header,
-                       Http2StringPiece payload,
+                       quiche::QuicheStringPiece payload,
                        size_t total_pad_length)
     : FrameParts(header, payload) {
   HTTP2_VLOG(1) << "FrameParts with total_pad_length=" << total_pad_length;
@@ -117,8 +118,8 @@
   }
 }
 
-void FrameParts::SetAltSvcExpected(Http2StringPiece origin,
-                                   Http2StringPiece value) {
+void FrameParts::SetAltSvcExpected(quiche::QuicheStringPiece origin,
+                                   quiche::QuicheStringPiece value) {
   altsvc_origin_.append(origin.data(), origin.size());
   altsvc_value_.append(value.data(), value.size());
   opt_altsvc_origin_length_ = origin.size();
@@ -140,7 +141,7 @@
   HTTP2_VLOG(1) << "OnDataPayload: len=" << len
                 << "; frame_header_: " << frame_header_;
   ASSERT_TRUE(InFrameOfType(Http2FrameType::DATA)) << *this;
-  ASSERT_TRUE(AppendString(Http2StringPiece(data, len), &payload_,
+  ASSERT_TRUE(AppendString(quiche::QuicheStringPiece(data, len), &payload_,
                            &opt_payload_length_));
 }
 
@@ -172,7 +173,7 @@
   ASSERT_TRUE(got_start_callback_);
   ASSERT_FALSE(got_end_callback_);
   ASSERT_TRUE(FrameCanHaveHpackPayload(frame_header_)) << *this;
-  ASSERT_TRUE(AppendString(Http2StringPiece(data, len), &payload_,
+  ASSERT_TRUE(AppendString(quiche::QuicheStringPiece(data, len), &payload_,
                            &opt_payload_length_));
 }
 
@@ -216,8 +217,8 @@
   HTTP2_VLOG(1) << "OnPadding: skipped_length=" << skipped_length;
   ASSERT_TRUE(InPaddedFrame()) << *this;
   ASSERT_TRUE(opt_pad_length_);
-  ASSERT_TRUE(AppendString(Http2StringPiece(pad, skipped_length), &padding_,
-                           &opt_pad_length_));
+  ASSERT_TRUE(AppendString(quiche::QuicheStringPiece(pad, skipped_length),
+                           &padding_, &opt_pad_length_));
 }
 
 void FrameParts::OnRstStream(const Http2FrameHeader& header,
@@ -313,7 +314,7 @@
 void FrameParts::OnGoAwayOpaqueData(const char* data, size_t len) {
   HTTP2_VLOG(1) << "OnGoAwayOpaqueData: len=" << len;
   ASSERT_TRUE(InFrameOfType(Http2FrameType::GOAWAY)) << *this;
-  ASSERT_TRUE(AppendString(Http2StringPiece(data, len), &payload_,
+  ASSERT_TRUE(AppendString(quiche::QuicheStringPiece(data, len), &payload_,
                            &opt_payload_length_));
 }
 
@@ -348,14 +349,14 @@
 void FrameParts::OnAltSvcOriginData(const char* data, size_t len) {
   HTTP2_VLOG(1) << "OnAltSvcOriginData: len=" << len;
   ASSERT_TRUE(InFrameOfType(Http2FrameType::ALTSVC)) << *this;
-  ASSERT_TRUE(AppendString(Http2StringPiece(data, len), &altsvc_origin_,
-                           &opt_altsvc_origin_length_));
+  ASSERT_TRUE(AppendString(quiche::QuicheStringPiece(data, len),
+                           &altsvc_origin_, &opt_altsvc_origin_length_));
 }
 
 void FrameParts::OnAltSvcValueData(const char* data, size_t len) {
   HTTP2_VLOG(1) << "OnAltSvcValueData: len=" << len;
   ASSERT_TRUE(InFrameOfType(Http2FrameType::ALTSVC)) << *this;
-  ASSERT_TRUE(AppendString(Http2StringPiece(data, len), &altsvc_value_,
+  ASSERT_TRUE(AppendString(quiche::QuicheStringPiece(data, len), &altsvc_value_,
                            &opt_altsvc_value_length_));
 }
 
@@ -378,7 +379,7 @@
   ASSERT_FALSE(IsSupportedHttp2FrameType(frame_header_.type)) << *this;
   ASSERT_TRUE(got_start_callback_);
   ASSERT_FALSE(got_end_callback_);
-  ASSERT_TRUE(AppendString(Http2StringPiece(data, len), &payload_,
+  ASSERT_TRUE(AppendString(quiche::QuicheStringPiece(data, len), &payload_,
                            &opt_payload_length_));
 }
 
@@ -506,7 +507,7 @@
   return AssertionSuccess();
 }
 
-AssertionResult FrameParts::AppendString(Http2StringPiece source,
+AssertionResult FrameParts::AppendString(quiche::QuicheStringPiece source,
                                          std::string* target,
                                          Http2Optional<size_t>* opt_length) {
   target->append(source.data(), source.size());
diff --git a/http2/test_tools/frame_parts.h b/http2/test_tools/frame_parts.h
index 598a687..2d54143 100644
--- a/http2/test_tools/frame_parts.h
+++ b/http2/test_tools/frame_parts.h
@@ -22,7 +22,7 @@
 #include "net/third_party/quiche/src/http2/http2_structures.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_logging.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_optional.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 namespace test {
@@ -34,12 +34,12 @@
   explicit FrameParts(const Http2FrameHeader& header);
 
   // For use in tests where the expected frame has a variable size payload.
-  FrameParts(const Http2FrameHeader& header, Http2StringPiece payload);
+  FrameParts(const Http2FrameHeader& header, quiche::QuicheStringPiece payload);
 
   // For use in tests where the expected frame has a variable size payload
   // and may be padded.
   FrameParts(const Http2FrameHeader& header,
-             Http2StringPiece payload,
+             quiche::QuicheStringPiece payload,
              size_t total_pad_length);
 
   // Copy constructor.
@@ -58,7 +58,8 @@
   void SetTotalPadLength(size_t total_pad_length);
 
   // Set the origin and value expected in an ALTSVC frame.
-  void SetAltSvcExpected(Http2StringPiece origin, Http2StringPiece value);
+  void SetAltSvcExpected(quiche::QuicheStringPiece origin,
+                         quiche::QuicheStringPiece value);
 
   // Http2FrameDecoderListener methods:
   bool OnFrameHeader(const Http2FrameHeader& header) override;
@@ -207,7 +208,7 @@
   // Append source to target. If opt_length is not nullptr, then verifies that
   // the optional has a value (i.e. that the necessary On*Start method has been
   // called), and that target is not longer than opt_length->value().
-  ::testing::AssertionResult AppendString(Http2StringPiece source,
+  ::testing::AssertionResult AppendString(quiche::QuicheStringPiece source,
                                           std::string* target,
                                           Http2Optional<size_t>* opt_length);
 
diff --git a/http2/test_tools/http2_random.cc b/http2/test_tools/http2_random.cc
index 6b61a58..df20364 100644
--- a/http2/test_tools/http2_random.cc
+++ b/http2/test_tools/http2_random.cc
@@ -16,7 +16,7 @@
   HTTP2_LOG(INFO) << "Initialized test RNG with the following key: " << Key();
 }
 
-Http2Random::Http2Random(Http2StringPiece key) {
+Http2Random::Http2Random(quiche::QuicheStringPiece key) {
   std::string decoded_key = Http2HexDecode(key);
   CHECK_EQ(sizeof(key_), decoded_key.size());
   memcpy(key_, decoded_key.data(), sizeof(key_));
@@ -58,8 +58,9 @@
   return value.f - 1.0;
 }
 
-std::string Http2Random::RandStringWithAlphabet(int length,
-                                                Http2StringPiece alphabet) {
+std::string Http2Random::RandStringWithAlphabet(
+    int length,
+    quiche::QuicheStringPiece alphabet) {
   std::string result;
   result.resize(length);
   for (int i = 0; i < length; i++) {
diff --git a/http2/test_tools/http2_random.h b/http2/test_tools/http2_random.h
index 774212c..9f046a1 100644
--- a/http2/test_tools/http2_random.h
+++ b/http2/test_tools/http2_random.h
@@ -11,7 +11,7 @@
 #include <random>
 #include <string>
 
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 namespace test {
@@ -28,7 +28,7 @@
 
   // Reproducible random number generation: by using the same key, the same
   // sequence of results is obtained.
-  explicit Http2Random(Http2StringPiece key);
+  explicit Http2Random(quiche::QuicheStringPiece key);
   std::string Key() const;
 
   void FillRandom(void* buffer, size_t buffer_size);
@@ -67,7 +67,8 @@
 
   // Return a random string consisting of the characters from the specified
   // alphabet.
-  std::string RandStringWithAlphabet(int length, Http2StringPiece alphabet);
+  std::string RandStringWithAlphabet(int length,
+                                     quiche::QuicheStringPiece alphabet);
 
   // STL UniformRandomNumberGenerator implementation.
   using result_type = uint64_t;
diff --git a/http2/tools/http2_frame_builder.cc b/http2/tools/http2_frame_builder.cc
index 1dfcdeb..1f1af16 100644
--- a/http2/tools/http2_frame_builder.cc
+++ b/http2/tools/http2_frame_builder.cc
@@ -30,12 +30,12 @@
   Append(v);
 }
 
-void Http2FrameBuilder::Append(Http2StringPiece s) {
+void Http2FrameBuilder::Append(quiche::QuicheStringPiece s) {
   Http2StrAppend(&buffer_, s);
 }
 
 void Http2FrameBuilder::AppendBytes(const void* data, uint32_t num_bytes) {
-  Append(Http2StringPiece(static_cast<const char*>(data), num_bytes));
+  Append(quiche::QuicheStringPiece(static_cast<const char*>(data), num_bytes));
 }
 
 void Http2FrameBuilder::AppendZeroes(size_t num_zero_bytes) {
@@ -143,7 +143,7 @@
 
 // Methods for changing existing buffer contents.
 
-void Http2FrameBuilder::WriteAt(Http2StringPiece s, size_t offset) {
+void Http2FrameBuilder::WriteAt(quiche::QuicheStringPiece s, size_t offset) {
   ASSERT_LE(offset, buffer_.size());
   size_t len = offset + s.size();
   if (len > buffer_.size()) {
@@ -157,7 +157,8 @@
 void Http2FrameBuilder::WriteBytesAt(const void* data,
                                      uint32_t num_bytes,
                                      size_t offset) {
-  WriteAt(Http2StringPiece(static_cast<const char*>(data), num_bytes), offset);
+  WriteAt(quiche::QuicheStringPiece(static_cast<const char*>(data), num_bytes),
+          offset);
 }
 
 void Http2FrameBuilder::WriteUInt24At(uint32_t value, size_t offset) {
diff --git a/http2/tools/http2_frame_builder.h b/http2/tools/http2_frame_builder.h
index 70d5f44..724c2b2 100644
--- a/http2/tools/http2_frame_builder.h
+++ b/http2/tools/http2_frame_builder.h
@@ -20,7 +20,7 @@
 
 #include "net/third_party/quiche/src/http2/http2_constants.h"
 #include "net/third_party/quiche/src/http2/http2_structures.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 namespace test {
@@ -39,7 +39,7 @@
   // Methods for appending to the end of the buffer.
 
   // Append a sequence of bytes from various sources.
-  void Append(Http2StringPiece s);
+  void Append(quiche::QuicheStringPiece s);
   void AppendBytes(const void* data, uint32_t num_bytes);
 
   // Append an array of type T[N] to the string. Intended for tests with arrays
@@ -80,7 +80,7 @@
   // Methods for changing existing buffer contents (mostly focused on updating
   // the payload length).
 
-  void WriteAt(Http2StringPiece s, size_t offset);
+  void WriteAt(quiche::QuicheStringPiece s, size_t offset);
   void WriteBytesAt(const void* data, uint32_t num_bytes, size_t offset);
   void WriteUInt24At(uint32_t value, size_t offset);
 
diff --git a/http2/tools/random_decoder_test.h b/http2/tools/random_decoder_test.h
index ef31d01..40b1e44 100644
--- a/http2/tools/random_decoder_test.h
+++ b/http2/tools/random_decoder_test.h
@@ -21,9 +21,9 @@
 #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/http2/platform/api/http2_logging.h"
-#include "net/third_party/quiche/src/http2/platform/api/http2_string_piece.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_test_helpers.h"
 #include "net/third_party/quiche/src/http2/test_tools/http2_random.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace http2 {
 namespace test {
@@ -31,8 +31,9 @@
 // Some helpers.
 
 template <typename T, size_t N>
-Http2StringPiece ToStringPiece(T (&data)[N]) {
-  return Http2StringPiece(reinterpret_cast<const char*>(data), N * sizeof(T));
+quiche::QuicheStringPiece ToStringPiece(T (&data)[N]) {
+  return quiche::QuicheStringPiece(reinterpret_cast<const char*>(data),
+                                   N * sizeof(T));
 }
 
 // Overwrite the enum with some random value, probably not a valid value for
diff --git a/http2/tools/random_util.cc b/http2/tools/random_util.cc
index a7d95c4..a0af07a 100644
--- a/http2/tools/random_util.cc
+++ b/http2/tools/random_util.cc
@@ -12,7 +12,7 @@
 // Here "word" means something that starts with a lower-case letter, and has
 // zero or more additional characters that are numbers or lower-case letters.
 std::string GenerateHttp2HeaderName(size_t len, Http2Random* rng) {
-  Http2StringPiece alpha_lc = "abcdefghijklmnopqrstuvwxyz";
+  quiche::QuicheStringPiece alpha_lc = "abcdefghijklmnopqrstuvwxyz";
   // If the name is short, just make it one word.
   if (len < 8) {
     return rng->RandStringWithAlphabet(len, alpha_lc);
@@ -20,7 +20,8 @@
   // If the name is longer, ensure it starts with a word, and after that may
   // have any character in alphanumdash_lc. 4 is arbitrary, could be as low
   // as 1.
-  Http2StringPiece alphanumdash_lc = "abcdefghijklmnopqrstuvwxyz0123456789-";
+  quiche::QuicheStringPiece alphanumdash_lc =
+      "abcdefghijklmnopqrstuvwxyz0123456789-";
   return rng->RandStringWithAlphabet(4, alpha_lc) +
          rng->RandStringWithAlphabet(len - 4, alphanumdash_lc);
 }