diff --git a/common/platform/api/quiche_string_piece.h b/common/platform/api/quiche_string_piece.h
index 9def942..35d5021 100644
--- a/common/platform/api/quiche_string_piece.h
+++ b/common/platform/api/quiche_string_piece.h
@@ -9,7 +9,13 @@
 
 namespace quiche {
 
-using QuicheStringPiece = quiche::QuicheStringPieceImpl;
+using QuicheStringPiece = QuicheStringPieceImpl;
+
+using QuicheStringPieceHash = QuicheStringPieceHashImpl;
+
+inline size_t QuicheHashStringPair(QuicheStringPiece a, QuicheStringPiece b) {
+  return QuicheHashStringPairImpl(a, b);
+}
 
 }  // namespace quiche
 
diff --git a/quic/masque/masque_server_backend.cc b/quic/masque/masque_server_backend.cc
index 41ef780..a3c2b97 100644
--- a/quic/masque/masque_server_backend.cc
+++ b/quic/masque/masque_server_backend.cc
@@ -4,6 +4,7 @@
 
 #include "net/third_party/quiche/src/quic/masque/masque_server_backend.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 {
 
@@ -39,9 +40,9 @@
     // This request is missing required headers.
     return false;
   }
-  spdy::SpdyStringPiece path = path_pair->second;
-  spdy::SpdyStringPiece scheme = scheme_pair->second;
-  spdy::SpdyStringPiece method = method_pair->second;
+  quiche::QuicheStringPiece path = path_pair->second;
+  quiche::QuicheStringPiece scheme = scheme_pair->second;
+  quiche::QuicheStringPiece method = method_pair->second;
   if (scheme != "https" || method != "POST" || request_body.empty()) {
     // MASQUE requests MUST be a non-empty https POST.
     return false;
@@ -59,7 +60,7 @@
       // Cannot enforce missing authority.
       return false;
     }
-    spdy::SpdyStringPiece authority = authority_pair->second;
+    quiche::QuicheStringPiece authority = authority_pair->second;
     if (server_authority_ != authority) {
       // This request does not match server_authority.
       return false;
diff --git a/spdy/core/hpack/hpack_decoder_adapter.cc b/spdy/core/hpack/hpack_decoder_adapter.cc
index b3bce70..fd5a5be 100644
--- a/spdy/core/hpack/hpack_decoder_adapter.cc
+++ b/spdy/core/hpack/hpack_decoder_adapter.cc
@@ -171,7 +171,7 @@
 }
 
 void HpackDecoderAdapter::ListenerAdapter::OnHeaderErrorDetected(
-    SpdyStringPiece error_message) {
+    quiche::QuicheStringPiece error_message) {
   SPDY_VLOG(1) << error_message;
 }
 
diff --git a/spdy/core/hpack/hpack_decoder_adapter.h b/spdy/core/hpack/hpack_decoder_adapter.h
index cdea661..1d5c7b2 100644
--- a/spdy/core/hpack/hpack_decoder_adapter.h
+++ b/spdy/core/hpack/hpack_decoder_adapter.h
@@ -18,11 +18,11 @@
 #include "net/third_party/quiche/src/http2/hpack/decoder/hpack_decoder_tables.h"
 #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/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_header_table.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_header_block.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_headers_handler_interface.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 namespace spdy {
 namespace test {
@@ -108,7 +108,8 @@
     void OnHeader(const http2::HpackString& name,
                   const http2::HpackString& value) override;
     void OnHeaderListEnd() override;
-    void OnHeaderErrorDetected(SpdyStringPiece error_message) override;
+    void OnHeaderErrorDetected(
+        quiche::QuicheStringPiece error_message) override;
 
     // Override the HpackDecoderTablesDebugListener methods:
     int64_t OnEntryInserted(const http2::HpackStringPair& entry,
diff --git a/spdy/core/hpack/hpack_decoder_adapter_test.cc b/spdy/core/hpack/hpack_decoder_adapter_test.cc
index 88318fb..f1bfe0c 100644
--- a/spdy/core/hpack/hpack_decoder_adapter_test.cc
+++ b/spdy/core/hpack/hpack_decoder_adapter_test.cc
@@ -65,7 +65,8 @@
   explicit HpackDecoderAdapterPeer(HpackDecoderAdapter* decoder)
       : decoder_(decoder) {}
 
-  void HandleHeaderRepresentation(SpdyStringPiece name, SpdyStringPiece value) {
+  void HandleHeaderRepresentation(quiche::QuicheStringPiece name,
+                                  quiche::QuicheStringPiece value) {
     decoder_->listener_adapter_.OnHeader(HpackString(name), HpackString(value));
   }
 
@@ -132,7 +133,7 @@
     }
   }
 
-  bool HandleControlFrameHeadersData(SpdyStringPiece str) {
+  bool HandleControlFrameHeadersData(quiche::QuicheStringPiece str) {
     SPDY_VLOG(3) << "HandleControlFrameHeadersData:\n" << SpdyHexDump(str);
     bytes_passed_in_ += str.size();
     return decoder_.HandleControlFrameHeadersData(str.data(), str.size());
@@ -146,7 +147,8 @@
     return rc;
   }
 
-  bool DecodeHeaderBlock(SpdyStringPiece str, bool check_decoded_size = true) {
+  bool DecodeHeaderBlock(quiche::QuicheStringPiece str,
+                         bool check_decoded_size = true) {
     // Don't call this again if HandleControlFrameHeadersData failed previously.
     EXPECT_FALSE(decode_has_failed_);
     HandleControlFrameHeadersStart();
@@ -223,7 +225,8 @@
     return size;
   }
 
-  const SpdyHeaderBlock& DecodeBlockExpectingSuccess(SpdyStringPiece str) {
+  const SpdyHeaderBlock& DecodeBlockExpectingSuccess(
+      quiche::QuicheStringPiece str) {
     EXPECT_TRUE(DecodeHeaderBlock(str));
     return decoded_block();
   }
@@ -429,12 +432,13 @@
   // Resulting decoded headers are in the same order as the inputs.
   EXPECT_THAT(
       decoded_block(),
-      ElementsAre(Pair("cookie", " part 1; part 2 ; part3;  fin!"),
-                  Pair("passed-through", SpdyStringPiece("foo\0baz", 7)),
-                  Pair("joined", "not joined"),
-                  Pair("joineD", SpdyStringPiece("value 1\0value 2", 15)),
-                  Pair("empty", ""),
-                  Pair("empty-joined", SpdyStringPiece("\0foo\0\0", 6))));
+      ElementsAre(
+          Pair("cookie", " part 1; part 2 ; part3;  fin!"),
+          Pair("passed-through", quiche::QuicheStringPiece("foo\0baz", 7)),
+          Pair("joined", "not joined"),
+          Pair("joineD", quiche::QuicheStringPiece("value 1\0value 2", 15)),
+          Pair("empty", ""),
+          Pair("empty-joined", quiche::QuicheStringPiece("\0foo\0\0", 6))));
 }
 
 // Decoding indexed static table field should work.
@@ -499,7 +503,7 @@
     output_stream.AppendUint32(126);
 
     output_stream.TakeString(&input);
-    EXPECT_TRUE(DecodeHeaderBlock(SpdyStringPiece(input)));
+    EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
     EXPECT_EQ(126u, decoder_peer_.header_table_size_limit());
   }
   {
@@ -509,7 +513,7 @@
     output_stream.AppendUint32(kDefaultHeaderTableSizeSetting);
 
     output_stream.TakeString(&input);
-    EXPECT_TRUE(DecodeHeaderBlock(SpdyStringPiece(input)));
+    EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
     EXPECT_EQ(kDefaultHeaderTableSizeSetting,
               decoder_peer_.header_table_size_limit());
   }
@@ -520,7 +524,7 @@
     output_stream.AppendUint32(kDefaultHeaderTableSizeSetting + 1);
 
     output_stream.TakeString(&input);
-    EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece(input)));
+    EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
     EXPECT_EQ(kDefaultHeaderTableSizeSetting,
               decoder_peer_.header_table_size_limit());
   }
@@ -538,7 +542,7 @@
     output_stream.AppendUint32(122);
 
     output_stream.TakeString(&input);
-    EXPECT_TRUE(DecodeHeaderBlock(SpdyStringPiece(input)));
+    EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
     EXPECT_EQ(122u, decoder_peer_.header_table_size_limit());
   }
 }
@@ -558,7 +562,7 @@
 
     output_stream.TakeString(&input);
 
-    EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece(input)));
+    EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
     EXPECT_EQ(10u, decoder_peer_.header_table_size_limit());
   }
 }
@@ -577,7 +581,7 @@
 
     output_stream.TakeString(&input);
 
-    EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece(input)));
+    EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
     EXPECT_EQ(kDefaultHeaderTableSizeSetting,
               decoder_peer_.header_table_size_limit());
   }
@@ -600,7 +604,7 @@
 
     output_stream.TakeString(&input);
 
-    EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece(input)));
+    EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece(input)));
     EXPECT_EQ(60u, decoder_peer_.header_table_size_limit());
   }
 }
@@ -612,7 +616,7 @@
   // name.
   const char input[] = "\x04\x0c/sample/path\x00\x06:path2\x0e/sample/path/2";
   const SpdyHeaderBlock& header_set = DecodeBlockExpectingSuccess(
-      SpdyStringPiece(input, QUICHE_ARRAYSIZE(input) - 1));
+      quiche::QuicheStringPiece(input, QUICHE_ARRAYSIZE(input) - 1));
 
   SpdyHeaderBlock expected_header_set;
   expected_header_set[":path"] = "/sample/path";
@@ -625,7 +629,7 @@
 TEST_P(HpackDecoderAdapterTest, LiteralHeaderIncrementalIndexing) {
   const char input[] = "\x44\x0c/sample/path\x40\x06:path2\x0e/sample/path/2";
   const SpdyHeaderBlock& header_set = DecodeBlockExpectingSuccess(
-      SpdyStringPiece(input, QUICHE_ARRAYSIZE(input) - 1));
+      quiche::QuicheStringPiece(input, QUICHE_ARRAYSIZE(input) - 1));
 
   SpdyHeaderBlock expected_header_set;
   expected_header_set[":path"] = "/sample/path";
@@ -638,23 +642,23 @@
   EXPECT_TRUE(EncodeAndDecodeDynamicTableSizeUpdates(0, 0));
 
   // Name is the last static index. Works.
-  EXPECT_TRUE(DecodeHeaderBlock(SpdyStringPiece("\x7d\x03ooo")));
+  EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x7d\x03ooo")));
   // Name is one beyond the last static index. Fails.
-  EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece("\x7e\x03ooo")));
+  EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x7e\x03ooo")));
 }
 
 TEST_P(HpackDecoderAdapterTest, LiteralHeaderNoIndexingInvalidNameIndex) {
   // Name is the last static index. Works.
-  EXPECT_TRUE(DecodeHeaderBlock(SpdyStringPiece("\x0f\x2e\x03ooo")));
+  EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x0f\x2e\x03ooo")));
   // Name is one beyond the last static index. Fails.
-  EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece("\x0f\x2f\x03ooo")));
+  EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x0f\x2f\x03ooo")));
 }
 
 TEST_P(HpackDecoderAdapterTest, LiteralHeaderNeverIndexedInvalidNameIndex) {
   // Name is the last static index. Works.
-  EXPECT_TRUE(DecodeHeaderBlock(SpdyStringPiece("\x1f\x2e\x03ooo")));
+  EXPECT_TRUE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x1f\x2e\x03ooo")));
   // Name is one beyond the last static index. Fails.
-  EXPECT_FALSE(DecodeHeaderBlock(SpdyStringPiece("\x1f\x2f\x03ooo")));
+  EXPECT_FALSE(DecodeHeaderBlock(quiche::QuicheStringPiece("\x1f\x2f\x03ooo")));
 }
 
 TEST_P(HpackDecoderAdapterTest, TruncatedIndex) {
@@ -1051,10 +1055,10 @@
   hbb.AppendDynamicTableSizeUpdate(0);
   hbb.AppendDynamicTableSizeUpdate(63);
 
-  const SpdyStringPiece name("some-name");
-  const SpdyStringPiece value1("some-value");
-  const SpdyStringPiece value2("another-value");
-  const SpdyStringPiece value3("yet-another-value");
+  const quiche::QuicheStringPiece name("some-name");
+  const quiche::QuicheStringPiece value1("some-value");
+  const quiche::QuicheStringPiece value2("another-value");
+  const quiche::QuicheStringPiece value3("yet-another-value");
 
   // Add an entry that will become the first in the dynamic table, entry 62.
   hbb.AppendLiteralNameAndValue(HpackEntryType::kIndexedLiteralHeader, false,
diff --git a/spdy/core/hpack/hpack_encoder.cc b/spdy/core/hpack/hpack_encoder.cc
index 368754e..3835047 100644
--- a/spdy/core/hpack/hpack_encoder.cc
+++ b/spdy/core/hpack/hpack_encoder.cc
@@ -56,10 +56,12 @@
 namespace {
 
 // The default header listener.
-void NoOpListener(SpdyStringPiece /*name*/, SpdyStringPiece /*value*/) {}
+void NoOpListener(quiche::QuicheStringPiece /*name*/,
+                  quiche::QuicheStringPiece /*value*/) {}
 
 // The default HPACK indexing policy.
-bool DefaultPolicy(SpdyStringPiece name, SpdyStringPiece /* value */) {
+bool DefaultPolicy(quiche::QuicheStringPiece name,
+                   quiche::QuicheStringPiece /* value */) {
   if (name.empty()) {
     return false;
   }
@@ -188,7 +190,7 @@
   EmitString(representation.second);
 }
 
-void HpackEncoder::EmitString(SpdyStringPiece str) {
+void HpackEncoder::EmitString(quiche::QuicheStringPiece str) {
   size_t encoded_size =
       enable_compression_ ? huffman_table_.EncodedSize(str) : str.size();
   if (encoded_size < str.size()) {
@@ -229,19 +231,21 @@
   // See Section 8.1.2.5. "Compressing the Cookie Header Field" in the HTTP/2
   // specification at https://tools.ietf.org/html/draft-ietf-httpbis-http2-14.
   // Cookie values are split into individually-encoded HPACK representations.
-  SpdyStringPiece cookie_value = cookie.second;
+  quiche::QuicheStringPiece cookie_value = cookie.second;
   // Consume leading and trailing whitespace if present.
-  SpdyStringPiece::size_type first = cookie_value.find_first_not_of(" \t");
-  SpdyStringPiece::size_type last = cookie_value.find_last_not_of(" \t");
-  if (first == SpdyStringPiece::npos) {
-    cookie_value = SpdyStringPiece();
+  quiche::QuicheStringPiece::size_type first =
+      cookie_value.find_first_not_of(" \t");
+  quiche::QuicheStringPiece::size_type last =
+      cookie_value.find_last_not_of(" \t");
+  if (first == quiche::QuicheStringPiece::npos) {
+    cookie_value = quiche::QuicheStringPiece();
   } else {
     cookie_value = cookie_value.substr(first, (last - first) + 1);
   }
   for (size_t pos = 0;;) {
     size_t end = cookie_value.find(";", pos);
 
-    if (end == SpdyStringPiece::npos) {
+    if (end == quiche::QuicheStringPiece::npos) {
       out->push_back(std::make_pair(cookie.first, cookie_value.substr(pos)));
       break;
     }
@@ -261,12 +265,12 @@
                                            Representations* out) {
   size_t pos = 0;
   size_t end = 0;
-  while (end != SpdyStringPiece::npos) {
+  while (end != quiche::QuicheStringPiece::npos) {
     end = header_field.second.find('\0', pos);
     out->push_back(std::make_pair(
         header_field.first,
         header_field.second.substr(
-            pos, end == SpdyStringPiece::npos ? end : end - pos)));
+            pos, end == quiche::QuicheStringPiece::npos ? end : end - pos)));
     pos = end + 1;
   }
 }
diff --git a/spdy/core/hpack/hpack_encoder.h b/spdy/core/hpack/hpack_encoder.h
index 03c9d92..115908b 100644
--- a/spdy/core/hpack/hpack_encoder.h
+++ b/spdy/core/hpack/hpack_encoder.h
@@ -14,11 +14,11 @@
 #include <utility>
 #include <vector>
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_header_table.h"
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_output_stream.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 // An HpackEncoder encodes header sets as outlined in
 // http://tools.ietf.org/html/rfc7541.
@@ -33,16 +33,19 @@
 
 class SPDY_EXPORT_PRIVATE HpackEncoder {
  public:
-  using Representation = std::pair<SpdyStringPiece, SpdyStringPiece>;
+  using Representation =
+      std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>;
   using Representations = std::vector<Representation>;
 
   // Callers may provide a HeaderListener to be informed of header name-value
   // pairs processed by this encoder.
-  using HeaderListener = std::function<void(SpdyStringPiece, SpdyStringPiece)>;
+  using HeaderListener =
+      std::function<void(quiche::QuicheStringPiece, quiche::QuicheStringPiece)>;
 
   // An indexing policy should return true if the provided header name-value
   // pair should be inserted into the HPACK dynamic table.
-  using IndexingPolicy = std::function<bool(SpdyStringPiece, SpdyStringPiece)>;
+  using IndexingPolicy =
+      std::function<bool(quiche::QuicheStringPiece, quiche::QuicheStringPiece)>;
 
   // |table| is an initialized HPACK Huffman table, having an
   // externally-managed lifetime which spans beyond HpackEncoder.
@@ -123,7 +126,7 @@
   void EmitLiteral(const Representation& representation);
 
   // Emits a Huffman or identity string (whichever is smaller).
-  void EmitString(SpdyStringPiece str);
+  void EmitString(quiche::QuicheStringPiece str);
 
   // Emits the current dynamic table size if the table size was recently
   // updated and we have not yet emitted it (Section 6.3).
diff --git a/spdy/core/hpack/hpack_encoder_test.cc b/spdy/core/hpack/hpack_encoder_test.cc
index b905214..a96ff69 100644
--- a/spdy/core/hpack/hpack_encoder_test.cc
+++ b/spdy/core/hpack/hpack_encoder_test.cc
@@ -41,12 +41,12 @@
   const HpackHuffmanTable& huffman_table() const {
     return encoder_->huffman_table_;
   }
-  void EmitString(SpdyStringPiece str) { encoder_->EmitString(str); }
+  void EmitString(quiche::QuicheStringPiece str) { encoder_->EmitString(str); }
   void TakeString(std::string* out) {
     encoder_->output_stream_.TakeString(out);
   }
-  static void CookieToCrumbs(SpdyStringPiece cookie,
-                             std::vector<SpdyStringPiece>* out) {
+  static void CookieToCrumbs(quiche::QuicheStringPiece cookie,
+                             std::vector<quiche::QuicheStringPiece>* out) {
     Representations tmp;
     HpackEncoder::CookieToCrumbs(std::make_pair("", cookie), &tmp);
 
@@ -55,8 +55,9 @@
       out->push_back(tmp[i].second);
     }
   }
-  static void DecomposeRepresentation(SpdyStringPiece value,
-                                      std::vector<SpdyStringPiece>* out) {
+  static void DecomposeRepresentation(
+      quiche::QuicheStringPiece value,
+      std::vector<quiche::QuicheStringPiece>* out) {
     Representations tmp;
     HpackEncoder::DecomposeRepresentation(std::make_pair("foobar", value),
                                           &tmp);
@@ -148,11 +149,12 @@
     peer_.table()->SetMaxSize(peer_.table()->size());
   }
 
-  void SaveHeaders(SpdyStringPiece name, SpdyStringPiece value) {
-    SpdyStringPiece n(headers_storage_.Memdup(name.data(), name.size()),
-                      name.size());
-    SpdyStringPiece v(headers_storage_.Memdup(value.data(), value.size()),
-                      value.size());
+  void SaveHeaders(quiche::QuicheStringPiece name,
+                   quiche::QuicheStringPiece value) {
+    quiche::QuicheStringPiece n(
+        headers_storage_.Memdup(name.data(), name.size()), name.size());
+    quiche::QuicheStringPiece v(
+        headers_storage_.Memdup(value.data(), value.size()), value.size());
     headers_observed_.push_back(std::make_pair(n, v));
   }
 
@@ -161,24 +163,26 @@
     expected_.AppendUint32(index);
   }
   void ExpectIndexedLiteral(const HpackEntry* key_entry,
-                            SpdyStringPiece value) {
+                            quiche::QuicheStringPiece value) {
     expected_.AppendPrefix(kLiteralIncrementalIndexOpcode);
     expected_.AppendUint32(IndexOf(key_entry));
     ExpectString(&expected_, value);
   }
-  void ExpectIndexedLiteral(SpdyStringPiece name, SpdyStringPiece value) {
+  void ExpectIndexedLiteral(quiche::QuicheStringPiece name,
+                            quiche::QuicheStringPiece value) {
     expected_.AppendPrefix(kLiteralIncrementalIndexOpcode);
     expected_.AppendUint32(0);
     ExpectString(&expected_, name);
     ExpectString(&expected_, value);
   }
-  void ExpectNonIndexedLiteral(SpdyStringPiece name, SpdyStringPiece value) {
+  void ExpectNonIndexedLiteral(quiche::QuicheStringPiece name,
+                               quiche::QuicheStringPiece value) {
     expected_.AppendPrefix(kLiteralNoIndexOpcode);
     expected_.AppendUint32(0);
     ExpectString(&expected_, name);
     ExpectString(&expected_, value);
   }
-  void ExpectString(HpackOutputStream* stream, SpdyStringPiece str) {
+  void ExpectString(HpackOutputStream* stream, quiche::QuicheStringPiece str) {
     const HpackHuffmanTable& huffman_table = peer_.huffman_table();
     size_t encoded_size = peer_.compression_enabled()
                               ? huffman_table.EncodedSize(str)
@@ -244,7 +248,8 @@
   const HpackEntry* cookie_c_;
 
   SpdySimpleArena headers_storage_;
-  std::vector<std::pair<SpdyStringPiece, SpdyStringPiece>> headers_observed_;
+  std::vector<std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>>
+      headers_observed_;
 
   HpackOutputStream expected_;
   EncodeStrategy strategy_ = kDefault;
@@ -252,15 +257,16 @@
 
 TEST_F(HpackEncoderTestBase, EncodeRepresentations) {
   encoder_.SetHeaderListener(
-      [this](SpdyStringPiece name, SpdyStringPiece value) {
+      [this](quiche::QuicheStringPiece name, quiche::QuicheStringPiece value) {
         this->SaveHeaders(name, value);
       });
-  const std::vector<std::pair<SpdyStringPiece, SpdyStringPiece>> header_list = {
-      {"cookie", "val1; val2;val3"},
-      {":path", "/home"},
-      {"accept", "text/html, text/plain,application/xml"},
-      {"cookie", "val4"},
-      {"withnul", SpdyStringPiece("one\0two", 7)}};
+  const std::vector<
+      std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>>
+      header_list = {{"cookie", "val1; val2;val3"},
+                     {":path", "/home"},
+                     {"accept", "text/html, text/plain,application/xml"},
+                     {"cookie", "val4"},
+                     {"withnul", quiche::QuicheStringPiece("one\0two", 7)}};
   ExpectNonIndexedLiteral(":path", "/home");
   ExpectIndexedLiteral(peer_.table()->GetByName("cookie"), "val1");
   ExpectIndexedLiteral(peer_.table()->GetByName("cookie"), "val2");
@@ -268,7 +274,7 @@
   ExpectIndexedLiteral(peer_.table()->GetByName("accept"),
                        "text/html, text/plain,application/xml");
   ExpectIndexedLiteral(peer_.table()->GetByName("cookie"), "val4");
-  ExpectIndexedLiteral("withnul", SpdyStringPiece("one\0two", 7));
+  ExpectIndexedLiteral("withnul", quiche::QuicheStringPiece("one\0two", 7));
 
   CompareWithExpectedEncoding(header_list);
   EXPECT_THAT(
@@ -277,7 +283,7 @@
                   Pair("cookie", "val2"), Pair("cookie", "val3"),
                   Pair("accept", "text/html, text/plain,application/xml"),
                   Pair("cookie", "val4"),
-                  Pair("withnul", SpdyStringPiece("one\0two", 7))));
+                  Pair("withnul", quiche::QuicheStringPiece("one\0two", 7))));
 }
 
 class HpackEncoderTest : public HpackEncoderTestBase,
@@ -297,7 +303,7 @@
 
 TEST_P(HpackEncoderTest, SingleDynamicIndex) {
   encoder_.SetHeaderListener(
-      [this](SpdyStringPiece name, SpdyStringPiece value) {
+      [this](quiche::QuicheStringPiece name, quiche::QuicheStringPiece value) {
         this->SaveHeaders(name, value);
       });
 
@@ -418,7 +424,7 @@
 
 TEST_P(HpackEncoderTest, EncodingWithoutCompression) {
   encoder_.SetHeaderListener(
-      [this](SpdyStringPiece name, SpdyStringPiece value) {
+      [this](quiche::QuicheStringPiece name, quiche::QuicheStringPiece value) {
         this->SaveHeaders(name, value);
       });
   encoder_.DisableCompression();
@@ -446,10 +452,11 @@
   if (strategy_ == kRepresentations) {
     EXPECT_THAT(
         headers_observed_,
-        ElementsAre(Pair(":path", "/index.html"), Pair("cookie", "foo=bar"),
-                    Pair("cookie", "baz=bing"),
-                    Pair("hello", SpdyStringPiece("goodbye\0aloha", 13)),
-                    Pair("multivalue", "value1, value2")));
+        ElementsAre(
+            Pair(":path", "/index.html"), Pair("cookie", "foo=bar"),
+            Pair("cookie", "baz=bing"),
+            Pair("hello", quiche::QuicheStringPiece("goodbye\0aloha", 13)),
+            Pair("multivalue", "value1, value2")));
   } else {
     EXPECT_THAT(
         headers_observed_,
@@ -462,7 +469,7 @@
 
 TEST_P(HpackEncoderTest, MultipleEncodingPasses) {
   encoder_.SetHeaderListener(
-      [this](SpdyStringPiece name, SpdyStringPiece value) {
+      [this](quiche::QuicheStringPiece name, quiche::QuicheStringPiece value) {
         this->SaveHeaders(name, value);
       });
 
@@ -558,7 +565,7 @@
 
 TEST_P(HpackEncoderTest, CookieToCrumbs) {
   test::HpackEncoderPeer peer(nullptr);
-  std::vector<SpdyStringPiece> out;
+  std::vector<quiche::QuicheStringPiece> out;
 
   // Leading and trailing whitespace is consumed. A space after ';' is consumed.
   // All other spaces remain. ';' at beginning and end of string produce empty
@@ -592,7 +599,7 @@
 
 TEST_P(HpackEncoderTest, DecomposeRepresentation) {
   test::HpackEncoderPeer peer(nullptr);
-  std::vector<SpdyStringPiece> out;
+  std::vector<quiche::QuicheStringPiece> out;
 
   peer.DecomposeRepresentation("", &out);
   EXPECT_THAT(out, ElementsAre(""));
@@ -600,16 +607,19 @@
   peer.DecomposeRepresentation("foobar", &out);
   EXPECT_THAT(out, ElementsAre("foobar"));
 
-  peer.DecomposeRepresentation(SpdyStringPiece("foo\0bar", 7), &out);
+  peer.DecomposeRepresentation(quiche::QuicheStringPiece("foo\0bar", 7), &out);
   EXPECT_THAT(out, ElementsAre("foo", "bar"));
 
-  peer.DecomposeRepresentation(SpdyStringPiece("\0foo\0bar", 8), &out);
+  peer.DecomposeRepresentation(quiche::QuicheStringPiece("\0foo\0bar", 8),
+                               &out);
   EXPECT_THAT(out, ElementsAre("", "foo", "bar"));
 
-  peer.DecomposeRepresentation(SpdyStringPiece("foo\0bar\0", 8), &out);
+  peer.DecomposeRepresentation(quiche::QuicheStringPiece("foo\0bar\0", 8),
+                               &out);
   EXPECT_THAT(out, ElementsAre("foo", "bar", ""));
 
-  peer.DecomposeRepresentation(SpdyStringPiece("\0foo\0bar\0", 9), &out);
+  peer.DecomposeRepresentation(quiche::QuicheStringPiece("\0foo\0bar\0", 9),
+                               &out);
   EXPECT_THAT(out, ElementsAre("", "foo", "bar", ""));
 }
 
diff --git a/spdy/core/hpack/hpack_entry.cc b/spdy/core/hpack/hpack_entry.cc
index 0965739..c96e35c 100644
--- a/spdy/core/hpack/hpack_entry.cc
+++ b/spdy/core/hpack/hpack_entry.cc
@@ -12,8 +12,8 @@
 
 const size_t HpackEntry::kSizeOverhead = 32;
 
-HpackEntry::HpackEntry(SpdyStringPiece name,
-                       SpdyStringPiece value,
+HpackEntry::HpackEntry(quiche::QuicheStringPiece name,
+                       quiche::QuicheStringPiece value,
                        bool is_static,
                        size_t insertion_index)
     : name_(name.data(), name.size()),
@@ -24,7 +24,8 @@
       type_(is_static ? STATIC : DYNAMIC),
       time_added_(0) {}
 
-HpackEntry::HpackEntry(SpdyStringPiece name, SpdyStringPiece value)
+HpackEntry::HpackEntry(quiche::QuicheStringPiece name,
+                       quiche::QuicheStringPiece value)
     : name_ref_(name),
       value_ref_(value),
       insertion_index_(0),
@@ -43,8 +44,8 @@
   } else {
     name_ = other.name_;
     value_ = other.value_;
-    name_ref_ = SpdyStringPiece(name_.data(), name_.size());
-    value_ref_ = SpdyStringPiece(value_.data(), value_.size());
+    name_ref_ = quiche::QuicheStringPiece(name_.data(), name_.size());
+    value_ref_ = quiche::QuicheStringPiece(value_.data(), value_.size());
   }
 }
 
@@ -60,15 +61,16 @@
   }
   name_ = other.name_;
   value_ = other.value_;
-  name_ref_ = SpdyStringPiece(name_.data(), name_.size());
-  value_ref_ = SpdyStringPiece(value_.data(), value_.size());
+  name_ref_ = quiche::QuicheStringPiece(name_.data(), name_.size());
+  value_ref_ = quiche::QuicheStringPiece(value_.data(), value_.size());
   return *this;
 }
 
 HpackEntry::~HpackEntry() = default;
 
 // static
-size_t HpackEntry::Size(SpdyStringPiece name, SpdyStringPiece value) {
+size_t HpackEntry::Size(quiche::QuicheStringPiece name,
+                        quiche::QuicheStringPiece value) {
   return name.size() + value.size() + kSizeOverhead;
 }
 size_t HpackEntry::Size() const {
diff --git a/spdy/core/hpack/hpack_entry.h b/spdy/core/hpack/hpack_entry.h
index 50ac3a7..d36bce4 100644
--- a/spdy/core/hpack/hpack_entry.h
+++ b/spdy/core/hpack/hpack_entry.h
@@ -9,8 +9,8 @@
 #include <cstdint>
 #include <string>
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 // All section references below are to
 // http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-08
@@ -34,15 +34,15 @@
   // The combination of |is_static| and |insertion_index| allows an
   // HpackEntryTable to determine the index of an HpackEntry in O(1) time.
   // Copies |name| and |value|.
-  HpackEntry(SpdyStringPiece name,
-             SpdyStringPiece value,
+  HpackEntry(quiche::QuicheStringPiece name,
+             quiche::QuicheStringPiece value,
              bool is_static,
              size_t insertion_index);
 
   // Create a 'lookup' entry (only) suitable for querying a HpackEntrySet. The
   // instance InsertionIndex() always returns 0 and IsLookup() returns true.
   // The memory backing |name| and |value| must outlive this object.
-  HpackEntry(SpdyStringPiece name, SpdyStringPiece value);
+  HpackEntry(quiche::QuicheStringPiece name, quiche::QuicheStringPiece value);
 
   HpackEntry(const HpackEntry& other);
   HpackEntry& operator=(const HpackEntry& other);
@@ -53,8 +53,8 @@
 
   ~HpackEntry();
 
-  SpdyStringPiece name() const { return name_ref_; }
-  SpdyStringPiece value() const { return value_ref_; }
+  quiche::QuicheStringPiece name() const { return name_ref_; }
+  quiche::QuicheStringPiece value() const { return value_ref_; }
 
   // Returns whether this entry is a member of the static (as opposed to
   // dynamic) table.
@@ -67,7 +67,8 @@
   size_t InsertionIndex() const { return insertion_index_; }
 
   // Returns the size of an entry as defined in 5.1.
-  static size_t Size(SpdyStringPiece name, SpdyStringPiece value);
+  static size_t Size(quiche::QuicheStringPiece name,
+                     quiche::QuicheStringPiece value);
   size_t Size() const;
 
   std::string GetDebugString() const;
@@ -91,8 +92,8 @@
 
   // These members are always valid. For DYNAMIC and STATIC entries, they
   // always point to |name_| and |value_|.
-  SpdyStringPiece name_ref_;
-  SpdyStringPiece value_ref_;
+  quiche::QuicheStringPiece name_ref_;
+  quiche::QuicheStringPiece value_ref_;
 
   // The entry's index in the total set of entries ever inserted into the header
   // table.
diff --git a/spdy/core/hpack/hpack_header_table.cc b/spdy/core/hpack/hpack_header_table.cc
index 17f91cd..67a0a5f 100644
--- a/spdy/core/hpack/hpack_header_table.cc
+++ b/spdy/core/hpack/hpack_header_table.cc
@@ -16,7 +16,7 @@
 
 size_t HpackHeaderTable::EntryHasher::operator()(
     const HpackEntry* entry) const {
-  return SpdyHashStringPair(entry->name(), entry->value());
+  return quiche::QuicheHashStringPair(entry->name(), entry->value());
 }
 
 bool HpackHeaderTable::EntriesEq::operator()(const HpackEntry* lhs,
@@ -60,7 +60,7 @@
   return nullptr;
 }
 
-const HpackEntry* HpackHeaderTable::GetByName(SpdyStringPiece name) {
+const HpackEntry* HpackHeaderTable::GetByName(quiche::QuicheStringPiece name) {
   {
     auto it = static_name_index_.find(name);
     if (it != static_name_index_.end()) {
@@ -80,8 +80,9 @@
   return nullptr;
 }
 
-const HpackEntry* HpackHeaderTable::GetByNameAndValue(SpdyStringPiece name,
-                                                      SpdyStringPiece value) {
+const HpackEntry* HpackHeaderTable::GetByNameAndValue(
+    quiche::QuicheStringPiece name,
+    quiche::QuicheStringPiece value) {
   HpackEntry query(name, value);
   {
     auto it = static_index_.find(&query);
@@ -127,8 +128,8 @@
   SetMaxSize(settings_size_bound_);
 }
 
-void HpackHeaderTable::EvictionSet(SpdyStringPiece name,
-                                   SpdyStringPiece value,
+void HpackHeaderTable::EvictionSet(quiche::QuicheStringPiece name,
+                                   quiche::QuicheStringPiece value,
                                    EntryTable::iterator* begin_out,
                                    EntryTable::iterator* end_out) {
   size_t eviction_count = EvictionCountForEntry(name, value);
@@ -136,8 +137,9 @@
   *end_out = dynamic_entries_.end();
 }
 
-size_t HpackHeaderTable::EvictionCountForEntry(SpdyStringPiece name,
-                                               SpdyStringPiece value) const {
+size_t HpackHeaderTable::EvictionCountForEntry(
+    quiche::QuicheStringPiece name,
+    quiche::QuicheStringPiece value) const {
   size_t available_size = max_size_ - size_;
   size_t entry_size = HpackEntry::Size(name, value);
 
@@ -183,8 +185,9 @@
   }
 }
 
-const HpackEntry* HpackHeaderTable::TryAddEntry(SpdyStringPiece name,
-                                                SpdyStringPiece value) {
+const HpackEntry* HpackHeaderTable::TryAddEntry(
+    quiche::QuicheStringPiece name,
+    quiche::QuicheStringPiece value) {
   Evict(EvictionCountForEntry(name, value));
 
   size_t entry_size = HpackEntry::Size(name, value);
diff --git a/spdy/core/hpack/hpack_header_table.h b/spdy/core/hpack/hpack_header_table.h
index 7ff49f3..3f532ac 100644
--- a/spdy/core/hpack/hpack_header_table.h
+++ b/spdy/core/hpack/hpack_header_table.h
@@ -10,11 +10,11 @@
 #include <deque>
 #include <memory>
 
+#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/platform/api/spdy_containers.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_macros.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 // All section references below are to http://tools.ietf.org/html/rfc7541.
 
@@ -67,8 +67,9 @@
     bool operator()(const HpackEntry* lhs, const HpackEntry* rhs) const;
   };
   using UnorderedEntrySet = SpdyHashSet<HpackEntry*, EntryHasher, EntriesEq>;
-  using NameToEntryMap =
-      SpdyHashMap<SpdyStringPiece, const HpackEntry*, SpdyStringPieceHash>;
+  using NameToEntryMap = SpdyHashMap<quiche::QuicheStringPiece,
+                                     const HpackEntry*,
+                                     quiche::QuicheStringPieceHash>;
 
   HpackHeaderTable();
   HpackHeaderTable(const HpackHeaderTable&) = delete;
@@ -88,11 +89,11 @@
   const HpackEntry* GetByIndex(size_t index);
 
   // Returns the lowest-value entry having |name|, or NULL.
-  const HpackEntry* GetByName(SpdyStringPiece name);
+  const HpackEntry* GetByName(quiche::QuicheStringPiece name);
 
   // Returns the lowest-index matching entry, or NULL.
-  const HpackEntry* GetByNameAndValue(SpdyStringPiece name,
-                                      SpdyStringPiece value);
+  const HpackEntry* GetByNameAndValue(quiche::QuicheStringPiece name,
+                                      quiche::QuicheStringPiece value);
 
   // Returns the index of an entry within this header table.
   size_t IndexOf(const HpackEntry* entry) const;
@@ -108,8 +109,8 @@
   // Determine the set of entries which would be evicted by the insertion
   // of |name| & |value| into the table, as per section 4.4. No eviction
   // actually occurs. The set is returned via range [begin_out, end_out).
-  void EvictionSet(SpdyStringPiece name,
-                   SpdyStringPiece value,
+  void EvictionSet(quiche::QuicheStringPiece name,
+                   quiche::QuicheStringPiece value,
                    EntryTable::iterator* begin_out,
                    EntryTable::iterator* end_out);
 
@@ -117,7 +118,8 @@
   // and |value| must not be owned by an entry which could be evicted. The
   // added HpackEntry is returned, or NULL is returned if all entries were
   // evicted and the empty table is of insufficent size for the representation.
-  const HpackEntry* TryAddEntry(SpdyStringPiece name, SpdyStringPiece value);
+  const HpackEntry* TryAddEntry(quiche::QuicheStringPiece name,
+                                quiche::QuicheStringPiece value);
 
   void DebugLogTableState() const SPDY_UNUSED;
 
@@ -130,8 +132,8 @@
 
  private:
   // Returns number of evictions required to enter |name| & |value|.
-  size_t EvictionCountForEntry(SpdyStringPiece name,
-                               SpdyStringPiece value) const;
+  size_t EvictionCountForEntry(quiche::QuicheStringPiece name,
+                               quiche::QuicheStringPiece value) const;
 
   // Returns number of evictions required to reclaim |reclaim_size| table size.
   size_t EvictionCountToReclaim(size_t reclaim_size) const;
diff --git a/spdy/core/hpack/hpack_header_table_test.cc b/spdy/core/hpack/hpack_header_table_test.cc
index a7d2482..4f77587 100644
--- a/spdy/core/hpack/hpack_header_table_test.cc
+++ b/spdy/core/hpack/hpack_header_table_test.cc
@@ -33,8 +33,8 @@
   size_t index_size() {
     return table_->static_index_.size() + table_->dynamic_index_.size();
   }
-  std::vector<HpackEntry*> EvictionSet(SpdyStringPiece name,
-                                       SpdyStringPiece value) {
+  std::vector<HpackEntry*> EvictionSet(quiche::QuicheStringPiece name,
+                                       quiche::QuicheStringPiece value) {
     HpackHeaderTable::EntryTable::iterator begin, end;
     table_->EvictionSet(name, value, &begin, &end);
     std::vector<HpackEntry*> result;
@@ -45,7 +45,8 @@
   }
   size_t total_insertions() { return table_->total_insertions_; }
   size_t dynamic_entries_count() { return table_->dynamic_entries_.size(); }
-  size_t EvictionCountForEntry(SpdyStringPiece name, SpdyStringPiece value) {
+  size_t EvictionCountForEntry(quiche::QuicheStringPiece name,
+                               quiche::QuicheStringPiece value) {
     return table_->EvictionCountForEntry(name, value);
   }
   size_t EvictionCountToReclaim(size_t reclaim_size) {
@@ -53,7 +54,8 @@
   }
   void Evict(size_t count) { return table_->Evict(count); }
 
-  void AddDynamicEntry(SpdyStringPiece name, SpdyStringPiece value) {
+  void AddDynamicEntry(quiche::QuicheStringPiece name,
+                       quiche::QuicheStringPiece value) {
     table_->dynamic_entries_.push_back(
         HpackEntry(name, value, false, table_->total_insertions_++));
   }
diff --git a/spdy/core/hpack/hpack_huffman_table.cc b/spdy/core/hpack/hpack_huffman_table.cc
index 3c637a4..eb799d0 100644
--- a/spdy/core/hpack/hpack_huffman_table.cc
+++ b/spdy/core/hpack/hpack_huffman_table.cc
@@ -96,7 +96,7 @@
   return !code_by_id_.empty();
 }
 
-void HpackHuffmanTable::EncodeString(SpdyStringPiece in,
+void HpackHuffmanTable::EncodeString(quiche::QuicheStringPiece in,
                                      HpackOutputStream* out) const {
   size_t bit_remnant = 0;
   for (size_t i = 0; i != in.size(); i++) {
@@ -129,7 +129,7 @@
   }
 }
 
-size_t HpackHuffmanTable::EncodedSize(SpdyStringPiece in) const {
+size_t HpackHuffmanTable::EncodedSize(quiche::QuicheStringPiece in) const {
   size_t bit_count = 0;
   for (size_t i = 0; i != in.size(); i++) {
     uint16_t symbol_id = static_cast<uint8_t>(in[i]);
diff --git a/spdy/core/hpack/hpack_huffman_table.h b/spdy/core/hpack/hpack_huffman_table.h
index a01c62f..abf8caa 100644
--- a/spdy/core/hpack/hpack_huffman_table.h
+++ b/spdy/core/hpack/hpack_huffman_table.h
@@ -9,9 +9,9 @@
 #include <cstdint>
 #include <vector>
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_constants.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 namespace spdy {
 
@@ -45,10 +45,10 @@
 
   // Encodes the input string to the output stream using the table's Huffman
   // context.
-  void EncodeString(SpdyStringPiece in, HpackOutputStream* out) const;
+  void EncodeString(quiche::QuicheStringPiece in, HpackOutputStream* out) const;
 
   // Returns the encoded size of the input string.
-  size_t EncodedSize(SpdyStringPiece in) const;
+  size_t EncodedSize(quiche::QuicheStringPiece in) const;
 
   // Returns the estimate of dynamically allocated memory in bytes.
   size_t EstimateMemoryUsage() const;
diff --git a/spdy/core/hpack/hpack_huffman_table_test.cc b/spdy/core/hpack/hpack_huffman_table_test.cc
index bc38f6d..abcebf8 100644
--- a/spdy/core/hpack/hpack_huffman_table_test.cc
+++ b/spdy/core/hpack/hpack_huffman_table_test.cc
@@ -42,7 +42,7 @@
  protected:
   GenericHuffmanTableTest() : table_(), peer_(table_) {}
 
-  std::string EncodeString(SpdyStringPiece input) {
+  std::string EncodeString(quiche::QuicheStringPiece input) {
     std::string result;
     HpackOutputStream output_stream;
     table_.EncodeString(input, &output_stream);
@@ -171,10 +171,12 @@
   EXPECT_EQ(0b10011000, peer_.pad_bits());
 
   char input_storage[] = {2, 3, 2, 7, 4};
-  SpdyStringPiece input(input_storage, QUICHE_ARRAYSIZE(input_storage));
+  quiche::QuicheStringPiece input(input_storage,
+                                  QUICHE_ARRAYSIZE(input_storage));
   // By symbol: (2) 00 (3) 010 (2) 00 (7) 10010 (4) 10000 (6 as pad) 1001100.
   char expect_storage[] = {0b00010001, 0b00101000, 0b01001100};
-  SpdyStringPiece expect(expect_storage, QUICHE_ARRAYSIZE(expect_storage));
+  quiche::QuicheStringPiece expect(expect_storage,
+                                   QUICHE_ARRAYSIZE(expect_storage));
   EXPECT_EQ(expect, EncodeString(input));
 }
 
@@ -256,7 +258,7 @@
   for (size_t i = 0; i != 256; i++) {
     char c = static_cast<char>(i);
     char storage[3] = {c, c, c};
-    SpdyStringPiece input(storage, QUICHE_ARRAYSIZE(storage));
+    quiche::QuicheStringPiece input(storage, QUICHE_ARRAYSIZE(storage));
     std::string buffer_in = EncodeString(input);
     std::string buffer_out;
     DecodeString(buffer_in, &buffer_out);
@@ -270,7 +272,7 @@
     storage[i] = static_cast<char>(i);
     storage[511 - i] = static_cast<char>(i);
   }
-  SpdyStringPiece input(storage, QUICHE_ARRAYSIZE(storage));
+  quiche::QuicheStringPiece input(storage, QUICHE_ARRAYSIZE(storage));
   std::string buffer_in = EncodeString(input);
   std::string buffer_out;
   DecodeString(buffer_in, &buffer_out);
diff --git a/spdy/core/hpack/hpack_output_stream.cc b/spdy/core/hpack/hpack_output_stream.cc
index 4ceaece..5c2dd68 100644
--- a/spdy/core/hpack/hpack_output_stream.cc
+++ b/spdy/core/hpack/hpack_output_stream.cc
@@ -41,7 +41,7 @@
   AppendBits(prefix.bits, prefix.bit_size);
 }
 
-void HpackOutputStream::AppendBytes(SpdyStringPiece buffer) {
+void HpackOutputStream::AppendBytes(quiche::QuicheStringPiece buffer) {
   DCHECK_EQ(bit_offset_, 0u);
   buffer_.append(buffer.data(), buffer.size());
 }
diff --git a/spdy/core/hpack/hpack_output_stream.h b/spdy/core/hpack/hpack_output_stream.h
index 5e65139..9b64554 100644
--- a/spdy/core/hpack/hpack_output_stream.h
+++ b/spdy/core/hpack/hpack_output_stream.h
@@ -9,9 +9,9 @@
 #include <map>
 #include <string>
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_constants.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 // All section references below are to
 // http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-08
@@ -37,7 +37,7 @@
   void AppendPrefix(HpackPrefix prefix);
 
   // Directly appends |buffer|.
-  void AppendBytes(SpdyStringPiece buffer);
+  void AppendBytes(quiche::QuicheStringPiece buffer);
 
   // Appends the given integer using the representation described in
   // 6.1. If the internal buffer ends on a byte boundary, the prefix
diff --git a/spdy/core/hpack/hpack_static_table.cc b/spdy/core/hpack/hpack_static_table.cc
index eea1d9e..e8b07f1 100644
--- a/spdy/core/hpack/hpack_static_table.cc
+++ b/spdy/core/hpack/hpack_static_table.cc
@@ -4,11 +4,11 @@
 
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_static_table.h"
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_constants.h"
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_entry.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_estimate_memory_usage.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_logging.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 namespace spdy {
 
@@ -24,8 +24,8 @@
   for (const HpackStaticEntry* it = static_entry_table;
        it != static_entry_table + static_entry_count; ++it) {
     static_entries_.push_back(
-        HpackEntry(SpdyStringPiece(it->name, it->name_len),
-                   SpdyStringPiece(it->value, it->value_len),
+        HpackEntry(quiche::QuicheStringPiece(it->name, it->name_len),
+                   quiche::QuicheStringPiece(it->value, it->value_len),
                    true,  // is_static
                    total_insertions));
     HpackEntry* entry = &static_entries_.back();
diff --git a/spdy/core/hpack/hpack_static_table_test.cc b/spdy/core/hpack/hpack_static_table_test.cc
index 3f51955..4cd310f 100644
--- a/spdy/core/hpack/hpack_static_table_test.cc
+++ b/spdy/core/hpack/hpack_static_table_test.cc
@@ -7,8 +7,8 @@
 #include <set>
 #include <vector>
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_constants.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_test.h"
 
 namespace spdy {
@@ -39,7 +39,7 @@
 
   HpackHeaderTable::NameToEntryMap static_name_index =
       table_.GetStaticNameIndex();
-  std::set<SpdyStringPiece> names;
+  std::set<quiche::QuicheStringPiece> names;
   for (auto* entry : static_index) {
     names.insert(entry->name());
   }
diff --git a/spdy/core/http2_frame_decoder_adapter.h b/spdy/core/http2_frame_decoder_adapter.h
index 93da684..b1e16b1 100644
--- a/spdy/core/http2_frame_decoder_adapter.h
+++ b/spdy/core/http2_frame_decoder_adapter.h
@@ -13,12 +13,12 @@
 
 #include "net/third_party/quiche/src/http2/decoder/http2_frame_decoder.h"
 #include "net/third_party/quiche/src/http2/platform/api/http2_optional.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_decoder_adapter.h"
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_header_table.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_headers_handler_interface.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 namespace spdy {
 
@@ -473,7 +473,7 @@
   // Called when an ALTSVC frame has been parsed.
   virtual void OnAltSvc(
       SpdyStreamId /*stream_id*/,
-      SpdyStringPiece /*origin*/,
+      quiche::QuicheStringPiece /*origin*/,
       const SpdyAltSvcWireFormat::AlternativeServiceVector& /*altsvc_vector*/) {
   }
 
diff --git a/spdy/core/mock_spdy_framer_visitor.h b/spdy/core/mock_spdy_framer_visitor.h
index 8600f5c..3425187 100644
--- a/spdy/core/mock_spdy_framer_visitor.h
+++ b/spdy/core/mock_spdy_framer_visitor.h
@@ -9,9 +9,9 @@
 #include <memory>
 #include <utility>
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/http2_frame_decoder_adapter.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_test_utils.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_test.h"
 
 namespace spdy {
@@ -61,7 +61,7 @@
   MOCK_METHOD2(OnContinuation, void(SpdyStreamId stream_id, bool end));
   MOCK_METHOD3(OnAltSvc,
                void(SpdyStreamId stream_id,
-                    SpdyStringPiece origin,
+                    quiche::QuicheStringPiece origin,
                     const SpdyAltSvcWireFormat::AlternativeServiceVector&
                         altsvc_vector));
   MOCK_METHOD4(OnPriority,
diff --git a/spdy/core/spdy_alt_svc_wire_format.cc b/spdy/core/spdy_alt_svc_wire_format.cc
index fcbfd16..2f90ab3 100644
--- a/spdy/core/spdy_alt_svc_wire_format.cc
+++ b/spdy/core/spdy_alt_svc_wire_format.cc
@@ -16,8 +16,8 @@
 namespace {
 
 template <class T>
-bool ParsePositiveIntegerImpl(SpdyStringPiece::const_iterator c,
-                              SpdyStringPiece::const_iterator end,
+bool ParsePositiveIntegerImpl(quiche::QuicheStringPiece::const_iterator c,
+                              quiche::QuicheStringPiece::const_iterator end,
                               T* value) {
   *value = 0;
   for (; c != end && std::isdigit(*c); ++c) {
@@ -56,20 +56,20 @@
 
 // static
 bool SpdyAltSvcWireFormat::ParseHeaderFieldValue(
-    SpdyStringPiece value,
+    quiche::QuicheStringPiece value,
     AlternativeServiceVector* altsvc_vector) {
   // Empty value is invalid according to the specification.
   if (value.empty()) {
     return false;
   }
   altsvc_vector->clear();
-  if (value == SpdyStringPiece("clear")) {
+  if (value == quiche::QuicheStringPiece("clear")) {
     return true;
   }
-  SpdyStringPiece::const_iterator c = value.begin();
+  quiche::QuicheStringPiece::const_iterator c = value.begin();
   while (c != value.end()) {
     // Parse protocol-id.
-    SpdyStringPiece::const_iterator percent_encoded_protocol_id_end =
+    quiche::QuicheStringPiece::const_iterator percent_encoded_protocol_id_end =
         std::find(c, value.end(), '=');
     std::string protocol_id;
     if (percent_encoded_protocol_id_end == c ||
@@ -90,7 +90,7 @@
       return false;
     }
     ++c;
-    SpdyStringPiece::const_iterator alt_authority_begin = c;
+    quiche::QuicheStringPiece::const_iterator alt_authority_begin = c;
     for (; c != value.end() && *c != '"'; ++c) {
       // Decode backslash encoding.
       if (*c != '\\') {
@@ -114,7 +114,7 @@
     // Parse parameters.
     uint32_t max_age = 86400;
     VersionVector version;
-    SpdyStringPiece::const_iterator parameters_end =
+    quiche::QuicheStringPiece::const_iterator parameters_end =
         std::find(c, value.end(), ',');
     while (c != parameters_end) {
       SkipWhiteSpace(&c, parameters_end);
@@ -139,7 +139,7 @@
       }
       ++c;
       SkipWhiteSpace(&c, parameters_end);
-      SpdyStringPiece::const_iterator parameter_value_begin = c;
+      quiche::QuicheStringPiece::const_iterator parameter_value_begin = c;
       for (; c != parameters_end && *c != ';' && *c != ' ' && *c != '\t'; ++c) {
       }
       if (c == parameter_value_begin) {
@@ -163,9 +163,10 @@
         }
         ++c;
         parameters_end = std::find(c, value.end(), ',');
-        SpdyStringPiece::const_iterator v_begin = parameter_value_begin + 1;
+        quiche::QuicheStringPiece::const_iterator v_begin =
+            parameter_value_begin + 1;
         while (v_begin < c) {
-          SpdyStringPiece::const_iterator v_end = v_begin;
+          quiche::QuicheStringPiece::const_iterator v_end = v_begin;
           while (v_end < c - 1 && *v_end != ',') {
             ++v_end;
           }
@@ -194,9 +195,10 @@
         // hq=":443";quic=51303338
         // ... will be stored in |versions| as 0x51303338.
         uint32_t quic_version;
-        if (!SpdyHexDecodeToUInt32(SpdyStringPiece(parameter_value_begin,
-                                                   c - parameter_value_begin),
-                                   &quic_version) ||
+        if (!SpdyHexDecodeToUInt32(
+                quiche::QuicheStringPiece(parameter_value_begin,
+                                          c - parameter_value_begin),
+                &quic_version) ||
             quic_version == 0) {
           return false;
         }
@@ -291,16 +293,18 @@
 }
 
 // static
-void SpdyAltSvcWireFormat::SkipWhiteSpace(SpdyStringPiece::const_iterator* c,
-                                          SpdyStringPiece::const_iterator end) {
+void SpdyAltSvcWireFormat::SkipWhiteSpace(
+    quiche::QuicheStringPiece::const_iterator* c,
+    quiche::QuicheStringPiece::const_iterator end) {
   for (; *c != end && (**c == ' ' || **c == '\t'); ++*c) {
   }
 }
 
 // static
-bool SpdyAltSvcWireFormat::PercentDecode(SpdyStringPiece::const_iterator c,
-                                         SpdyStringPiece::const_iterator end,
-                                         std::string* output) {
+bool SpdyAltSvcWireFormat::PercentDecode(
+    quiche::QuicheStringPiece::const_iterator c,
+    quiche::QuicheStringPiece::const_iterator end,
+    std::string* output) {
   output->clear();
   for (; c != end; ++c) {
     if (*c != '%') {
@@ -326,8 +330,8 @@
 
 // static
 bool SpdyAltSvcWireFormat::ParseAltAuthority(
-    SpdyStringPiece::const_iterator c,
-    SpdyStringPiece::const_iterator end,
+    quiche::QuicheStringPiece::const_iterator c,
+    quiche::QuicheStringPiece::const_iterator end,
     std::string* host,
     uint16_t* port) {
   host->clear();
@@ -373,16 +377,16 @@
 
 // static
 bool SpdyAltSvcWireFormat::ParsePositiveInteger16(
-    SpdyStringPiece::const_iterator c,
-    SpdyStringPiece::const_iterator end,
+    quiche::QuicheStringPiece::const_iterator c,
+    quiche::QuicheStringPiece::const_iterator end,
     uint16_t* value) {
   return ParsePositiveIntegerImpl<uint16_t>(c, end, value);
 }
 
 // static
 bool SpdyAltSvcWireFormat::ParsePositiveInteger32(
-    SpdyStringPiece::const_iterator c,
-    SpdyStringPiece::const_iterator end,
+    quiche::QuicheStringPiece::const_iterator c,
+    quiche::QuicheStringPiece::const_iterator end,
     uint32_t* value) {
   return ParsePositiveIntegerImpl<uint32_t>(c, end, value);
 }
diff --git a/spdy/core/spdy_alt_svc_wire_format.h b/spdy/core/spdy_alt_svc_wire_format.h
index 13142ef..6c3e7af 100644
--- a/spdy/core/spdy_alt_svc_wire_format.h
+++ b/spdy/core/spdy_alt_svc_wire_format.h
@@ -14,9 +14,9 @@
 #include <string>
 #include <vector>
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_containers.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 namespace spdy {
 
@@ -60,27 +60,29 @@
   typedef std::vector<AlternativeService> AlternativeServiceVector;
 
   friend class test::SpdyAltSvcWireFormatPeer;
-  static bool ParseHeaderFieldValue(SpdyStringPiece value,
+  static bool ParseHeaderFieldValue(quiche::QuicheStringPiece value,
                                     AlternativeServiceVector* altsvc_vector);
   static std::string SerializeHeaderFieldValue(
       const AlternativeServiceVector& altsvc_vector);
 
  private:
-  static void SkipWhiteSpace(SpdyStringPiece::const_iterator* c,
-                             SpdyStringPiece::const_iterator end);
-  static bool PercentDecode(SpdyStringPiece::const_iterator c,
-                            SpdyStringPiece::const_iterator end,
+  static void SkipWhiteSpace(quiche::QuicheStringPiece::const_iterator* c,
+                             quiche::QuicheStringPiece::const_iterator end);
+  static bool PercentDecode(quiche::QuicheStringPiece::const_iterator c,
+                            quiche::QuicheStringPiece::const_iterator end,
                             std::string* output);
-  static bool ParseAltAuthority(SpdyStringPiece::const_iterator c,
-                                SpdyStringPiece::const_iterator end,
+  static bool ParseAltAuthority(quiche::QuicheStringPiece::const_iterator c,
+                                quiche::QuicheStringPiece::const_iterator end,
                                 std::string* host,
                                 uint16_t* port);
-  static bool ParsePositiveInteger16(SpdyStringPiece::const_iterator c,
-                                     SpdyStringPiece::const_iterator end,
-                                     uint16_t* value);
-  static bool ParsePositiveInteger32(SpdyStringPiece::const_iterator c,
-                                     SpdyStringPiece::const_iterator end,
-                                     uint32_t* value);
+  static bool ParsePositiveInteger16(
+      quiche::QuicheStringPiece::const_iterator c,
+      quiche::QuicheStringPiece::const_iterator end,
+      uint16_t* value);
+  static bool ParsePositiveInteger32(
+      quiche::QuicheStringPiece::const_iterator c,
+      quiche::QuicheStringPiece::const_iterator end,
+      uint32_t* value);
 };
 
 }  // namespace spdy
diff --git a/spdy/core/spdy_alt_svc_wire_format_test.cc b/spdy/core/spdy_alt_svc_wire_format_test.cc
index 7b5e0bb..6dc4bab 100644
--- a/spdy/core/spdy_alt_svc_wire_format_test.cc
+++ b/spdy/core/spdy_alt_svc_wire_format_test.cc
@@ -14,29 +14,31 @@
 // Expose all private methods of class SpdyAltSvcWireFormat.
 class SpdyAltSvcWireFormatPeer {
  public:
-  static void SkipWhiteSpace(SpdyStringPiece::const_iterator* c,
-                             SpdyStringPiece::const_iterator end) {
+  static void SkipWhiteSpace(quiche::QuicheStringPiece::const_iterator* c,
+                             quiche::QuicheStringPiece::const_iterator end) {
     SpdyAltSvcWireFormat::SkipWhiteSpace(c, end);
   }
-  static bool PercentDecode(SpdyStringPiece::const_iterator c,
-                            SpdyStringPiece::const_iterator end,
+  static bool PercentDecode(quiche::QuicheStringPiece::const_iterator c,
+                            quiche::QuicheStringPiece::const_iterator end,
                             std::string* output) {
     return SpdyAltSvcWireFormat::PercentDecode(c, end, output);
   }
-  static bool ParseAltAuthority(SpdyStringPiece::const_iterator c,
-                                SpdyStringPiece::const_iterator end,
+  static bool ParseAltAuthority(quiche::QuicheStringPiece::const_iterator c,
+                                quiche::QuicheStringPiece::const_iterator end,
                                 std::string* host,
                                 uint16_t* port) {
     return SpdyAltSvcWireFormat::ParseAltAuthority(c, end, host, port);
   }
-  static bool ParsePositiveInteger16(SpdyStringPiece::const_iterator c,
-                                     SpdyStringPiece::const_iterator end,
-                                     uint16_t* max_age) {
+  static bool ParsePositiveInteger16(
+      quiche::QuicheStringPiece::const_iterator c,
+      quiche::QuicheStringPiece::const_iterator end,
+      uint16_t* max_age) {
     return SpdyAltSvcWireFormat::ParsePositiveInteger16(c, end, max_age);
   }
-  static bool ParsePositiveInteger32(SpdyStringPiece::const_iterator c,
-                                     SpdyStringPiece::const_iterator end,
-                                     uint32_t* max_age) {
+  static bool ParsePositiveInteger32(
+      quiche::QuicheStringPiece::const_iterator c,
+      quiche::QuicheStringPiece::const_iterator end,
+      uint32_t* max_age) {
     return SpdyAltSvcWireFormat::ParsePositiveInteger32(c, end, max_age);
   }
 };
@@ -387,8 +389,8 @@
 
 // Test SkipWhiteSpace().
 TEST(SpdyAltSvcWireFormatTest, SkipWhiteSpace) {
-  SpdyStringPiece input("a \tb  ");
-  SpdyStringPiece::const_iterator c = input.begin();
+  quiche::QuicheStringPiece input("a \tb  ");
+  quiche::QuicheStringPiece::const_iterator c = input.begin();
   test::SpdyAltSvcWireFormatPeer::SkipWhiteSpace(&c, input.end());
   ASSERT_EQ(input.begin(), c);
   ++c;
@@ -401,19 +403,19 @@
 
 // Test PercentDecode() on valid input.
 TEST(SpdyAltSvcWireFormatTest, PercentDecodeValid) {
-  SpdyStringPiece input("");
+  quiche::QuicheStringPiece input("");
   std::string output;
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::PercentDecode(
       input.begin(), input.end(), &output));
   EXPECT_EQ("", output);
 
-  input = SpdyStringPiece("foo");
+  input = quiche::QuicheStringPiece("foo");
   output.clear();
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::PercentDecode(
       input.begin(), input.end(), &output));
   EXPECT_EQ("foo", output);
 
-  input = SpdyStringPiece("%2ca%5Cb");
+  input = quiche::QuicheStringPiece("%2ca%5Cb");
   output.clear();
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::PercentDecode(
       input.begin(), input.end(), &output));
@@ -424,7 +426,7 @@
 TEST(SpdyAltSvcWireFormatTest, PercentDecodeInvalid) {
   const char* invalid_input_array[] = {"a%", "a%x", "a%b", "%J22", "%9z"};
   for (const char* invalid_input : invalid_input_array) {
-    SpdyStringPiece input(invalid_input);
+    quiche::QuicheStringPiece input(invalid_input);
     std::string output;
     EXPECT_FALSE(test::SpdyAltSvcWireFormatPeer::PercentDecode(
         input.begin(), input.end(), &output))
@@ -434,7 +436,7 @@
 
 // Test ParseAltAuthority() on valid input.
 TEST(SpdyAltSvcWireFormatTest, ParseAltAuthorityValid) {
-  SpdyStringPiece input(":42");
+  quiche::QuicheStringPiece input(":42");
   std::string host;
   uint16_t port;
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority(
@@ -442,13 +444,13 @@
   EXPECT_TRUE(host.empty());
   EXPECT_EQ(42, port);
 
-  input = SpdyStringPiece("foo:137");
+  input = quiche::QuicheStringPiece("foo:137");
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority(
       input.begin(), input.end(), &host, &port));
   EXPECT_EQ("foo", host);
   EXPECT_EQ(137, port);
 
-  input = SpdyStringPiece("[2003:8:0:16::509d:9615]:443");
+  input = quiche::QuicheStringPiece("[2003:8:0:16::509d:9615]:443");
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority(
       input.begin(), input.end(), &host, &port));
   EXPECT_EQ("[2003:8:0:16::509d:9615]", host);
@@ -475,7 +477,7 @@
                                        "[2003:8:0:16::509d:9615:443",
                                        "2003:8:0:16::509d:9615]:443"};
   for (const char* invalid_input : invalid_input_array) {
-    SpdyStringPiece input(invalid_input);
+    quiche::QuicheStringPiece input(invalid_input);
     std::string host;
     uint16_t port;
     EXPECT_FALSE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority(
@@ -486,13 +488,13 @@
 
 // Test ParseInteger() on valid input.
 TEST(SpdyAltSvcWireFormatTest, ParseIntegerValid) {
-  SpdyStringPiece input("3");
+  quiche::QuicheStringPiece input("3");
   uint16_t value;
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16(
       input.begin(), input.end(), &value));
   EXPECT_EQ(3, value);
 
-  input = SpdyStringPiece("1337");
+  input = quiche::QuicheStringPiece("1337");
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16(
       input.begin(), input.end(), &value));
   EXPECT_EQ(1337, value);
@@ -503,7 +505,7 @@
 TEST(SpdyAltSvcWireFormatTest, ParseIntegerInvalid) {
   const char* invalid_input_array[] = {"", " ", "a", "0", "00", "1 ", "12b"};
   for (const char* invalid_input : invalid_input_array) {
-    SpdyStringPiece input(invalid_input);
+    quiche::QuicheStringPiece input(invalid_input);
     uint16_t value;
     EXPECT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16(
         input.begin(), input.end(), &value))
@@ -514,39 +516,39 @@
 // Test ParseIntegerValid() around overflow limit.
 TEST(SpdyAltSvcWireFormatTest, ParseIntegerOverflow) {
   // Largest possible uint16_t value.
-  SpdyStringPiece input("65535");
+  quiche::QuicheStringPiece input("65535");
   uint16_t value16;
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16(
       input.begin(), input.end(), &value16));
   EXPECT_EQ(65535, value16);
 
   // Overflow uint16_t, ParsePositiveInteger16() should return false.
-  input = SpdyStringPiece("65536");
+  input = quiche::QuicheStringPiece("65536");
   ASSERT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16(
       input.begin(), input.end(), &value16));
 
   // However, even if overflow is not checked for, 65536 overflows to 0, which
   // returns false anyway.  Check for a larger number which overflows to 1.
-  input = SpdyStringPiece("65537");
+  input = quiche::QuicheStringPiece("65537");
   ASSERT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16(
       input.begin(), input.end(), &value16));
 
   // Largest possible uint32_t value.
-  input = SpdyStringPiece("4294967295");
+  input = quiche::QuicheStringPiece("4294967295");
   uint32_t value32;
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger32(
       input.begin(), input.end(), &value32));
   EXPECT_EQ(4294967295, value32);
 
   // Overflow uint32_t, ParsePositiveInteger32() should return false.
-  input = SpdyStringPiece("4294967296");
+  input = quiche::QuicheStringPiece("4294967296");
   ASSERT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger32(
       input.begin(), input.end(), &value32));
 
   // However, even if overflow is not checked for, 4294967296 overflows to 0,
   // which returns false anyway.  Check for a larger number which overflows to
   // 1.
-  input = SpdyStringPiece("4294967297");
+  input = quiche::QuicheStringPiece("4294967297");
   ASSERT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger32(
       input.begin(), input.end(), &value32));
 }
diff --git a/spdy/core/spdy_deframer_visitor.cc b/spdy/core/spdy_deframer_visitor.cc
index e49b755..10e5e85 100644
--- a/spdy/core/spdy_deframer_visitor.cc
+++ b/spdy/core/spdy_deframer_visitor.cc
@@ -12,6 +12,7 @@
 #include <memory>
 
 #include "net/third_party/quiche/src/http2/platform/api/http2_macros.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_constants.h"
 #include "net/third_party/quiche/src/spdy/core/mock_spdy_framer_visitor.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_frame_reader.h"
@@ -19,7 +20,6 @@
 #include "net/third_party/quiche/src/spdy/core/spdy_test_utils.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_flags.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_logging.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 using ::testing::AssertionFailure;
 using ::testing::AssertionResult;
@@ -138,7 +138,7 @@
   // alphabetical order for ease of navigation, and are not in same order
   // as in SpdyFramerVisitorInterface.
   void OnAltSvc(SpdyStreamId stream_id,
-                SpdyStringPiece origin,
+                quiche::QuicheStringPiece origin,
                 const SpdyAltSvcWireFormat::AlternativeServiceVector&
                     altsvc_vector) override;
   void OnContinuation(SpdyStreamId stream_id, bool end) override;
@@ -184,7 +184,8 @@
   // Callbacks defined in SpdyHeadersHandlerInterface.
 
   void OnHeaderBlockStart() override;
-  void OnHeader(SpdyStringPiece key, SpdyStringPiece value) override;
+  void OnHeader(quiche::QuicheStringPiece key,
+                quiche::QuicheStringPiece value) override;
   void OnHeaderBlockEnd(size_t header_bytes_parsed,
                         size_t compressed_header_bytes_parsed) override;
 
@@ -409,7 +410,7 @@
 
 void SpdyTestDeframerImpl::OnAltSvc(
     SpdyStreamId stream_id,
-    SpdyStringPiece origin,
+    quiche::QuicheStringPiece origin,
     const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector) {
   SPDY_DVLOG(1) << "OnAltSvc stream_id: " << stream_id;
   CHECK_EQ(frame_type_, UNSET)
@@ -754,8 +755,8 @@
   got_hpack_end_ = false;
 }
 
-void SpdyTestDeframerImpl::OnHeader(SpdyStringPiece key,
-                                    SpdyStringPiece value) {
+void SpdyTestDeframerImpl::OnHeader(quiche::QuicheStringPiece key,
+                                    quiche::QuicheStringPiece value) {
   CHECK(frame_type_ == HEADERS || frame_type_ == CONTINUATION ||
         frame_type_ == PUSH_PROMISE)
       << "   frame_type_=" << Http2FrameTypeToString(frame_type_);
diff --git a/spdy/core/spdy_deframer_visitor.h b/spdy/core/spdy_deframer_visitor.h
index f36daac..2753523 100644
--- a/spdy/core/spdy_deframer_visitor.h
+++ b/spdy/core/spdy_deframer_visitor.h
@@ -45,7 +45,7 @@
 //    framer.set_visitor(the_deframer.get());
 //
 //    // Process frames.
-//    SpdyStringPiece input = ...
+//    QuicheStringPiece input = ...
 //    while (!input.empty() && !framer.HasError()) {
 //      size_t consumed = framer.ProcessInput(input.data(), input.size());
 //      input.remove_prefix(consumed);
diff --git a/spdy/core/spdy_frame_builder.cc b/spdy/core/spdy_frame_builder.cc
index f4b71d3..492cd43 100644
--- a/spdy/core/spdy_frame_builder.cc
+++ b/spdy/core/spdy_frame_builder.cc
@@ -120,7 +120,8 @@
   return success;
 }
 
-bool SpdyFrameBuilder::WriteStringPiece32(const SpdyStringPiece value) {
+bool SpdyFrameBuilder::WriteStringPiece32(
+    const quiche::QuicheStringPiece value) {
   if (!WriteUInt32(value.size())) {
     return false;
   }
diff --git a/spdy/core/spdy_frame_builder.h b/spdy/core/spdy_frame_builder.h
index e1dc32b..eb90ddb 100644
--- a/spdy/core/spdy_frame_builder.h
+++ b/spdy/core/spdy_frame_builder.h
@@ -9,12 +9,12 @@
 #include <cstdint>
 #include <memory>
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
 #include "net/third_party/quiche/src/spdy/core/zero_copy_output_buffer.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_bug_tracker.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_endianness_util.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 namespace spdy {
 
@@ -100,7 +100,7 @@
     return (WriteBytes(&upper, sizeof(upper)) &&
             WriteBytes(&lower, sizeof(lower)));
   }
-  bool WriteStringPiece32(const SpdyStringPiece value);
+  bool WriteStringPiece32(const quiche::QuicheStringPiece value);
   bool WriteBytes(const void* data, uint32_t data_len);
 
  private:
diff --git a/spdy/core/spdy_frame_builder_test.cc b/spdy/core/spdy_frame_builder_test.cc
index c5f234e..73ee8e8 100644
--- a/spdy/core/spdy_frame_builder_test.cc
+++ b/spdy/core/spdy_frame_builder_test.cc
@@ -48,8 +48,8 @@
   SpdySerializedFrame frame(builder.take());
   char expected[kBuilderSize];
   memset(expected, ~1, kBuilderSize);
-  EXPECT_EQ(SpdyStringPiece(expected, kBuilderSize),
-            SpdyStringPiece(frame.data(), kBuilderSize));
+  EXPECT_EQ(quiche::QuicheStringPiece(expected, kBuilderSize),
+            quiche::QuicheStringPiece(frame.data(), kBuilderSize));
 }
 
 // Verifies that SpdyFrameBuilder::GetWritableBuffer() can be used to build a
@@ -66,8 +66,8 @@
   SpdySerializedFrame frame(output.Begin(), kBuilderSize, false);
   char expected[kBuilderSize];
   memset(expected, ~1, kBuilderSize);
-  EXPECT_EQ(SpdyStringPiece(expected, kBuilderSize),
-            SpdyStringPiece(frame.data(), kBuilderSize));
+  EXPECT_EQ(quiche::QuicheStringPiece(expected, kBuilderSize),
+            quiche::QuicheStringPiece(frame.data(), kBuilderSize));
 }
 
 // Verifies the case that the buffer's capacity is too small.
diff --git a/spdy/core/spdy_frame_reader.cc b/spdy/core/spdy_frame_reader.cc
index b9bf4c1..253f906 100644
--- a/spdy/core/spdy_frame_reader.cc
+++ b/spdy/core/spdy_frame_reader.cc
@@ -109,7 +109,7 @@
   return true;
 }
 
-bool SpdyFrameReader::ReadStringPiece16(SpdyStringPiece* result) {
+bool SpdyFrameReader::ReadStringPiece16(quiche::QuicheStringPiece* result) {
   // Read resultant length.
   uint16_t result_len;
   if (!ReadUInt16(&result_len)) {
@@ -124,7 +124,7 @@
   }
 
   // Set result.
-  *result = SpdyStringPiece(data_ + ofs_, result_len);
+  *result = quiche::QuicheStringPiece(data_ + ofs_, result_len);
 
   // Iterate.
   ofs_ += result_len;
@@ -132,7 +132,7 @@
   return true;
 }
 
-bool SpdyFrameReader::ReadStringPiece32(SpdyStringPiece* result) {
+bool SpdyFrameReader::ReadStringPiece32(quiche::QuicheStringPiece* result) {
   // Read resultant length.
   uint32_t result_len;
   if (!ReadUInt32(&result_len)) {
@@ -147,7 +147,7 @@
   }
 
   // Set result.
-  *result = SpdyStringPiece(data_ + ofs_, result_len);
+  *result = quiche::QuicheStringPiece(data_ + ofs_, result_len);
 
   // Iterate.
   ofs_ += result_len;
diff --git a/spdy/core/spdy_frame_reader.h b/spdy/core/spdy_frame_reader.h
index dc6c064..a7136ca 100644
--- a/spdy/core/spdy_frame_reader.h
+++ b/spdy/core/spdy_frame_reader.h
@@ -7,8 +7,8 @@
 
 #include <cstdint>
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 namespace spdy {
 
@@ -73,7 +73,7 @@
   //
   // Forwards the internal iterator on success.
   // Returns true on success, false otherwise.
-  bool ReadStringPiece16(SpdyStringPiece* result);
+  bool ReadStringPiece16(quiche::QuicheStringPiece* result);
 
   // Reads a string prefixed with 32-bit length into the given output parameter.
   //
@@ -82,7 +82,7 @@
   //
   // Forwards the internal iterator on success.
   // Returns true on success, false otherwise.
-  bool ReadStringPiece32(SpdyStringPiece* result);
+  bool ReadStringPiece32(quiche::QuicheStringPiece* result);
 
   // Reads a given number of bytes into the given buffer. The buffer
   // must be of adequate size.
diff --git a/spdy/core/spdy_frame_reader_test.cc b/spdy/core/spdy_frame_reader_test.cc
index c1ab02e..a3cfe21 100644
--- a/spdy/core/spdy_frame_reader_test.cc
+++ b/spdy/core/spdy_frame_reader_test.cc
@@ -67,7 +67,7 @@
   SpdyFrameReader frame_reader(kFrameData, QUICHE_ARRAYSIZE(kFrameData));
   EXPECT_FALSE(frame_reader.IsDoneReading());
 
-  SpdyStringPiece stringpiece_val;
+  quiche::QuicheStringPiece stringpiece_val;
   EXPECT_TRUE(frame_reader.ReadStringPiece16(&stringpiece_val));
   EXPECT_FALSE(frame_reader.IsDoneReading());
   EXPECT_EQ(0, stringpiece_val.compare("Hi"));
@@ -90,7 +90,7 @@
   SpdyFrameReader frame_reader(kFrameData, QUICHE_ARRAYSIZE(kFrameData));
   EXPECT_FALSE(frame_reader.IsDoneReading());
 
-  SpdyStringPiece stringpiece_val;
+  quiche::QuicheStringPiece stringpiece_val;
   EXPECT_TRUE(frame_reader.ReadStringPiece32(&stringpiece_val));
   EXPECT_FALSE(frame_reader.IsDoneReading());
   EXPECT_EQ(0, stringpiece_val.compare("foo"));
@@ -142,7 +142,7 @@
   SpdyFrameReader frame_reader(kFrameData, QUICHE_ARRAYSIZE(kFrameData));
   EXPECT_FALSE(frame_reader.IsDoneReading());
 
-  SpdyStringPiece stringpiece_val;
+  quiche::QuicheStringPiece stringpiece_val;
   EXPECT_FALSE(frame_reader.ReadStringPiece16(&stringpiece_val));
 
   // Also make sure that trying to read a uint16_t, which technically could
@@ -161,7 +161,7 @@
   SpdyFrameReader frame_reader(kFrameData, QUICHE_ARRAYSIZE(kFrameData));
   EXPECT_FALSE(frame_reader.IsDoneReading());
 
-  SpdyStringPiece stringpiece_val;
+  quiche::QuicheStringPiece stringpiece_val;
   EXPECT_FALSE(frame_reader.ReadStringPiece16(&stringpiece_val));
 
   // Also make sure that trying to read a uint16_t, which technically could
@@ -181,7 +181,7 @@
   SpdyFrameReader frame_reader(kFrameData, QUICHE_ARRAYSIZE(kFrameData));
   EXPECT_FALSE(frame_reader.IsDoneReading());
 
-  SpdyStringPiece stringpiece_val;
+  quiche::QuicheStringPiece stringpiece_val;
   EXPECT_FALSE(frame_reader.ReadStringPiece32(&stringpiece_val));
 
   // Also make sure that trying to read a uint16_t, which technically could
@@ -200,7 +200,7 @@
   SpdyFrameReader frame_reader(kFrameData, QUICHE_ARRAYSIZE(kFrameData));
   EXPECT_FALSE(frame_reader.IsDoneReading());
 
-  SpdyStringPiece stringpiece_val;
+  quiche::QuicheStringPiece stringpiece_val;
   EXPECT_FALSE(frame_reader.ReadStringPiece32(&stringpiece_val));
 
   // Also make sure that trying to read a uint16_t, which technically could
@@ -222,12 +222,12 @@
   char dest1[3] = {};
   EXPECT_TRUE(frame_reader.ReadBytes(&dest1, QUICHE_ARRAYSIZE(dest1)));
   EXPECT_FALSE(frame_reader.IsDoneReading());
-  EXPECT_EQ("foo", SpdyStringPiece(dest1, QUICHE_ARRAYSIZE(dest1)));
+  EXPECT_EQ("foo", quiche::QuicheStringPiece(dest1, QUICHE_ARRAYSIZE(dest1)));
 
   char dest2[2] = {};
   EXPECT_TRUE(frame_reader.ReadBytes(&dest2, QUICHE_ARRAYSIZE(dest2)));
   EXPECT_TRUE(frame_reader.IsDoneReading());
-  EXPECT_EQ("Hi", SpdyStringPiece(dest2, QUICHE_ARRAYSIZE(dest2)));
+  EXPECT_EQ("Hi", quiche::QuicheStringPiece(dest2, QUICHE_ARRAYSIZE(dest2)));
 }
 
 TEST(SpdyFrameReaderTest, ReadBytesWithBufferTooSmall) {
diff --git a/spdy/core/spdy_framer.h b/spdy/core/spdy_framer.h
index 45d1f86..95b7e20 100644
--- a/spdy/core/spdy_framer.h
+++ b/spdy/core/spdy_framer.h
@@ -13,6 +13,7 @@
 #include <string>
 #include <utility>
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/hpack/hpack_encoder.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_header_block.h"
@@ -20,7 +21,6 @@
 #include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
 #include "net/third_party/quiche/src/spdy/core/zero_copy_output_buffer.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 namespace spdy {
 
diff --git a/spdy/core/spdy_framer_test.cc b/spdy/core/spdy_framer_test.cc
index dd9f150..d14d293 100644
--- a/spdy/core/spdy_framer_test.cc
+++ b/spdy/core/spdy_framer_test.cc
@@ -287,7 +287,7 @@
     SPDY_VLOG(1) << "OnStreamFrameData(" << stream_id << ", data, " << len
                  << ", "
                  << ")   data:\n"
-                 << SpdyHexDump(SpdyStringPiece(data, len));
+                 << SpdyHexDump(quiche::QuicheStringPiece(data, len));
     EXPECT_EQ(header_stream_id_, stream_id);
 
     data_bytes_ += len;
@@ -403,7 +403,7 @@
   }
 
   void OnAltSvc(SpdyStreamId stream_id,
-                SpdyStringPiece origin,
+                quiche::QuicheStringPiece origin,
                 const SpdyAltSvcWireFormat::AlternativeServiceVector&
                     altsvc_vector) override {
     SPDY_VLOG(1) << "OnAltSvc(" << stream_id << ", \"" << origin
@@ -1125,7 +1125,7 @@
       control_frame.size());
 
   EXPECT_THAT(visitor.headers_, testing::ElementsAre(testing::Pair(
-                                    "name", SpdyStringPiece(value))));
+                                    "name", quiche::QuicheStringPiece(value))));
 }
 
 TEST_P(SpdyFramerTest, CompressEmptyHeaders) {
@@ -1315,7 +1315,7 @@
 
   const char bytes[] = "this is a test test test test test!";
   SpdyDataIR data_ir(/* stream_id = */ 1,
-                     SpdyStringPiece(bytes, QUICHE_ARRAYSIZE(bytes)));
+                     quiche::QuicheStringPiece(bytes, QUICHE_ARRAYSIZE(bytes)));
   data_ir.set_fin(true);
   SpdySerializedFrame send_frame(framer_.SerializeData(data_ir));
 
@@ -4298,8 +4298,8 @@
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
   altsvc_vector.push_back(altsvc1);
   altsvc_vector.push_back(altsvc2);
-  EXPECT_CALL(visitor,
-              OnAltSvc(kStreamId, SpdyStringPiece("o_r|g!n"), altsvc_vector));
+  EXPECT_CALL(visitor, OnAltSvc(kStreamId, quiche::QuicheStringPiece("o_r|g!n"),
+                                altsvc_vector));
 
   SpdyAltSvcIR altsvc_ir(kStreamId);
   altsvc_ir.set_origin("o_r|g!n");
@@ -4333,7 +4333,8 @@
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
   altsvc_vector.push_back(altsvc1);
   altsvc_vector.push_back(altsvc2);
-  EXPECT_CALL(visitor, OnAltSvc(kStreamId, SpdyStringPiece(""), altsvc_vector));
+  EXPECT_CALL(visitor, OnAltSvc(kStreamId, quiche::QuicheStringPiece(""),
+                                altsvc_vector));
 
   SpdyAltSvcIR altsvc_ir(kStreamId);
   altsvc_ir.add_altsvc(altsvc1);
@@ -4769,7 +4770,8 @@
   SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
 
   const char bytes[] = "this is a very short data frame";
-  SpdyDataIR data_ir(1, SpdyStringPiece(bytes, QUICHE_ARRAYSIZE(bytes)));
+  SpdyDataIR data_ir(1,
+                     quiche::QuicheStringPiece(bytes, QUICHE_ARRAYSIZE(bytes)));
   CheckFrameAndIRSize(&data_ir, &framer, &output_);
 
   SpdyRstStreamIR rst_ir(/* stream_id = */ 1, ERROR_CODE_PROTOCOL_ERROR);
diff --git a/spdy/core/spdy_header_block.cc b/spdy/core/spdy_header_block.cc
index c87bfff..d7e3faa 100644
--- a/spdy/core/spdy_header_block.cc
+++ b/spdy/core/spdy_header_block.cc
@@ -27,20 +27,21 @@
 const char kCookieKey[] = "cookie";
 const char kNullSeparator = 0;
 
-SpdyStringPiece SeparatorForKey(SpdyStringPiece key) {
+quiche::QuicheStringPiece SeparatorForKey(quiche::QuicheStringPiece key) {
   if (key == kCookieKey) {
-    static SpdyStringPiece cookie_separator = "; ";
+    static quiche::QuicheStringPiece cookie_separator = "; ";
     return cookie_separator;
   } else {
-    return SpdyStringPiece(&kNullSeparator, 1);
+    return quiche::QuicheStringPiece(&kNullSeparator, 1);
   }
 }
 
 }  // namespace
 
-SpdyHeaderBlock::HeaderValue::HeaderValue(SpdyHeaderStorage* storage,
-                                          SpdyStringPiece key,
-                                          SpdyStringPiece initial_value)
+SpdyHeaderBlock::HeaderValue::HeaderValue(
+    SpdyHeaderStorage* storage,
+    quiche::QuicheStringPiece key,
+    quiche::QuicheStringPiece initial_value)
     : storage_(storage),
       fragments_({initial_value}),
       pair_({key, {}}),
@@ -70,9 +71,10 @@
 
 SpdyHeaderBlock::HeaderValue::~HeaderValue() = default;
 
-SpdyStringPiece SpdyHeaderBlock::HeaderValue::ConsolidatedValue() const {
+quiche::QuicheStringPiece SpdyHeaderBlock::HeaderValue::ConsolidatedValue()
+    const {
   if (fragments_.empty()) {
-    return SpdyStringPiece();
+    return quiche::QuicheStringPiece();
   }
   if (fragments_.size() > 1) {
     fragments_ = {
@@ -81,12 +83,12 @@
   return fragments_[0];
 }
 
-void SpdyHeaderBlock::HeaderValue::Append(SpdyStringPiece fragment) {
+void SpdyHeaderBlock::HeaderValue::Append(quiche::QuicheStringPiece fragment) {
   size_ += (fragment.size() + separator_size_);
   fragments_.push_back(fragment);
 }
 
-const std::pair<SpdyStringPiece, SpdyStringPiece>&
+const std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>&
 SpdyHeaderBlock::HeaderValue::as_pair() const {
   pair_.second = ConsolidatedValue();
   return pair_;
@@ -101,7 +103,7 @@
 SpdyHeaderBlock::ValueProxy::ValueProxy(
     SpdyHeaderBlock* block,
     SpdyHeaderBlock::MapType::iterator lookup_result,
-    const SpdyStringPiece key,
+    const quiche::QuicheStringPiece key,
     size_t* spdy_header_block_value_size)
     : block_(block),
       lookup_result_(lookup_result),
@@ -140,7 +142,7 @@
 }
 
 SpdyHeaderBlock::ValueProxy& SpdyHeaderBlock::ValueProxy::operator=(
-    SpdyStringPiece value) {
+    quiche::QuicheStringPiece value) {
   *spdy_header_block_value_size_ += value.size();
   SpdyHeaderStorage* storage = &block_->storage_;
   if (lookup_result_ == block_->map_.end()) {
@@ -158,7 +160,8 @@
   return *this;
 }
 
-bool SpdyHeaderBlock::ValueProxy::operator==(SpdyStringPiece value) const {
+bool SpdyHeaderBlock::ValueProxy::operator==(
+    quiche::QuicheStringPiece value) const {
   if (lookup_result_ == block_->map_.end()) {
     return false;
   } else {
@@ -229,7 +232,7 @@
   return output;
 }
 
-void SpdyHeaderBlock::erase(SpdyStringPiece key) {
+void SpdyHeaderBlock::erase(quiche::QuicheStringPiece key) {
   auto iter = map_.find(key);
   if (iter != map_.end()) {
     SPDY_DVLOG(1) << "Erasing header with name: " << key;
@@ -265,13 +268,13 @@
 }
 
 SpdyHeaderBlock::ValueProxy SpdyHeaderBlock::operator[](
-    const SpdyStringPiece key) {
+    const quiche::QuicheStringPiece key) {
   SPDY_DVLOG(2) << "Operator[] saw key: " << key;
-  SpdyStringPiece out_key;
+  quiche::QuicheStringPiece out_key;
   auto iter = map_.find(key);
   if (iter == map_.end()) {
     // We write the key first, to assure that the ValueProxy has a
-    // reference to a valid SpdyStringPiece in its operator=.
+    // reference to a valid QuicheStringPiece in its operator=.
     out_key = WriteKey(key);
     SPDY_DVLOG(2) << "Key written as: " << std::hex
                   << static_cast<const void*>(key.data()) << ", " << std::dec
@@ -282,8 +285,9 @@
   return ValueProxy(this, iter, out_key, &value_size_);
 }
 
-void SpdyHeaderBlock::AppendValueOrAddHeader(const SpdyStringPiece key,
-                                             const SpdyStringPiece value) {
+void SpdyHeaderBlock::AppendValueOrAddHeader(
+    const quiche::QuicheStringPiece key,
+    const quiche::QuicheStringPiece value) {
   value_size_ += value.size();
 
   auto iter = map_.find(key);
@@ -305,14 +309,15 @@
   return SpdyEstimateMemoryUsage(storage_);
 }
 
-void SpdyHeaderBlock::AppendHeader(const SpdyStringPiece key,
-                                   const SpdyStringPiece value) {
+void SpdyHeaderBlock::AppendHeader(const quiche::QuicheStringPiece key,
+                                   const quiche::QuicheStringPiece value) {
   auto backed_key = WriteKey(key);
   map_.emplace(std::make_pair(
       backed_key, HeaderValue(&storage_, backed_key, storage_.Write(value))));
 }
 
-SpdyStringPiece SpdyHeaderBlock::WriteKey(const SpdyStringPiece key) {
+quiche::QuicheStringPiece SpdyHeaderBlock::WriteKey(
+    const quiche::QuicheStringPiece key) {
   key_size_ += key.size();
   return storage_.Write(key);
 }
diff --git a/spdy/core/spdy_header_block.h b/spdy/core/spdy_header_block.h
index 56ee1d5..e164478 100644
--- a/spdy/core/spdy_header_block.h
+++ b/spdy/core/spdy_header_block.h
@@ -13,11 +13,11 @@
 #include <utility>
 #include <vector>
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_header_storage.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_containers.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_macros.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 namespace spdy {
 
@@ -30,9 +30,9 @@
 // names and values. This data structure preserves insertion order.
 //
 // Under the hood, this data structure uses large, contiguous blocks of memory
-// to store names and values. Lookups may be performed with SpdyStringPiece
-// keys, and values are returned as SpdyStringPieces (via ValueProxy, below).
-// Value SpdyStringPieces are valid as long as the SpdyHeaderBlock exists;
+// to store names and values. Lookups may be performed with QuicheStringPiece
+// keys, and values are returned as QuicheStringPieces (via ValueProxy, below).
+// Value QuicheStringPieces are valid as long as the SpdyHeaderBlock exists;
 // allocated memory is never freed until SpdyHeaderBlock's destruction.
 //
 // This implementation does not make much of an effort to minimize wasted space.
@@ -44,8 +44,8 @@
   class SPDY_EXPORT_PRIVATE HeaderValue {
    public:
     HeaderValue(SpdyHeaderStorage* storage,
-                SpdyStringPiece key,
-                SpdyStringPiece initial_value);
+                quiche::QuicheStringPiece key,
+                quiche::QuicheStringPiece initial_value);
 
     // Moves are allowed.
     HeaderValue(HeaderValue&& other);
@@ -60,10 +60,11 @@
     ~HeaderValue();
 
     // Consumes at most |fragment.size()| bytes of memory.
-    void Append(SpdyStringPiece fragment);
+    void Append(quiche::QuicheStringPiece fragment);
 
-    SpdyStringPiece value() const { return as_pair().second; }
-    const std::pair<SpdyStringPiece, SpdyStringPiece>& as_pair() const;
+    quiche::QuicheStringPiece value() const { return as_pair().second; }
+    const std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>&
+    as_pair() const;
 
     // Size estimate including separators. Used when keys are erased from
     // SpdyHeaderBlock.
@@ -72,34 +73,37 @@
    private:
     // May allocate a large contiguous region of memory to hold the concatenated
     // fragments and separators.
-    SpdyStringPiece ConsolidatedValue() const;
+    quiche::QuicheStringPiece ConsolidatedValue() const;
 
     mutable SpdyHeaderStorage* storage_;
-    mutable std::vector<SpdyStringPiece> fragments_;
+    mutable std::vector<quiche::QuicheStringPiece> fragments_;
     // The first element is the key; the second is the consolidated value.
-    mutable std::pair<SpdyStringPiece, SpdyStringPiece> pair_;
+    mutable std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>
+        pair_;
     size_t size_ = 0;
     size_t separator_size_ = 0;
   };
 
-  typedef SpdyLinkedHashMap<SpdyStringPiece,
+  typedef SpdyLinkedHashMap<quiche::QuicheStringPiece,
                             HeaderValue,
-                            SpdyStringPieceHash,
-                            std::equal_to<SpdyStringPiece>>
+                            quiche::QuicheStringPieceHash,
+                            std::equal_to<quiche::QuicheStringPiece>>
       MapType;
 
  public:
-  typedef std::pair<SpdyStringPiece, SpdyStringPiece> value_type;
+  typedef std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>
+      value_type;
 
-  // Provides iteration over a sequence of std::pair<SpdyStringPiece,
-  // SpdyStringPiece>, even though the underlying MapType::value_type is
+  // Provides iteration over a sequence of std::pair<QuicheStringPiece,
+  // QuicheStringPiece>, even though the underlying MapType::value_type is
   // different. Dereferencing the iterator will result in memory allocation for
   // multi-value headers.
   class SPDY_EXPORT_PRIVATE iterator {
    public:
     // The following type definitions fulfill the requirements for iterator
     // implementations.
-    typedef std::pair<SpdyStringPiece, SpdyStringPiece> value_type;
+    typedef std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>
+        value_type;
     typedef value_type& reference;
     typedef value_type* pointer;
     typedef std::forward_iterator_tag iterator_category;
@@ -159,11 +163,13 @@
   const_iterator end() const { return const_iterator(map_.end()); }
   bool empty() const { return map_.empty(); }
   size_t size() const { return map_.size(); }
-  iterator find(SpdyStringPiece key) { return iterator(map_.find(key)); }
-  const_iterator find(SpdyStringPiece key) const {
+  iterator find(quiche::QuicheStringPiece key) {
+    return iterator(map_.find(key));
+  }
+  const_iterator find(quiche::QuicheStringPiece key) const {
     return const_iterator(map_.find(key));
   }
-  void erase(SpdyStringPiece key);
+  void erase(quiche::QuicheStringPiece key);
 
   // Clears both our MapType member and the memory used to hold headers.
   void clear();
@@ -178,8 +184,8 @@
   // existing header value, NUL ("\0") separated unless the key is cookie, in
   // which case the separator is "; ".
   // If there is no such key, a new header with the key and value is added.
-  void AppendValueOrAddHeader(const SpdyStringPiece key,
-                              const SpdyStringPiece value);
+  void AppendValueOrAddHeader(const quiche::QuicheStringPiece key,
+                              const quiche::QuicheStringPiece value);
 
   // This object provides automatic conversions that allow SpdyHeaderBlock to be
   // nearly a drop-in replacement for
@@ -198,10 +204,10 @@
     ValueProxy& operator=(const ValueProxy& other) = delete;
 
     // Assignment modifies the underlying SpdyHeaderBlock.
-    ValueProxy& operator=(SpdyStringPiece value);
+    ValueProxy& operator=(quiche::QuicheStringPiece value);
 
-    // Provides easy comparison against SpdyStringPiece.
-    bool operator==(SpdyStringPiece value) const;
+    // Provides easy comparison against QuicheStringPiece.
+    bool operator==(quiche::QuicheStringPiece value) const;
 
     std::string as_string() const;
 
@@ -211,18 +217,19 @@
 
     ValueProxy(SpdyHeaderBlock* block,
                SpdyHeaderBlock::MapType::iterator lookup_result,
-               const SpdyStringPiece key,
+               const quiche::QuicheStringPiece key,
                size_t* spdy_header_block_value_size);
 
     SpdyHeaderBlock* block_;
     SpdyHeaderBlock::MapType::iterator lookup_result_;
-    SpdyStringPiece key_;
+    quiche::QuicheStringPiece key_;
     size_t* spdy_header_block_value_size_;
     bool valid_;
   };
 
   // Allows either lookup or mutation of the value associated with a key.
-  SPDY_MUST_USE_RESULT ValueProxy operator[](const SpdyStringPiece key);
+  SPDY_MUST_USE_RESULT ValueProxy
+  operator[](const quiche::QuicheStringPiece key);
 
   // Returns the estimate of dynamically allocated memory in bytes.
   size_t EstimateMemoryUsage() const;
@@ -232,11 +239,12 @@
  private:
   friend class test::SpdyHeaderBlockPeer;
 
-  void AppendHeader(const SpdyStringPiece key, const SpdyStringPiece value);
-  SpdyStringPiece WriteKey(const SpdyStringPiece key);
+  void AppendHeader(const quiche::QuicheStringPiece key,
+                    const quiche::QuicheStringPiece value);
+  quiche::QuicheStringPiece WriteKey(const quiche::QuicheStringPiece key);
   size_t bytes_allocated() const;
 
-  // SpdyStringPieces held by |map_| point to memory owned by |storage_|.
+  // QuicheStringPieces held by |map_| point to memory owned by |storage_|.
   MapType map_;
   SpdyHeaderStorage storage_;
 
diff --git a/spdy/core/spdy_header_block_test.cc b/spdy/core/spdy_header_block_test.cc
index 7695aad..aad264c 100644
--- a/spdy/core/spdy_header_block_test.cc
+++ b/spdy/core/spdy_header_block_test.cc
@@ -17,11 +17,14 @@
 
 class ValueProxyPeer {
  public:
-  static SpdyStringPiece key(SpdyHeaderBlock::ValueProxy* p) { return p->key_; }
+  static quiche::QuicheStringPiece key(SpdyHeaderBlock::ValueProxy* p) {
+    return p->key_;
+  }
 };
 
-std::pair<SpdyStringPiece, SpdyStringPiece> Pair(SpdyStringPiece k,
-                                                 SpdyStringPiece v) {
+std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece> Pair(
+    quiche::QuicheStringPiece k,
+    quiche::QuicheStringPiece v) {
   return std::make_pair(k, v);
 }
 
@@ -39,19 +42,20 @@
 
 TEST(SpdyHeaderBlockTest, KeyMemoryReclaimedOnLookup) {
   SpdyHeaderBlock block;
-  SpdyStringPiece copied_key1;
+  quiche::QuicheStringPiece copied_key1;
   {
     auto proxy1 = block["some key name"];
     copied_key1 = ValueProxyPeer::key(&proxy1);
   }
-  SpdyStringPiece copied_key2;
+  quiche::QuicheStringPiece copied_key2;
   {
     auto proxy2 = block["some other key name"];
     copied_key2 = ValueProxyPeer::key(&proxy2);
   }
   // Because proxy1 was never used to modify the block, the memory used for the
   // key could be reclaimed and used for the second call to operator[].
-  // Therefore, we expect the pointers of the two SpdyStringPieces to be equal.
+  // Therefore, we expect the pointers of the two QuicheStringPieces to be
+  // equal.
   EXPECT_EQ(copied_key1.data(), copied_key2.data());
 
   {
@@ -189,25 +193,25 @@
   EXPECT_EQ("singleton", block["h4"]);
 }
 
-TEST(SpdyHeaderBlockTest, CompareValueToSpdyStringPiece) {
+TEST(SpdyHeaderBlockTest, CompareValueToStringPiece) {
   SpdyHeaderBlock block;
   block["foo"] = "foo";
   block.AppendValueOrAddHeader("foo", "bar");
   const auto& val = block["foo"];
   const char expected[] = "foo\0bar";
-  EXPECT_TRUE(SpdyStringPiece(expected, 7) == val);
-  EXPECT_TRUE(val == SpdyStringPiece(expected, 7));
-  EXPECT_FALSE(SpdyStringPiece(expected, 3) == val);
-  EXPECT_FALSE(val == SpdyStringPiece(expected, 3));
+  EXPECT_TRUE(quiche::QuicheStringPiece(expected, 7) == val);
+  EXPECT_TRUE(val == quiche::QuicheStringPiece(expected, 7));
+  EXPECT_FALSE(quiche::QuicheStringPiece(expected, 3) == val);
+  EXPECT_FALSE(val == quiche::QuicheStringPiece(expected, 3));
   const char not_expected[] = "foo\0barextra";
-  EXPECT_FALSE(SpdyStringPiece(not_expected, 12) == val);
-  EXPECT_FALSE(val == SpdyStringPiece(not_expected, 12));
+  EXPECT_FALSE(quiche::QuicheStringPiece(not_expected, 12) == val);
+  EXPECT_FALSE(val == quiche::QuicheStringPiece(not_expected, 12));
 
   const auto& val2 = block["foo2"];
-  EXPECT_FALSE(SpdyStringPiece(expected, 7) == val2);
-  EXPECT_FALSE(val2 == SpdyStringPiece(expected, 7));
-  EXPECT_FALSE(SpdyStringPiece("") == val2);
-  EXPECT_FALSE(val2 == SpdyStringPiece(""));
+  EXPECT_FALSE(quiche::QuicheStringPiece(expected, 7) == val2);
+  EXPECT_FALSE(val2 == quiche::QuicheStringPiece(expected, 7));
+  EXPECT_FALSE(quiche::QuicheStringPiece("") == val2);
+  EXPECT_FALSE(val2 == quiche::QuicheStringPiece(""));
 }
 
 // This test demonstrates that the SpdyHeaderBlock data structure does not place
diff --git a/spdy/core/spdy_header_storage.cc b/spdy/core/spdy_header_storage.cc
index e84b3be..76ba378 100644
--- a/spdy/core/spdy_header_storage.cc
+++ b/spdy/core/spdy_header_storage.cc
@@ -12,19 +12,20 @@
 
 SpdyHeaderStorage::SpdyHeaderStorage() : arena_(kDefaultStorageBlockSize) {}
 
-SpdyStringPiece SpdyHeaderStorage::Write(const SpdyStringPiece s) {
-  return SpdyStringPiece(arena_.Memdup(s.data(), s.size()), s.size());
+quiche::QuicheStringPiece SpdyHeaderStorage::Write(
+    const quiche::QuicheStringPiece s) {
+  return quiche::QuicheStringPiece(arena_.Memdup(s.data(), s.size()), s.size());
 }
 
-void SpdyHeaderStorage::Rewind(const SpdyStringPiece s) {
+void SpdyHeaderStorage::Rewind(const quiche::QuicheStringPiece s) {
   arena_.Free(const_cast<char*>(s.data()), s.size());
 }
 
-SpdyStringPiece SpdyHeaderStorage::WriteFragments(
-    const std::vector<SpdyStringPiece>& fragments,
-    SpdyStringPiece separator) {
+quiche::QuicheStringPiece SpdyHeaderStorage::WriteFragments(
+    const std::vector<quiche::QuicheStringPiece>& fragments,
+    quiche::QuicheStringPiece separator) {
   if (fragments.empty()) {
-    return SpdyStringPiece();
+    return quiche::QuicheStringPiece();
   }
   size_t total_size = separator.size() * (fragments.size() - 1);
   for (const auto fragment : fragments) {
@@ -33,12 +34,12 @@
   char* dst = arena_.Alloc(total_size);
   size_t written = Join(dst, fragments, separator);
   DCHECK_EQ(written, total_size);
-  return SpdyStringPiece(dst, total_size);
+  return quiche::QuicheStringPiece(dst, total_size);
 }
 
 size_t Join(char* dst,
-            const std::vector<SpdyStringPiece>& fragments,
-            SpdyStringPiece separator) {
+            const std::vector<quiche::QuicheStringPiece>& fragments,
+            quiche::QuicheStringPiece separator) {
   if (fragments.empty()) {
     return 0;
   }
diff --git a/spdy/core/spdy_header_storage.h b/spdy/core/spdy_header_storage.h
index fc559ec..af1775a 100644
--- a/spdy/core/spdy_header_storage.h
+++ b/spdy/core/spdy_header_storage.h
@@ -1,15 +1,15 @@
 #ifndef QUICHE_SPDY_CORE_SPDY_HEADER_STORAGE_H_
 #define QUICHE_SPDY_CORE_SPDY_HEADER_STORAGE_H_
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_simple_arena.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 namespace spdy {
 
-// This class provides a backing store for SpdyStringPieces. It previously used
-// custom allocation logic, but now uses an UnsafeArena instead. It has the
-// property that SpdyStringPieces that refer to data in SpdyHeaderStorage are
+// This class provides a backing store for QuicheStringPieces. It previously
+// used custom allocation logic, but now uses an UnsafeArena instead. It has the
+// property that QuicheStringPieces that refer to data in SpdyHeaderStorage are
 // never invalidated until the SpdyHeaderStorage is deleted or Clear() is
 // called.
 //
@@ -26,19 +26,20 @@
   SpdyHeaderStorage(SpdyHeaderStorage&& other) = default;
   SpdyHeaderStorage& operator=(SpdyHeaderStorage&& other) = default;
 
-  SpdyStringPiece Write(SpdyStringPiece s);
+  quiche::QuicheStringPiece Write(quiche::QuicheStringPiece s);
 
   // If |s| points to the most recent allocation from arena_, the arena will
   // reclaim the memory. Otherwise, this method is a no-op.
-  void Rewind(SpdyStringPiece s);
+  void Rewind(quiche::QuicheStringPiece s);
 
   void Clear() { arena_.Reset(); }
 
   // Given a list of fragments and a separator, writes the fragments joined by
-  // the separator to a contiguous region of memory. Returns a SpdyStringPiece
+  // the separator to a contiguous region of memory. Returns a QuicheStringPiece
   // pointing to the region of memory.
-  SpdyStringPiece WriteFragments(const std::vector<SpdyStringPiece>& fragments,
-                                 SpdyStringPiece separator);
+  quiche::QuicheStringPiece WriteFragments(
+      const std::vector<quiche::QuicheStringPiece>& fragments,
+      quiche::QuicheStringPiece separator);
 
   size_t bytes_allocated() const { return arena_.status().bytes_allocated(); }
 
@@ -50,9 +51,10 @@
 
 // Writes |fragments| to |dst|, joined by |separator|. |dst| must be large
 // enough to hold the result. Returns the number of bytes written.
-SPDY_EXPORT_PRIVATE size_t Join(char* dst,
-                                const std::vector<SpdyStringPiece>& fragments,
-                                SpdyStringPiece separator);
+SPDY_EXPORT_PRIVATE size_t
+Join(char* dst,
+     const std::vector<quiche::QuicheStringPiece>& fragments,
+     quiche::QuicheStringPiece separator);
 
 }  // namespace spdy
 
diff --git a/spdy/core/spdy_header_storage_test.cc b/spdy/core/spdy_header_storage_test.cc
index 6f82013..2abd762 100644
--- a/spdy/core/spdy_header_storage_test.cc
+++ b/spdy/core/spdy_header_storage_test.cc
@@ -6,29 +6,29 @@
 namespace test {
 
 TEST(JoinTest, JoinEmpty) {
-  std::vector<SpdyStringPiece> empty;
-  SpdyStringPiece separator = ", ";
+  std::vector<quiche::QuicheStringPiece> empty;
+  quiche::QuicheStringPiece separator = ", ";
   char buf[10] = "";
   size_t written = Join(buf, empty, separator);
   EXPECT_EQ(0u, written);
 }
 
 TEST(JoinTest, JoinOne) {
-  std::vector<SpdyStringPiece> v = {"one"};
-  SpdyStringPiece separator = ", ";
+  std::vector<quiche::QuicheStringPiece> v = {"one"};
+  quiche::QuicheStringPiece separator = ", ";
   char buf[15];
   size_t written = Join(buf, v, separator);
   EXPECT_EQ(3u, written);
-  EXPECT_EQ("one", SpdyStringPiece(buf, written));
+  EXPECT_EQ("one", quiche::QuicheStringPiece(buf, written));
 }
 
 TEST(JoinTest, JoinMultiple) {
-  std::vector<SpdyStringPiece> v = {"one", "two", "three"};
-  SpdyStringPiece separator = ", ";
+  std::vector<quiche::QuicheStringPiece> v = {"one", "two", "three"};
+  quiche::QuicheStringPiece separator = ", ";
   char buf[15];
   size_t written = Join(buf, v, separator);
   EXPECT_EQ(15u, written);
-  EXPECT_EQ("one, two, three", SpdyStringPiece(buf, written));
+  EXPECT_EQ("one, two, three", quiche::QuicheStringPiece(buf, written));
 }
 
 }  // namespace test
diff --git a/spdy/core/spdy_headers_handler_interface.h b/spdy/core/spdy_headers_handler_interface.h
index ce6c1b6..cff4922 100644
--- a/spdy/core/spdy_headers_handler_interface.h
+++ b/spdy/core/spdy_headers_handler_interface.h
@@ -7,8 +7,8 @@
 
 #include <stddef.h>
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 namespace spdy {
 
@@ -25,7 +25,8 @@
 
   // A callback method which notifies on a header key value pair. Multiple
   // values for a given key will be emitted as multiple calls to OnHeader.
-  virtual void OnHeader(SpdyStringPiece key, SpdyStringPiece value) = 0;
+  virtual void OnHeader(quiche::QuicheStringPiece key,
+                        quiche::QuicheStringPiece value) = 0;
 
   // A callback method which notifies when the parser finishes handling a
   // header block (i.e. the containing frame has the END_HEADERS flag set).
diff --git a/spdy/core/spdy_no_op_visitor.h b/spdy/core/spdy_no_op_visitor.h
index 6e4a48a..a6f4438 100644
--- a/spdy/core/spdy_no_op_visitor.h
+++ b/spdy/core/spdy_no_op_visitor.h
@@ -11,9 +11,9 @@
 
 #include <cstdint>
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/http2_frame_decoder_adapter.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 namespace spdy {
 namespace test {
@@ -61,7 +61,7 @@
                      bool /*end*/) override {}
   void OnContinuation(SpdyStreamId /*stream_id*/, bool /*end*/) override {}
   void OnAltSvc(SpdyStreamId /*stream_id*/,
-                SpdyStringPiece /*origin*/,
+                quiche::QuicheStringPiece /*origin*/,
                 const SpdyAltSvcWireFormat::AlternativeServiceVector&
                 /*altsvc_vector*/) override {}
   void OnPriority(SpdyStreamId /*stream_id*/,
@@ -82,7 +82,8 @@
 
   // SpdyHeadersHandlerInterface methods:
   void OnHeaderBlockStart() override {}
-  void OnHeader(SpdyStringPiece /*key*/, SpdyStringPiece /*value*/) override {}
+  void OnHeader(quiche::QuicheStringPiece /*key*/,
+                quiche::QuicheStringPiece /*value*/) override {}
   void OnHeaderBlockEnd(size_t /* uncompressed_header_bytes */,
                         size_t /* compressed_header_bytes */) override {}
 };
diff --git a/spdy/core/spdy_pinnable_buffer_piece.h b/spdy/core/spdy_pinnable_buffer_piece.h
index 3032ad7..469c0d3 100644
--- a/spdy/core/spdy_pinnable_buffer_piece.h
+++ b/spdy/core/spdy_pinnable_buffer_piece.h
@@ -9,8 +9,8 @@
 
 #include <memory>
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 namespace spdy {
 
@@ -27,8 +27,8 @@
 
   const char* buffer() const { return buffer_; }
 
-  explicit operator SpdyStringPiece() const {
-    return SpdyStringPiece(buffer_, length_);
+  explicit operator quiche::QuicheStringPiece() const {
+    return quiche::QuicheStringPiece(buffer_, length_);
   }
 
   // Allocates and copies the buffer to internal storage.
diff --git a/spdy/core/spdy_pinnable_buffer_piece_test.cc b/spdy/core/spdy_pinnable_buffer_piece_test.cc
index 9c7f138..f625425 100644
--- a/spdy/core/spdy_pinnable_buffer_piece_test.cc
+++ b/spdy/core/spdy_pinnable_buffer_piece_test.cc
@@ -31,14 +31,16 @@
   EXPECT_TRUE(reader.ReadN(6, &piece));
 
   // Piece points to underlying prefix storage.
-  EXPECT_EQ(SpdyStringPiece("foobar"), SpdyStringPiece(piece));
+  EXPECT_EQ(quiche::QuicheStringPiece("foobar"),
+            quiche::QuicheStringPiece(piece));
   EXPECT_FALSE(piece.IsPinned());
   EXPECT_EQ(prefix_.data(), piece.buffer());
 
   piece.Pin();
 
   // Piece now points to allocated storage.
-  EXPECT_EQ(SpdyStringPiece("foobar"), SpdyStringPiece(piece));
+  EXPECT_EQ(quiche::QuicheStringPiece("foobar"),
+            quiche::QuicheStringPiece(piece));
   EXPECT_TRUE(piece.IsPinned());
   EXPECT_NE(prefix_.data(), piece.buffer());
 
@@ -56,22 +58,24 @@
 
   piece1.Pin();
 
-  EXPECT_EQ(SpdyStringPiece("foob"), SpdyStringPiece(piece1));
+  EXPECT_EQ(quiche::QuicheStringPiece("foob"),
+            quiche::QuicheStringPiece(piece1));
   EXPECT_TRUE(piece1.IsPinned());
-  EXPECT_EQ(SpdyStringPiece("ar"), SpdyStringPiece(piece2));
+  EXPECT_EQ(quiche::QuicheStringPiece("ar"), quiche::QuicheStringPiece(piece2));
   EXPECT_FALSE(piece2.IsPinned());
 
   piece1.Swap(&piece2);
 
-  EXPECT_EQ(SpdyStringPiece("ar"), SpdyStringPiece(piece1));
+  EXPECT_EQ(quiche::QuicheStringPiece("ar"), quiche::QuicheStringPiece(piece1));
   EXPECT_FALSE(piece1.IsPinned());
-  EXPECT_EQ(SpdyStringPiece("foob"), SpdyStringPiece(piece2));
+  EXPECT_EQ(quiche::QuicheStringPiece("foob"),
+            quiche::QuicheStringPiece(piece2));
   EXPECT_TRUE(piece2.IsPinned());
 
   SpdyPinnableBufferPiece empty;
   piece2.Swap(&empty);
 
-  EXPECT_EQ(SpdyStringPiece(""), SpdyStringPiece(piece2));
+  EXPECT_EQ(quiche::QuicheStringPiece(""), quiche::QuicheStringPiece(piece2));
   EXPECT_FALSE(piece2.IsPinned());
 }
 
diff --git a/spdy/core/spdy_prefixed_buffer_reader_test.cc b/spdy/core/spdy_prefixed_buffer_reader_test.cc
index a0f9257..273e001 100644
--- a/spdy/core/spdy_prefixed_buffer_reader_test.cc
+++ b/spdy/core/spdy_prefixed_buffer_reader_test.cc
@@ -6,7 +6,7 @@
 
 #include <string>
 
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_test.h"
 
 namespace spdy {
@@ -46,7 +46,8 @@
   EXPECT_FALSE(reader.ReadN(10, &piece));  // Not enough buffer.
   EXPECT_TRUE(reader.ReadN(6, &piece));
   EXPECT_FALSE(piece.IsPinned());
-  EXPECT_EQ(SpdyStringPiece("foobar"), SpdyStringPiece(piece));
+  EXPECT_EQ(quiche::QuicheStringPiece("foobar"),
+            quiche::QuicheStringPiece(piece));
   EXPECT_EQ(0u, reader.Available());
 }
 
@@ -69,7 +70,8 @@
   EXPECT_FALSE(reader.ReadN(10, &piece));  // Not enough buffer.
   EXPECT_TRUE(reader.ReadN(6, &piece));
   EXPECT_FALSE(piece.IsPinned());
-  EXPECT_EQ(SpdyStringPiece("foobar"), SpdyStringPiece(piece));
+  EXPECT_EQ(quiche::QuicheStringPiece("foobar"),
+            quiche::QuicheStringPiece(piece));
   EXPECT_EQ(0u, reader.Available());
 }
 
@@ -92,7 +94,8 @@
   EXPECT_FALSE(reader.ReadN(10, &piece));  // Not enough buffer.
   EXPECT_TRUE(reader.ReadN(6, &piece));
   EXPECT_TRUE(piece.IsPinned());
-  EXPECT_EQ(SpdyStringPiece("foobar"), SpdyStringPiece(piece));
+  EXPECT_EQ(quiche::QuicheStringPiece("foobar"),
+            quiche::QuicheStringPiece(piece));
   EXPECT_EQ(0u, reader.Available());
 }
 
@@ -112,12 +115,12 @@
   EXPECT_EQ(6u, reader.Available());
 
   EXPECT_TRUE(reader.ReadN(3, &piece));
-  EXPECT_EQ(SpdyStringPiece("fhi"), SpdyStringPiece(piece));
+  EXPECT_EQ(quiche::QuicheStringPiece("fhi"), quiche::QuicheStringPiece(piece));
   EXPECT_TRUE(piece.IsPinned());
   EXPECT_EQ(3u, reader.Available());
 
   EXPECT_TRUE(reader.ReadN(2, &piece));
-  EXPECT_EQ(SpdyStringPiece("jk"), SpdyStringPiece(piece));
+  EXPECT_EQ(quiche::QuicheStringPiece("jk"), quiche::QuicheStringPiece(piece));
   EXPECT_FALSE(piece.IsPinned());
   EXPECT_EQ(1u, reader.Available());
 
diff --git a/spdy/core/spdy_protocol.cc b/spdy/core/spdy_protocol.cc
index 0ab6737..4a59d55 100644
--- a/spdy/core/spdy_protocol.cc
+++ b/spdy/core/spdy_protocol.cc
@@ -280,7 +280,7 @@
 
 SpdyFrameWithHeaderBlockIR::~SpdyFrameWithHeaderBlockIR() = default;
 
-SpdyDataIR::SpdyDataIR(SpdyStreamId stream_id, SpdyStringPiece data)
+SpdyDataIR::SpdyDataIR(SpdyStreamId stream_id, quiche::QuicheStringPiece data)
     : SpdyFrameWithFinIR(stream_id),
       data_(nullptr),
       data_len_(0),
@@ -290,7 +290,7 @@
 }
 
 SpdyDataIR::SpdyDataIR(SpdyStreamId stream_id, const char* data)
-    : SpdyDataIR(stream_id, SpdyStringPiece(data)) {}
+    : SpdyDataIR(stream_id, quiche::QuicheStringPiece(data)) {}
 
 SpdyDataIR::SpdyDataIR(SpdyStreamId stream_id, std::string data)
     : SpdyFrameWithFinIR(stream_id),
@@ -376,7 +376,7 @@
 
 SpdyGoAwayIR::SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
                            SpdyErrorCode error_code,
-                           SpdyStringPiece description)
+                           quiche::QuicheStringPiece description)
     : description_(description) {
   set_last_good_stream_id(last_good_stream_id);
   set_error_code(error_code);
@@ -387,7 +387,7 @@
                            const char* description)
     : SpdyGoAwayIR(last_good_stream_id,
                    error_code,
-                   SpdyStringPiece(description)) {}
+                   quiche::QuicheStringPiece(description)) {}
 
 SpdyGoAwayIR::SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
                            SpdyErrorCode error_code,
diff --git a/spdy/core/spdy_protocol.h b/spdy/core/spdy_protocol.h
index cb6906c..5d96497 100644
--- a/spdy/core/spdy_protocol.h
+++ b/spdy/core/spdy_protocol.h
@@ -19,13 +19,13 @@
 #include <string>
 #include <utility>
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_alt_svc_wire_format.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_bitmasks.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_header_block.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_bug_tracker.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_export.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_logging.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 namespace spdy {
 
@@ -499,7 +499,8 @@
     // Deep copy.
     header_block_ = std::move(header_block);
   }
-  void SetHeader(SpdyStringPiece name, SpdyStringPiece value) {
+  void SetHeader(quiche::QuicheStringPiece name,
+                 quiche::QuicheStringPiece value) {
     header_block_[name] = value;
   }
 
@@ -517,7 +518,7 @@
 class SPDY_EXPORT_PRIVATE SpdyDataIR : public SpdyFrameWithFinIR {
  public:
   // Performs a deep copy on data.
-  SpdyDataIR(SpdyStreamId stream_id, SpdyStringPiece data);
+  SpdyDataIR(SpdyStreamId stream_id, quiche::QuicheStringPiece data);
 
   // Performs a deep copy on data.
   SpdyDataIR(SpdyStreamId stream_id, const char* data);
@@ -548,14 +549,14 @@
   }
 
   // Deep-copy of data (keep private copy).
-  void SetDataDeep(SpdyStringPiece data) {
+  void SetDataDeep(quiche::QuicheStringPiece data) {
     data_store_ = std::make_unique<std::string>(data.data(), data.size());
     data_ = data_store_->data();
     data_len_ = data.size();
   }
 
   // Shallow-copy of data (do not keep private copy).
-  void SetDataShallow(SpdyStringPiece data) {
+  void SetDataShallow(quiche::QuicheStringPiece data) {
     data_store_.reset();
     data_ = data.data();
     data_len_ = data.size();
@@ -661,7 +662,7 @@
   // this SpdyGoAwayIR.
   SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
                SpdyErrorCode error_code,
-               SpdyStringPiece description);
+               quiche::QuicheStringPiece description);
 
   // References description, doesn't copy it, so description must outlast
   // this SpdyGoAwayIR.
@@ -690,7 +691,7 @@
     error_code_ = error_code;
   }
 
-  const SpdyStringPiece& description() const { return description_; }
+  const quiche::QuicheStringPiece& description() const { return description_; }
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
@@ -702,7 +703,7 @@
   SpdyStreamId last_good_stream_id_;
   SpdyErrorCode error_code_;
   const std::string description_store_;
-  const SpdyStringPiece description_;
+  const quiche::QuicheStringPiece description_;
 };
 
 class SPDY_EXPORT_PRIVATE SpdyHeadersIR : public SpdyFrameWithHeaderBlockIR {
diff --git a/spdy/core/spdy_protocol_test.cc b/spdy/core/spdy_protocol_test.cc
index 542d23d..af6df35 100644
--- a/spdy/core/spdy_protocol_test.cc
+++ b/spdy/core/spdy_protocol_test.cc
@@ -226,8 +226,8 @@
 
 TEST(SpdyDataIRTest, Construct) {
   // Confirm that it makes a string of zero length from a
-  // SpdyStringPiece(nullptr).
-  SpdyStringPiece s1;
+  // QuicheStringPiece(nullptr).
+  quiche::QuicheStringPiece s1;
   SpdyDataIR d1(/* stream_id = */ 1, s1);
   EXPECT_EQ(0u, d1.data_len());
   EXPECT_NE(nullptr, d1.data());
@@ -235,8 +235,8 @@
   // Confirms makes a copy of char array.
   const char s2[] = "something";
   SpdyDataIR d2(/* stream_id = */ 2, s2);
-  EXPECT_EQ(SpdyStringPiece(d2.data(), d2.data_len()), s2);
-  EXPECT_NE(SpdyStringPiece(d1.data(), d1.data_len()), s2);
+  EXPECT_EQ(quiche::QuicheStringPiece(d2.data(), d2.data_len()), s2);
+  EXPECT_NE(quiche::QuicheStringPiece(d1.data(), d1.data_len()), s2);
   EXPECT_EQ((int)d1.data_len(), d1.flow_control_window_consumed());
 
   // Confirm copies a const string.
@@ -249,18 +249,20 @@
   std::string bar = "bar";
   SpdyDataIR d4(/* stream_id = */ 4, bar);
   EXPECT_EQ("bar", bar);
-  EXPECT_EQ("bar", SpdyStringPiece(d4.data(), d4.data_len()));
+  EXPECT_EQ("bar", quiche::QuicheStringPiece(d4.data(), d4.data_len()));
 
   // Confirm moves an rvalue reference. Note that the test string "baz" is too
   // short to trigger the move optimization, and instead a copy occurs.
   std::string baz = "the quick brown fox";
   SpdyDataIR d5(/* stream_id = */ 5, std::move(baz));
   EXPECT_EQ("", baz);
-  EXPECT_EQ(SpdyStringPiece(d5.data(), d5.data_len()), "the quick brown fox");
+  EXPECT_EQ(quiche::QuicheStringPiece(d5.data(), d5.data_len()),
+            "the quick brown fox");
 
   // Confirms makes a copy of string literal.
   SpdyDataIR d7(/* stream_id = */ 7, "something else");
-  EXPECT_EQ(SpdyStringPiece(d7.data(), d7.data_len()), "something else");
+  EXPECT_EQ(quiche::QuicheStringPiece(d7.data(), d7.data_len()),
+            "something else");
 
   SpdyDataIR d8(/* stream_id = */ 8, "shawarma");
   d8.set_padding_len(20);
diff --git a/spdy/core/spdy_protocol_test_utils.cc b/spdy/core/spdy_protocol_test_utils.cc
index b8ffb4a..7390f50 100644
--- a/spdy/core/spdy_protocol_test_utils.cc
+++ b/spdy/core/spdy_protocol_test_utils.cc
@@ -6,7 +6,7 @@
 
 #include <cstdint>
 
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace spdy {
 namespace test {
@@ -47,8 +47,8 @@
   if (expected.data() == nullptr) {
     VERIFY_EQ(nullptr, actual.data());
   } else {
-    VERIFY_EQ(SpdyStringPiece(expected.data(), expected.data_len()),
-              SpdyStringPiece(actual.data(), actual.data_len()));
+    VERIFY_EQ(quiche::QuicheStringPiece(expected.data(), expected.data_len()),
+              quiche::QuicheStringPiece(actual.data(), actual.data_len()));
   }
   VERIFY_SUCCESS(VerifySpdyFrameWithPaddingIREquals(expected, actual));
   return ::testing::AssertionSuccess();
diff --git a/spdy/core/spdy_simple_arena_test.cc b/spdy/core/spdy_simple_arena_test.cc
index 35c84f1..d20bdff 100644
--- a/spdy/core/spdy_simple_arena_test.cc
+++ b/spdy/core/spdy_simple_arena_test.cc
@@ -7,7 +7,7 @@
 #include <string>
 #include <vector>
 
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_test.h"
 
 namespace spdy {
@@ -27,7 +27,7 @@
   char* c = arena.Memdup(kTestString, length);
   EXPECT_NE(nullptr, c);
   EXPECT_NE(c, kTestString);
-  EXPECT_EQ(SpdyStringPiece(c, length), kTestString);
+  EXPECT_EQ(quiche::QuicheStringPiece(c, length), kTestString);
 }
 
 TEST(SpdySimpleArenaTest, MemdupLargeString) {
@@ -36,7 +36,7 @@
   char* c = arena.Memdup(kTestString, length);
   EXPECT_NE(nullptr, c);
   EXPECT_NE(c, kTestString);
-  EXPECT_EQ(SpdyStringPiece(c, length), kTestString);
+  EXPECT_EQ(quiche::QuicheStringPiece(c, length), kTestString);
 }
 
 TEST(SpdySimpleArenaTest, MultipleBlocks) {
@@ -44,9 +44,9 @@
   std::vector<std::string> strings = {
       "One decently long string.", "Another string.",
       "A third string that will surely go in a different block."};
-  std::vector<SpdyStringPiece> copies;
+  std::vector<quiche::QuicheStringPiece> copies;
   for (const std::string& s : strings) {
-    SpdyStringPiece sp(arena.Memdup(s.data(), s.size()), s.size());
+    quiche::QuicheStringPiece sp(arena.Memdup(s.data(), s.size()), s.size());
     copies.push_back(sp);
   }
   EXPECT_EQ(strings.size(), copies.size());
@@ -63,7 +63,7 @@
   c = arena.Memdup(kTestString, length);
   EXPECT_NE(nullptr, c);
   EXPECT_NE(c, kTestString);
-  EXPECT_EQ(SpdyStringPiece(c, length), kTestString);
+  EXPECT_EQ(quiche::QuicheStringPiece(c, length), kTestString);
 }
 
 TEST(SpdySimpleArenaTest, Free) {
@@ -102,7 +102,7 @@
   EXPECT_EQ(c1 + length, c2);
   EXPECT_EQ(c2 + 2 * length, c3);
   EXPECT_EQ(c3 + 3 * length, c4);
-  EXPECT_EQ(SpdyStringPiece(c4, length), kTestString);
+  EXPECT_EQ(quiche::QuicheStringPiece(c4, length), kTestString);
 }
 
 TEST(SpdySimpleArenaTest, Realloc) {
@@ -113,28 +113,28 @@
   char* c2 = arena.Realloc(c1, length, 2 * length);
   EXPECT_TRUE(c1);
   EXPECT_EQ(c1, c2);
-  EXPECT_EQ(SpdyStringPiece(c1, length), kTestString);
+  EXPECT_EQ(quiche::QuicheStringPiece(c1, length), kTestString);
   // Multiple reallocs.
   char* c3 = arena.Memdup(kTestString, length);
   EXPECT_EQ(c2 + 2 * length, c3);
-  EXPECT_EQ(SpdyStringPiece(c3, length), kTestString);
+  EXPECT_EQ(quiche::QuicheStringPiece(c3, length), kTestString);
   char* c4 = arena.Realloc(c3, length, 2 * length);
   EXPECT_EQ(c3, c4);
-  EXPECT_EQ(SpdyStringPiece(c4, length), kTestString);
+  EXPECT_EQ(quiche::QuicheStringPiece(c4, length), kTestString);
   char* c5 = arena.Realloc(c4, 2 * length, 3 * length);
   EXPECT_EQ(c4, c5);
-  EXPECT_EQ(SpdyStringPiece(c5, length), kTestString);
+  EXPECT_EQ(quiche::QuicheStringPiece(c5, length), kTestString);
   char* c6 = arena.Memdup(kTestString, length);
   EXPECT_EQ(c5 + 3 * length, c6);
-  EXPECT_EQ(SpdyStringPiece(c6, length), kTestString);
+  EXPECT_EQ(quiche::QuicheStringPiece(c6, length), kTestString);
   // Realloc that does not fit in the remainder of the first block.
   char* c7 = arena.Realloc(c6, length, kDefaultBlockSize);
-  EXPECT_EQ(SpdyStringPiece(c7, length), kTestString);
+  EXPECT_EQ(quiche::QuicheStringPiece(c7, length), kTestString);
   arena.Free(c7, kDefaultBlockSize);
   char* c8 = arena.Memdup(kTestString, length);
   EXPECT_NE(c6, c7);
   EXPECT_EQ(c7, c8);
-  EXPECT_EQ(SpdyStringPiece(c8, length), kTestString);
+  EXPECT_EQ(quiche::QuicheStringPiece(c8, length), kTestString);
 }
 
 }  // namespace
diff --git a/spdy/core/spdy_test_utils.cc b/spdy/core/spdy_test_utils.cc
index f248c86..860e2e5 100644
--- a/spdy/core/spdy_test_utils.cc
+++ b/spdy/core/spdy_test_utils.cc
@@ -104,7 +104,8 @@
   block_.clear();
 }
 
-void TestHeadersHandler::OnHeader(SpdyStringPiece name, SpdyStringPiece value) {
+void TestHeadersHandler::OnHeader(quiche::QuicheStringPiece name,
+                                  quiche::QuicheStringPiece value) {
   block_.AppendValueOrAddHeader(name, value);
 }
 
diff --git a/spdy/core/spdy_test_utils.h b/spdy/core/spdy_test_utils.h
index ff08a50..b3c3aa5 100644
--- a/spdy/core/spdy_test_utils.h
+++ b/spdy/core/spdy_test_utils.h
@@ -9,15 +9,15 @@
 #include <cstdint>
 #include <string>
 
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_header_block.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_headers_handler_interface.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_bug_tracker.h"
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 
 namespace spdy {
 
-inline bool operator==(SpdyStringPiece x,
+inline bool operator==(quiche::QuicheStringPiece x,
                        const SpdyHeaderBlock::ValueProxy& y) {
   return y.operator==(x);
 }
@@ -49,7 +49,8 @@
 
   void OnHeaderBlockStart() override;
 
-  void OnHeader(SpdyStringPiece name, SpdyStringPiece value) override;
+  void OnHeader(quiche::QuicheStringPiece name,
+                quiche::QuicheStringPiece value) override;
 
   void OnHeaderBlockEnd(size_t header_bytes_parsed,
                         size_t compressed_header_bytes_parsed) override;
diff --git a/spdy/platform/api/spdy_containers.h b/spdy/platform/api/spdy_containers.h
index 1449c3c..a1a00e6 100644
--- a/spdy/platform/api/spdy_containers.h
+++ b/spdy/platform/api/spdy_containers.h
@@ -5,7 +5,6 @@
 #ifndef QUICHE_SPDY_PLATFORM_API_SPDY_CONTAINERS_H_
 #define QUICHE_SPDY_PLATFORM_API_SPDY_CONTAINERS_H_
 
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
 #include "net/spdy/platform/impl/spdy_containers_impl.h"
 
 namespace spdy {
@@ -31,12 +30,6 @@
 template <typename T, size_t N, typename A = std::allocator<T>>
 using SpdyInlinedVector = SpdyInlinedVectorImpl<T, N, A>;
 
-using SpdyStringPieceHash = SpdyStringPieceHashImpl;
-
-inline size_t SpdyHashStringPair(SpdyStringPiece a, SpdyStringPiece b) {
-  return SpdyHashStringPairImpl(a, b);
-}
-
 // Used for maps that are typically small, then it is faster than (for example)
 // hash_map which is optimized for large data sets. SpdySmallMap upgrades itself
 // automatically to a SpdySmallMapImpl-specified map when it runs out of space.
diff --git a/spdy/platform/api/spdy_string_piece.h b/spdy/platform/api/spdy_string_piece.h
deleted file mode 100644
index 37eea70..0000000
--- a/spdy/platform/api/spdy_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_SPDY_PLATFORM_API_SPDY_STRING_PIECE_H_
-#define QUICHE_SPDY_PLATFORM_API_SPDY_STRING_PIECE_H_
-
-#include "net/spdy/platform/impl/spdy_string_piece_impl.h"
-
-namespace spdy {
-
-using SpdyStringPiece = SpdyStringPieceImpl;
-
-}  // namespace spdy
-
-#endif  // QUICHE_SPDY_PLATFORM_API_SPDY_STRING_PIECE_H_
diff --git a/spdy/platform/api/spdy_string_utils.h b/spdy/platform/api/spdy_string_utils.h
index 7619fb0..473a394 100644
--- a/spdy/platform/api/spdy_string_utils.h
+++ b/spdy/platform/api/spdy_string_utils.h
@@ -14,7 +14,7 @@
 // non-test code.
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_mem_slice.h"
 
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/spdy/platform/impl/spdy_string_utils_impl.h"
 
 namespace spdy {
@@ -33,11 +33,12 @@
   return SpdyHexDigitToIntImpl(c);
 }
 
-inline std::string SpdyHexDecode(SpdyStringPiece data) {
+inline std::string SpdyHexDecode(quiche::QuicheStringPiece data) {
   return SpdyHexDecodeImpl(data);
 }
 
-inline bool SpdyHexDecodeToUInt32(SpdyStringPiece data, uint32_t* out) {
+inline bool SpdyHexDecodeToUInt32(quiche::QuicheStringPiece data,
+                                  uint32_t* out) {
   return SpdyHexDecodeToUInt32Impl(data, out);
 }
 
@@ -49,7 +50,7 @@
   return SpdyHexEncodeUInt32AndTrimImpl(data);
 }
 
-inline std::string SpdyHexDump(SpdyStringPiece data) {
+inline std::string SpdyHexDump(quiche::QuicheStringPiece data) {
   return SpdyHexDumpImpl(data);
 }
 
diff --git a/spdy/platform/api/spdy_string_utils_test.cc b/spdy/platform/api/spdy_string_utils_test.cc
index 76a2a35..2134348 100644
--- a/spdy/platform/api/spdy_string_utils_test.cc
+++ b/spdy/platform/api/spdy_string_utils_test.cc
@@ -6,7 +6,7 @@
 
 #include <cstdint>
 
-#include "net/third_party/quiche/src/spdy/platform/api/spdy_string_piece.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/platform/api/spdy_test.h"
 
 namespace spdy {
@@ -20,14 +20,14 @@
   // Single string-like argument.
   const char kFoo[] = "foo";
   const std::string string_foo(kFoo);
-  const SpdyStringPiece stringpiece_foo(string_foo);
+  const quiche::QuicheStringPiece stringpiece_foo(string_foo);
   EXPECT_EQ("foo", SpdyStrCat(kFoo));
   EXPECT_EQ("foo", SpdyStrCat(string_foo));
   EXPECT_EQ("foo", SpdyStrCat(stringpiece_foo));
 
   // Two string-like arguments.
   const char kBar[] = "bar";
-  const SpdyStringPiece stringpiece_bar(kBar);
+  const quiche::QuicheStringPiece stringpiece_bar(kBar);
   const std::string string_bar(kBar);
   EXPECT_EQ("foobar", SpdyStrCat(kFoo, kBar));
   EXPECT_EQ("foobar", SpdyStrCat(kFoo, string_bar));
@@ -79,7 +79,7 @@
   // Single string-like argument.
   const char kFoo[] = "foo";
   const std::string string_foo(kFoo);
-  const SpdyStringPiece stringpiece_foo(string_foo);
+  const quiche::QuicheStringPiece stringpiece_foo(string_foo);
   SpdyStrAppend(&output, kFoo);
   EXPECT_EQ("foo", output);
   SpdyStrAppend(&output, string_foo);
@@ -95,7 +95,7 @@
 
   // Two string-like arguments.
   const char kBar[] = "bar";
-  const SpdyStringPiece stringpiece_bar(kBar);
+  const quiche::QuicheStringPiece stringpiece_bar(kBar);
   const std::string string_bar(kBar);
   SpdyStrAppend(&output, kFoo, kBar);
   EXPECT_EQ("foobar", output);