diff --git a/spdy/core/http2_frame_decoder_adapter.h b/spdy/core/http2_frame_decoder_adapter.h
index 1ac20c2..a75ab23 100644
--- a/spdy/core/http2_frame_decoder_adapter.h
+++ b/spdy/core/http2_frame_decoder_adapter.h
@@ -11,10 +11,10 @@
 #include <memory>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/http2/decoder/http2_frame_decoder.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_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"
@@ -494,7 +494,7 @@
   // Called when an ALTSVC frame has been parsed.
   virtual void OnAltSvc(
       SpdyStreamId /*stream_id*/,
-      quiche::QuicheStringPiece /*origin*/,
+      absl::string_view /*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 e54c869..31ed952 100644
--- a/spdy/core/mock_spdy_framer_visitor.h
+++ b/spdy/core/mock_spdy_framer_visitor.h
@@ -9,7 +9,7 @@
 #include <memory>
 #include <utility>
 
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_test.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"
@@ -90,7 +90,7 @@
       void,
       OnAltSvc,
       (SpdyStreamId stream_id,
-       quiche::QuicheStringPiece origin,
+       absl::string_view origin,
        const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector),
       (override));
   MOCK_METHOD(void,
diff --git a/spdy/core/spdy_alt_svc_wire_format.cc b/spdy/core/spdy_alt_svc_wire_format.cc
index 7f7ca29..ac85b9c 100644
--- a/spdy/core/spdy_alt_svc_wire_format.cc
+++ b/spdy/core/spdy_alt_svc_wire_format.cc
@@ -17,8 +17,8 @@
 namespace {
 
 template <class T>
-bool ParsePositiveIntegerImpl(quiche::QuicheStringPiece::const_iterator c,
-                              quiche::QuicheStringPiece::const_iterator end,
+bool ParsePositiveIntegerImpl(absl::string_view::const_iterator c,
+                              absl::string_view::const_iterator end,
                               T* value) {
   *value = 0;
   for (; c != end && std::isdigit(*c); ++c) {
@@ -57,20 +57,20 @@
 
 // static
 bool SpdyAltSvcWireFormat::ParseHeaderFieldValue(
-    quiche::QuicheStringPiece value,
+    absl::string_view value,
     AlternativeServiceVector* altsvc_vector) {
   // Empty value is invalid according to the specification.
   if (value.empty()) {
     return false;
   }
   altsvc_vector->clear();
-  if (value == quiche::QuicheStringPiece("clear")) {
+  if (value == absl::string_view("clear")) {
     return true;
   }
-  quiche::QuicheStringPiece::const_iterator c = value.begin();
+  absl::string_view::const_iterator c = value.begin();
   while (c != value.end()) {
     // Parse protocol-id.
-    quiche::QuicheStringPiece::const_iterator percent_encoded_protocol_id_end =
+    absl::string_view::const_iterator percent_encoded_protocol_id_end =
         std::find(c, value.end(), '=');
     std::string protocol_id;
     if (percent_encoded_protocol_id_end == c ||
@@ -91,7 +91,7 @@
       return false;
     }
     ++c;
-    quiche::QuicheStringPiece::const_iterator alt_authority_begin = c;
+    absl::string_view::const_iterator alt_authority_begin = c;
     for (; c != value.end() && *c != '"'; ++c) {
       // Decode backslash encoding.
       if (*c != '\\') {
@@ -115,7 +115,7 @@
     // Parse parameters.
     uint32_t max_age = 86400;
     VersionVector version;
-    quiche::QuicheStringPiece::const_iterator parameters_end =
+    absl::string_view::const_iterator parameters_end =
         std::find(c, value.end(), ',');
     while (c != parameters_end) {
       SkipWhiteSpace(&c, parameters_end);
@@ -140,7 +140,7 @@
       }
       ++c;
       SkipWhiteSpace(&c, parameters_end);
-      quiche::QuicheStringPiece::const_iterator parameter_value_begin = c;
+      absl::string_view::const_iterator parameter_value_begin = c;
       for (; c != parameters_end && *c != ';' && *c != ' ' && *c != '\t'; ++c) {
       }
       if (c == parameter_value_begin) {
@@ -164,10 +164,9 @@
         }
         ++c;
         parameters_end = std::find(c, value.end(), ',');
-        quiche::QuicheStringPiece::const_iterator v_begin =
-            parameter_value_begin + 1;
+        absl::string_view::const_iterator v_begin = parameter_value_begin + 1;
         while (v_begin < c) {
-          quiche::QuicheStringPiece::const_iterator v_end = v_begin;
+          absl::string_view::const_iterator v_end = v_begin;
           while (v_end < c - 1 && *v_end != ',') {
             ++v_end;
           }
@@ -196,10 +195,9 @@
         // hq=":443";quic=51303338
         // ... will be stored in |versions| as 0x51303338.
         uint32_t quic_version;
-        if (!SpdyHexDecodeToUInt32(
-                quiche::QuicheStringPiece(&*parameter_value_begin,
-                                          c - parameter_value_begin),
-                &quic_version) ||
+        if (!SpdyHexDecodeToUInt32(absl::string_view(&*parameter_value_begin,
+                                                     c - parameter_value_begin),
+                                   &quic_version) ||
             quic_version == 0) {
           return false;
         }
@@ -295,17 +293,16 @@
 
 // static
 void SpdyAltSvcWireFormat::SkipWhiteSpace(
-    quiche::QuicheStringPiece::const_iterator* c,
-    quiche::QuicheStringPiece::const_iterator end) {
+    absl::string_view::const_iterator* c,
+    absl::string_view::const_iterator end) {
   for (; *c != end && (**c == ' ' || **c == '\t'); ++*c) {
   }
 }
 
 // static
-bool SpdyAltSvcWireFormat::PercentDecode(
-    quiche::QuicheStringPiece::const_iterator c,
-    quiche::QuicheStringPiece::const_iterator end,
-    std::string* output) {
+bool SpdyAltSvcWireFormat::PercentDecode(absl::string_view::const_iterator c,
+                                         absl::string_view::const_iterator end,
+                                         std::string* output) {
   output->clear();
   for (; c != end; ++c) {
     if (*c != '%') {
@@ -331,8 +328,8 @@
 
 // static
 bool SpdyAltSvcWireFormat::ParseAltAuthority(
-    quiche::QuicheStringPiece::const_iterator c,
-    quiche::QuicheStringPiece::const_iterator end,
+    absl::string_view::const_iterator c,
+    absl::string_view::const_iterator end,
     std::string* host,
     uint16_t* port) {
   host->clear();
@@ -378,16 +375,16 @@
 
 // static
 bool SpdyAltSvcWireFormat::ParsePositiveInteger16(
-    quiche::QuicheStringPiece::const_iterator c,
-    quiche::QuicheStringPiece::const_iterator end,
+    absl::string_view::const_iterator c,
+    absl::string_view::const_iterator end,
     uint16_t* value) {
   return ParsePositiveIntegerImpl<uint16_t>(c, end, value);
 }
 
 // static
 bool SpdyAltSvcWireFormat::ParsePositiveInteger32(
-    quiche::QuicheStringPiece::const_iterator c,
-    quiche::QuicheStringPiece::const_iterator end,
+    absl::string_view::const_iterator c,
+    absl::string_view::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 4d25450..30462fe 100644
--- a/spdy/core/spdy_alt_svc_wire_format.h
+++ b/spdy/core/spdy_alt_svc_wire_format.h
@@ -14,8 +14,8 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
-#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"
 
 namespace spdy {
@@ -60,29 +60,27 @@
   typedef std::vector<AlternativeService> AlternativeServiceVector;
 
   friend class test::SpdyAltSvcWireFormatPeer;
-  static bool ParseHeaderFieldValue(quiche::QuicheStringPiece value,
+  static bool ParseHeaderFieldValue(absl::string_view value,
                                     AlternativeServiceVector* altsvc_vector);
   static std::string SerializeHeaderFieldValue(
       const AlternativeServiceVector& altsvc_vector);
 
  private:
-  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,
+  static void SkipWhiteSpace(absl::string_view::const_iterator* c,
+                             absl::string_view::const_iterator end);
+  static bool PercentDecode(absl::string_view::const_iterator c,
+                            absl::string_view::const_iterator end,
                             std::string* output);
-  static bool ParseAltAuthority(quiche::QuicheStringPiece::const_iterator c,
-                                quiche::QuicheStringPiece::const_iterator end,
+  static bool ParseAltAuthority(absl::string_view::const_iterator c,
+                                absl::string_view::const_iterator end,
                                 std::string* host,
                                 uint16_t* port);
-  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);
+  static bool ParsePositiveInteger16(absl::string_view::const_iterator c,
+                                     absl::string_view::const_iterator end,
+                                     uint16_t* value);
+  static bool ParsePositiveInteger32(absl::string_view::const_iterator c,
+                                     absl::string_view::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 d80de7d..a4127c8 100644
--- a/spdy/core/spdy_alt_svc_wire_format_test.cc
+++ b/spdy/core/spdy_alt_svc_wire_format_test.cc
@@ -14,31 +14,29 @@
 // Expose all private methods of class SpdyAltSvcWireFormat.
 class SpdyAltSvcWireFormatPeer {
  public:
-  static void SkipWhiteSpace(quiche::QuicheStringPiece::const_iterator* c,
-                             quiche::QuicheStringPiece::const_iterator end) {
+  static void SkipWhiteSpace(absl::string_view::const_iterator* c,
+                             absl::string_view::const_iterator end) {
     SpdyAltSvcWireFormat::SkipWhiteSpace(c, end);
   }
-  static bool PercentDecode(quiche::QuicheStringPiece::const_iterator c,
-                            quiche::QuicheStringPiece::const_iterator end,
+  static bool PercentDecode(absl::string_view::const_iterator c,
+                            absl::string_view::const_iterator end,
                             std::string* output) {
     return SpdyAltSvcWireFormat::PercentDecode(c, end, output);
   }
-  static bool ParseAltAuthority(quiche::QuicheStringPiece::const_iterator c,
-                                quiche::QuicheStringPiece::const_iterator end,
+  static bool ParseAltAuthority(absl::string_view::const_iterator c,
+                                absl::string_view::const_iterator end,
                                 std::string* host,
                                 uint16_t* port) {
     return SpdyAltSvcWireFormat::ParseAltAuthority(c, end, host, port);
   }
-  static bool ParsePositiveInteger16(
-      quiche::QuicheStringPiece::const_iterator c,
-      quiche::QuicheStringPiece::const_iterator end,
-      uint16_t* max_age) {
+  static bool ParsePositiveInteger16(absl::string_view::const_iterator c,
+                                     absl::string_view::const_iterator end,
+                                     uint16_t* max_age) {
     return SpdyAltSvcWireFormat::ParsePositiveInteger16(c, end, max_age);
   }
-  static bool ParsePositiveInteger32(
-      quiche::QuicheStringPiece::const_iterator c,
-      quiche::QuicheStringPiece::const_iterator end,
-      uint32_t* max_age) {
+  static bool ParsePositiveInteger32(absl::string_view::const_iterator c,
+                                     absl::string_view::const_iterator end,
+                                     uint32_t* max_age) {
     return SpdyAltSvcWireFormat::ParsePositiveInteger32(c, end, max_age);
   }
 };
@@ -389,8 +387,8 @@
 
 // Test SkipWhiteSpace().
 TEST(SpdyAltSvcWireFormatTest, SkipWhiteSpace) {
-  quiche::QuicheStringPiece input("a \tb  ");
-  quiche::QuicheStringPiece::const_iterator c = input.begin();
+  absl::string_view input("a \tb  ");
+  absl::string_view::const_iterator c = input.begin();
   test::SpdyAltSvcWireFormatPeer::SkipWhiteSpace(&c, input.end());
   ASSERT_EQ(input.begin(), c);
   ++c;
@@ -403,19 +401,19 @@
 
 // Test PercentDecode() on valid input.
 TEST(SpdyAltSvcWireFormatTest, PercentDecodeValid) {
-  quiche::QuicheStringPiece input("");
+  absl::string_view input("");
   std::string output;
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::PercentDecode(
       input.begin(), input.end(), &output));
   EXPECT_EQ("", output);
 
-  input = quiche::QuicheStringPiece("foo");
+  input = absl::string_view("foo");
   output.clear();
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::PercentDecode(
       input.begin(), input.end(), &output));
   EXPECT_EQ("foo", output);
 
-  input = quiche::QuicheStringPiece("%2ca%5Cb");
+  input = absl::string_view("%2ca%5Cb");
   output.clear();
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::PercentDecode(
       input.begin(), input.end(), &output));
@@ -426,7 +424,7 @@
 TEST(SpdyAltSvcWireFormatTest, PercentDecodeInvalid) {
   const char* invalid_input_array[] = {"a%", "a%x", "a%b", "%J22", "%9z"};
   for (const char* invalid_input : invalid_input_array) {
-    quiche::QuicheStringPiece input(invalid_input);
+    absl::string_view input(invalid_input);
     std::string output;
     EXPECT_FALSE(test::SpdyAltSvcWireFormatPeer::PercentDecode(
         input.begin(), input.end(), &output))
@@ -436,7 +434,7 @@
 
 // Test ParseAltAuthority() on valid input.
 TEST(SpdyAltSvcWireFormatTest, ParseAltAuthorityValid) {
-  quiche::QuicheStringPiece input(":42");
+  absl::string_view input(":42");
   std::string host;
   uint16_t port;
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority(
@@ -444,13 +442,13 @@
   EXPECT_TRUE(host.empty());
   EXPECT_EQ(42, port);
 
-  input = quiche::QuicheStringPiece("foo:137");
+  input = absl::string_view("foo:137");
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority(
       input.begin(), input.end(), &host, &port));
   EXPECT_EQ("foo", host);
   EXPECT_EQ(137, port);
 
-  input = quiche::QuicheStringPiece("[2003:8:0:16::509d:9615]:443");
+  input = absl::string_view("[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);
@@ -477,7 +475,7 @@
                                        "[2003:8:0:16::509d:9615:443",
                                        "2003:8:0:16::509d:9615]:443"};
   for (const char* invalid_input : invalid_input_array) {
-    quiche::QuicheStringPiece input(invalid_input);
+    absl::string_view input(invalid_input);
     std::string host;
     uint16_t port;
     EXPECT_FALSE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority(
@@ -488,13 +486,13 @@
 
 // Test ParseInteger() on valid input.
 TEST(SpdyAltSvcWireFormatTest, ParseIntegerValid) {
-  quiche::QuicheStringPiece input("3");
+  absl::string_view input("3");
   uint16_t value;
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16(
       input.begin(), input.end(), &value));
   EXPECT_EQ(3, value);
 
-  input = quiche::QuicheStringPiece("1337");
+  input = absl::string_view("1337");
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16(
       input.begin(), input.end(), &value));
   EXPECT_EQ(1337, value);
@@ -505,7 +503,7 @@
 TEST(SpdyAltSvcWireFormatTest, ParseIntegerInvalid) {
   const char* invalid_input_array[] = {"", " ", "a", "0", "00", "1 ", "12b"};
   for (const char* invalid_input : invalid_input_array) {
-    quiche::QuicheStringPiece input(invalid_input);
+    absl::string_view input(invalid_input);
     uint16_t value;
     EXPECT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16(
         input.begin(), input.end(), &value))
@@ -516,39 +514,39 @@
 // Test ParseIntegerValid() around overflow limit.
 TEST(SpdyAltSvcWireFormatTest, ParseIntegerOverflow) {
   // Largest possible uint16_t value.
-  quiche::QuicheStringPiece input("65535");
+  absl::string_view 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 = quiche::QuicheStringPiece("65536");
+  input = absl::string_view("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 = quiche::QuicheStringPiece("65537");
+  input = absl::string_view("65537");
   ASSERT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16(
       input.begin(), input.end(), &value16));
 
   // Largest possible uint32_t value.
-  input = quiche::QuicheStringPiece("4294967295");
+  input = absl::string_view("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 = quiche::QuicheStringPiece("4294967296");
+  input = absl::string_view("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 = quiche::QuicheStringPiece("4294967297");
+  input = absl::string_view("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 9e20e3e..f5d3646 100644
--- a/spdy/core/spdy_deframer_visitor.cc
+++ b/spdy/core/spdy_deframer_visitor.cc
@@ -11,8 +11,8 @@
 #include <limits>
 #include <memory>
 
+#include "absl/strings/string_view.h"
 #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"
@@ -138,7 +138,7 @@
   // alphabetical order for ease of navigation, and are not in same order
   // as in SpdyFramerVisitorInterface.
   void OnAltSvc(SpdyStreamId stream_id,
-                quiche::QuicheStringPiece origin,
+                absl::string_view origin,
                 const SpdyAltSvcWireFormat::AlternativeServiceVector&
                     altsvc_vector) override;
   void OnContinuation(SpdyStreamId stream_id, bool end) override;
@@ -185,8 +185,7 @@
   // Callbacks defined in SpdyHeadersHandlerInterface.
 
   void OnHeaderBlockStart() override;
-  void OnHeader(quiche::QuicheStringPiece key,
-                quiche::QuicheStringPiece value) override;
+  void OnHeader(absl::string_view key, absl::string_view value) override;
   void OnHeaderBlockEnd(size_t header_bytes_parsed,
                         size_t compressed_header_bytes_parsed) override;
 
@@ -411,7 +410,7 @@
 
 void SpdyTestDeframerImpl::OnAltSvc(
     SpdyStreamId stream_id,
-    quiche::QuicheStringPiece origin,
+    absl::string_view origin,
     const SpdyAltSvcWireFormat::AlternativeServiceVector& altsvc_vector) {
   SPDY_DVLOG(1) << "OnAltSvc stream_id: " << stream_id;
   CHECK_EQ(frame_type_, UNSET)
@@ -757,8 +756,8 @@
   got_hpack_end_ = false;
 }
 
-void SpdyTestDeframerImpl::OnHeader(quiche::QuicheStringPiece key,
-                                    quiche::QuicheStringPiece value) {
+void SpdyTestDeframerImpl::OnHeader(absl::string_view key,
+                                    absl::string_view 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 2753523..f17df98 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.
-//    QuicheStringPiece input = ...
+//    absl::string_view 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 492cd43..93fb284 100644
--- a/spdy/core/spdy_frame_builder.cc
+++ b/spdy/core/spdy_frame_builder.cc
@@ -120,8 +120,7 @@
   return success;
 }
 
-bool SpdyFrameBuilder::WriteStringPiece32(
-    const quiche::QuicheStringPiece value) {
+bool SpdyFrameBuilder::WriteStringPiece32(const absl::string_view value) {
   if (!WriteUInt32(value.size())) {
     return false;
   }
diff --git a/spdy/core/spdy_frame_builder.h b/spdy/core/spdy_frame_builder.h
index 4853d44..f840099 100644
--- a/spdy/core/spdy_frame_builder.h
+++ b/spdy/core/spdy_frame_builder.h
@@ -9,8 +9,8 @@
 #include <cstdint>
 #include <memory>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
 #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"
@@ -100,7 +100,7 @@
     return (WriteBytes(&upper, sizeof(upper)) &&
             WriteBytes(&lower, sizeof(lower)));
   }
-  bool WriteStringPiece32(const quiche::QuicheStringPiece value);
+  bool WriteStringPiece32(const absl::string_view 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 b109323..8f6a7b4 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(quiche::QuicheStringPiece(expected, kBuilderSize),
-            quiche::QuicheStringPiece(frame.data(), kBuilderSize));
+  EXPECT_EQ(absl::string_view(expected, kBuilderSize),
+            absl::string_view(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(quiche::QuicheStringPiece(expected, kBuilderSize),
-            quiche::QuicheStringPiece(frame.data(), kBuilderSize));
+  EXPECT_EQ(absl::string_view(expected, kBuilderSize),
+            absl::string_view(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 253f906..a76beb3 100644
--- a/spdy/core/spdy_frame_reader.cc
+++ b/spdy/core/spdy_frame_reader.cc
@@ -109,7 +109,7 @@
   return true;
 }
 
-bool SpdyFrameReader::ReadStringPiece16(quiche::QuicheStringPiece* result) {
+bool SpdyFrameReader::ReadStringPiece16(absl::string_view* result) {
   // Read resultant length.
   uint16_t result_len;
   if (!ReadUInt16(&result_len)) {
@@ -124,7 +124,7 @@
   }
 
   // Set result.
-  *result = quiche::QuicheStringPiece(data_ + ofs_, result_len);
+  *result = absl::string_view(data_ + ofs_, result_len);
 
   // Iterate.
   ofs_ += result_len;
@@ -132,7 +132,7 @@
   return true;
 }
 
-bool SpdyFrameReader::ReadStringPiece32(quiche::QuicheStringPiece* result) {
+bool SpdyFrameReader::ReadStringPiece32(absl::string_view* result) {
   // Read resultant length.
   uint32_t result_len;
   if (!ReadUInt32(&result_len)) {
@@ -147,7 +147,7 @@
   }
 
   // Set result.
-  *result = quiche::QuicheStringPiece(data_ + ofs_, result_len);
+  *result = absl::string_view(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 0ed5be4..e097ee3 100644
--- a/spdy/core/spdy_frame_reader.h
+++ b/spdy/core/spdy_frame_reader.h
@@ -7,8 +7,8 @@
 
 #include <cstdint>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace spdy {
 
@@ -73,7 +73,7 @@
   //
   // Forwards the internal iterator on success.
   // Returns true on success, false otherwise.
-  bool ReadStringPiece16(quiche::QuicheStringPiece* result);
+  bool ReadStringPiece16(absl::string_view* 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(quiche::QuicheStringPiece* result);
+  bool ReadStringPiece32(absl::string_view* 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 0bbe7f6..2a79caf 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());
 
-  quiche::QuicheStringPiece stringpiece_val;
+  absl::string_view 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());
 
-  quiche::QuicheStringPiece stringpiece_val;
+  absl::string_view 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());
 
-  quiche::QuicheStringPiece stringpiece_val;
+  absl::string_view 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());
 
-  quiche::QuicheStringPiece stringpiece_val;
+  absl::string_view 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());
 
-  quiche::QuicheStringPiece stringpiece_val;
+  absl::string_view 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());
 
-  quiche::QuicheStringPiece stringpiece_val;
+  absl::string_view 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", quiche::QuicheStringPiece(dest1, QUICHE_ARRAYSIZE(dest1)));
+  EXPECT_EQ("foo", absl::string_view(dest1, QUICHE_ARRAYSIZE(dest1)));
 
   char dest2[2] = {};
   EXPECT_TRUE(frame_reader.ReadBytes(&dest2, QUICHE_ARRAYSIZE(dest2)));
   EXPECT_TRUE(frame_reader.IsDoneReading());
-  EXPECT_EQ("Hi", quiche::QuicheStringPiece(dest2, QUICHE_ARRAYSIZE(dest2)));
+  EXPECT_EQ("Hi", absl::string_view(dest2, QUICHE_ARRAYSIZE(dest2)));
 }
 
 TEST(SpdyFrameReaderTest, ReadBytesWithBufferTooSmall) {
diff --git a/spdy/core/spdy_framer.h b/spdy/core/spdy_framer.h
index f16e3bd..99c2037 100644
--- a/spdy/core/spdy_framer.h
+++ b/spdy/core/spdy_framer.h
@@ -13,8 +13,8 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
-#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"
diff --git a/spdy/core/spdy_framer_test.cc b/spdy/core/spdy_framer_test.cc
index ee05143..864ea7d 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(quiche::QuicheStringPiece(data, len));
+                 << SpdyHexDump(absl::string_view(data, len));
     EXPECT_EQ(header_stream_id_, stream_id);
 
     data_bytes_ += len;
@@ -403,7 +403,7 @@
   }
 
   void OnAltSvc(SpdyStreamId stream_id,
-                quiche::QuicheStringPiece origin,
+                absl::string_view 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", quiche::QuicheStringPiece(value))));
+                                    "name", absl::string_view(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,
-                     quiche::QuicheStringPiece(bytes, QUICHE_ARRAYSIZE(bytes)));
+                     absl::string_view(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, quiche::QuicheStringPiece("o_r|g!n"),
-                                altsvc_vector));
+  EXPECT_CALL(visitor,
+              OnAltSvc(kStreamId, absl::string_view("o_r|g!n"), altsvc_vector));
 
   SpdyAltSvcIR altsvc_ir(kStreamId);
   altsvc_ir.set_origin("o_r|g!n");
@@ -4333,8 +4333,8 @@
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
   altsvc_vector.push_back(altsvc1);
   altsvc_vector.push_back(altsvc2);
-  EXPECT_CALL(visitor, OnAltSvc(kStreamId, quiche::QuicheStringPiece(""),
-                                altsvc_vector));
+  EXPECT_CALL(visitor,
+              OnAltSvc(kStreamId, absl::string_view(""), altsvc_vector));
 
   SpdyAltSvcIR altsvc_ir(kStreamId);
   altsvc_ir.add_altsvc(altsvc1);
@@ -4770,8 +4770,7 @@
   SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
 
   const char bytes[] = "this is a very short data frame";
-  SpdyDataIR data_ir(1,
-                     quiche::QuicheStringPiece(bytes, QUICHE_ARRAYSIZE(bytes)));
+  SpdyDataIR data_ir(1, absl::string_view(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 d7e3faa..ebb7918 100644
--- a/spdy/core/spdy_header_block.cc
+++ b/spdy/core/spdy_header_block.cc
@@ -27,21 +27,20 @@
 const char kCookieKey[] = "cookie";
 const char kNullSeparator = 0;
 
-quiche::QuicheStringPiece SeparatorForKey(quiche::QuicheStringPiece key) {
+absl::string_view SeparatorForKey(absl::string_view key) {
   if (key == kCookieKey) {
-    static quiche::QuicheStringPiece cookie_separator = "; ";
+    static absl::string_view cookie_separator = "; ";
     return cookie_separator;
   } else {
-    return quiche::QuicheStringPiece(&kNullSeparator, 1);
+    return absl::string_view(&kNullSeparator, 1);
   }
 }
 
 }  // namespace
 
-SpdyHeaderBlock::HeaderValue::HeaderValue(
-    SpdyHeaderStorage* storage,
-    quiche::QuicheStringPiece key,
-    quiche::QuicheStringPiece initial_value)
+SpdyHeaderBlock::HeaderValue::HeaderValue(SpdyHeaderStorage* storage,
+                                          absl::string_view key,
+                                          absl::string_view initial_value)
     : storage_(storage),
       fragments_({initial_value}),
       pair_({key, {}}),
@@ -71,10 +70,9 @@
 
 SpdyHeaderBlock::HeaderValue::~HeaderValue() = default;
 
-quiche::QuicheStringPiece SpdyHeaderBlock::HeaderValue::ConsolidatedValue()
-    const {
+absl::string_view SpdyHeaderBlock::HeaderValue::ConsolidatedValue() const {
   if (fragments_.empty()) {
-    return quiche::QuicheStringPiece();
+    return absl::string_view();
   }
   if (fragments_.size() > 1) {
     fragments_ = {
@@ -83,12 +81,12 @@
   return fragments_[0];
 }
 
-void SpdyHeaderBlock::HeaderValue::Append(quiche::QuicheStringPiece fragment) {
+void SpdyHeaderBlock::HeaderValue::Append(absl::string_view fragment) {
   size_ += (fragment.size() + separator_size_);
   fragments_.push_back(fragment);
 }
 
-const std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>&
+const std::pair<absl::string_view, absl::string_view>&
 SpdyHeaderBlock::HeaderValue::as_pair() const {
   pair_.second = ConsolidatedValue();
   return pair_;
@@ -103,7 +101,7 @@
 SpdyHeaderBlock::ValueProxy::ValueProxy(
     SpdyHeaderBlock* block,
     SpdyHeaderBlock::MapType::iterator lookup_result,
-    const quiche::QuicheStringPiece key,
+    const absl::string_view key,
     size_t* spdy_header_block_value_size)
     : block_(block),
       lookup_result_(lookup_result),
@@ -142,7 +140,7 @@
 }
 
 SpdyHeaderBlock::ValueProxy& SpdyHeaderBlock::ValueProxy::operator=(
-    quiche::QuicheStringPiece value) {
+    absl::string_view value) {
   *spdy_header_block_value_size_ += value.size();
   SpdyHeaderStorage* storage = &block_->storage_;
   if (lookup_result_ == block_->map_.end()) {
@@ -160,8 +158,7 @@
   return *this;
 }
 
-bool SpdyHeaderBlock::ValueProxy::operator==(
-    quiche::QuicheStringPiece value) const {
+bool SpdyHeaderBlock::ValueProxy::operator==(absl::string_view value) const {
   if (lookup_result_ == block_->map_.end()) {
     return false;
   } else {
@@ -232,7 +229,7 @@
   return output;
 }
 
-void SpdyHeaderBlock::erase(quiche::QuicheStringPiece key) {
+void SpdyHeaderBlock::erase(absl::string_view key) {
   auto iter = map_.find(key);
   if (iter != map_.end()) {
     SPDY_DVLOG(1) << "Erasing header with name: " << key;
@@ -268,13 +265,13 @@
 }
 
 SpdyHeaderBlock::ValueProxy SpdyHeaderBlock::operator[](
-    const quiche::QuicheStringPiece key) {
+    const absl::string_view key) {
   SPDY_DVLOG(2) << "Operator[] saw key: " << key;
-  quiche::QuicheStringPiece out_key;
+  absl::string_view 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 QuicheStringPiece in its operator=.
+    // reference to a valid absl::string_view in its operator=.
     out_key = WriteKey(key);
     SPDY_DVLOG(2) << "Key written as: " << std::hex
                   << static_cast<const void*>(key.data()) << ", " << std::dec
@@ -285,9 +282,8 @@
   return ValueProxy(this, iter, out_key, &value_size_);
 }
 
-void SpdyHeaderBlock::AppendValueOrAddHeader(
-    const quiche::QuicheStringPiece key,
-    const quiche::QuicheStringPiece value) {
+void SpdyHeaderBlock::AppendValueOrAddHeader(const absl::string_view key,
+                                             const absl::string_view value) {
   value_size_ += value.size();
 
   auto iter = map_.find(key);
@@ -309,15 +305,14 @@
   return SpdyEstimateMemoryUsage(storage_);
 }
 
-void SpdyHeaderBlock::AppendHeader(const quiche::QuicheStringPiece key,
-                                   const quiche::QuicheStringPiece value) {
+void SpdyHeaderBlock::AppendHeader(const absl::string_view key,
+                                   const absl::string_view value) {
   auto backed_key = WriteKey(key);
   map_.emplace(std::make_pair(
       backed_key, HeaderValue(&storage_, backed_key, storage_.Write(value))));
 }
 
-quiche::QuicheStringPiece SpdyHeaderBlock::WriteKey(
-    const quiche::QuicheStringPiece key) {
+absl::string_view SpdyHeaderBlock::WriteKey(const absl::string_view 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 2348551..1faf34d 100644
--- a/spdy/core/spdy_header_block.h
+++ b/spdy/core/spdy_header_block.h
@@ -13,8 +13,8 @@
 #include <utility>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
-#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_macros.h"
@@ -39,9 +39,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 QuicheStringPiece
-// keys, and values are returned as QuicheStringPieces (via ValueProxy, below).
-// Value QuicheStringPieces are valid as long as the SpdyHeaderBlock exists;
+// to store names and values. Lookups may be performed with absl::string_view
+// keys, and values are returned as absl::string_views (via ValueProxy, below).
+// Value absl::string_views 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.
@@ -53,8 +53,8 @@
   class QUICHE_EXPORT_PRIVATE HeaderValue {
    public:
     HeaderValue(SpdyHeaderStorage* storage,
-                quiche::QuicheStringPiece key,
-                quiche::QuicheStringPiece initial_value);
+                absl::string_view key,
+                absl::string_view initial_value);
 
     // Moves are allowed.
     HeaderValue(HeaderValue&& other);
@@ -69,11 +69,10 @@
     ~HeaderValue();
 
     // Consumes at most |fragment.size()| bytes of memory.
-    void Append(quiche::QuicheStringPiece fragment);
+    void Append(absl::string_view fragment);
 
-    quiche::QuicheStringPiece value() const { return as_pair().second; }
-    const std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>&
-    as_pair() const;
+    absl::string_view value() const { return as_pair().second; }
+    const std::pair<absl::string_view, absl::string_view>& as_pair() const;
 
     // Size estimate including separators. Used when keys are erased from
     // SpdyHeaderBlock.
@@ -82,37 +81,34 @@
    private:
     // May allocate a large contiguous region of memory to hold the concatenated
     // fragments and separators.
-    quiche::QuicheStringPiece ConsolidatedValue() const;
+    absl::string_view ConsolidatedValue() const;
 
     mutable SpdyHeaderStorage* storage_;
-    mutable std::vector<quiche::QuicheStringPiece> fragments_;
+    mutable std::vector<absl::string_view> fragments_;
     // The first element is the key; the second is the consolidated value.
-    mutable std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>
-        pair_;
+    mutable std::pair<absl::string_view, absl::string_view> pair_;
     size_t size_ = 0;
     size_t separator_size_ = 0;
   };
 
-  typedef SpdyLinkedHashMap<quiche::QuicheStringPiece,
+  typedef SpdyLinkedHashMap<absl::string_view,
                             HeaderValue,
                             SpdyStringPieceCaseHash,
                             SpdyStringPieceCaseEq>
       MapType;
 
  public:
-  typedef std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>
-      value_type;
+  typedef std::pair<absl::string_view, absl::string_view> value_type;
 
-  // Provides iteration over a sequence of std::pair<QuicheStringPiece,
-  // QuicheStringPiece>, even though the underlying MapType::value_type is
+  // Provides iteration over a sequence of std::pair<absl::string_view,
+  // absl::string_view>, even though the underlying MapType::value_type is
   // different. Dereferencing the iterator will result in memory allocation for
   // multi-value headers.
   class QUICHE_EXPORT_PRIVATE iterator {
    public:
     // The following type definitions fulfill the requirements for iterator
     // implementations.
-    typedef std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece>
-        value_type;
+    typedef std::pair<absl::string_view, absl::string_view> value_type;
     typedef value_type& reference;
     typedef value_type* pointer;
     typedef std::forward_iterator_tag iterator_category;
@@ -184,13 +180,11 @@
   const_iterator end() const { return wrap_const_iterator(map_.end()); }
   bool empty() const { return map_.empty(); }
   size_t size() const { return map_.size(); }
-  iterator find(quiche::QuicheStringPiece key) {
-    return wrap_iterator(map_.find(key));
-  }
-  const_iterator find(quiche::QuicheStringPiece key) const {
+  iterator find(absl::string_view key) { return wrap_iterator(map_.find(key)); }
+  const_iterator find(absl::string_view key) const {
     return wrap_const_iterator(map_.find(key));
   }
-  void erase(quiche::QuicheStringPiece key);
+  void erase(absl::string_view key);
 
   // Clears both our MapType member and the memory used to hold headers.
   void clear();
@@ -205,8 +199,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 quiche::QuicheStringPiece key,
-                              const quiche::QuicheStringPiece value);
+  void AppendValueOrAddHeader(const absl::string_view key,
+                              const absl::string_view value);
 
   // This object provides automatic conversions that allow SpdyHeaderBlock to be
   // nearly a drop-in replacement for
@@ -225,10 +219,10 @@
     ValueProxy& operator=(const ValueProxy& other) = delete;
 
     // Assignment modifies the underlying SpdyHeaderBlock.
-    ValueProxy& operator=(quiche::QuicheStringPiece value);
+    ValueProxy& operator=(absl::string_view value);
 
-    // Provides easy comparison against QuicheStringPiece.
-    bool operator==(quiche::QuicheStringPiece value) const;
+    // Provides easy comparison against absl::string_view.
+    bool operator==(absl::string_view value) const;
 
     std::string as_string() const;
 
@@ -238,19 +232,18 @@
 
     ValueProxy(SpdyHeaderBlock* block,
                SpdyHeaderBlock::MapType::iterator lookup_result,
-               const quiche::QuicheStringPiece key,
+               const absl::string_view key,
                size_t* spdy_header_block_value_size);
 
     SpdyHeaderBlock* block_;
     SpdyHeaderBlock::MapType::iterator lookup_result_;
-    quiche::QuicheStringPiece key_;
+    absl::string_view 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 quiche::QuicheStringPiece key);
+  SPDY_MUST_USE_RESULT ValueProxy operator[](const absl::string_view key);
 
   // Returns the estimate of dynamically allocated memory in bytes.
   size_t EstimateMemoryUsage() const;
@@ -285,12 +278,11 @@
 #endif  // SPDY_HEADER_DEBUG
   }
 
-  void AppendHeader(const quiche::QuicheStringPiece key,
-                    const quiche::QuicheStringPiece value);
-  quiche::QuicheStringPiece WriteKey(const quiche::QuicheStringPiece key);
+  void AppendHeader(const absl::string_view key, const absl::string_view value);
+  absl::string_view WriteKey(const absl::string_view key);
   size_t bytes_allocated() const;
 
-  // QuicheStringPieces held by |map_| point to memory owned by |storage_|.
+  // absl::string_views 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 b670c2a..a8dbe01 100644
--- a/spdy/core/spdy_header_block_test.cc
+++ b/spdy/core/spdy_header_block_test.cc
@@ -17,14 +17,13 @@
 
 class ValueProxyPeer {
  public:
-  static quiche::QuicheStringPiece key(SpdyHeaderBlock::ValueProxy* p) {
+  static absl::string_view key(SpdyHeaderBlock::ValueProxy* p) {
     return p->key_;
   }
 };
 
-std::pair<quiche::QuicheStringPiece, quiche::QuicheStringPiece> Pair(
-    quiche::QuicheStringPiece k,
-    quiche::QuicheStringPiece v) {
+std::pair<absl::string_view, absl::string_view> Pair(absl::string_view k,
+                                                     absl::string_view v) {
   return std::make_pair(k, v);
 }
 
@@ -42,19 +41,19 @@
 
 TEST(SpdyHeaderBlockTest, KeyMemoryReclaimedOnLookup) {
   SpdyHeaderBlock block;
-  quiche::QuicheStringPiece copied_key1;
+  absl::string_view copied_key1;
   {
     auto proxy1 = block["some key name"];
     copied_key1 = ValueProxyPeer::key(&proxy1);
   }
-  quiche::QuicheStringPiece copied_key2;
+  absl::string_view 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 QuicheStringPieces to be
+  // Therefore, we expect the pointers of the two absl::string_views to be
   // equal.
   EXPECT_EQ(copied_key1.data(), copied_key2.data());
 
@@ -199,19 +198,19 @@
   block.AppendValueOrAddHeader("foo", "bar");
   const auto& val = block["foo"];
   const char expected[] = "foo\0bar";
-  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));
+  EXPECT_TRUE(absl::string_view(expected, 7) == val);
+  EXPECT_TRUE(val == absl::string_view(expected, 7));
+  EXPECT_FALSE(absl::string_view(expected, 3) == val);
+  EXPECT_FALSE(val == absl::string_view(expected, 3));
   const char not_expected[] = "foo\0barextra";
-  EXPECT_FALSE(quiche::QuicheStringPiece(not_expected, 12) == val);
-  EXPECT_FALSE(val == quiche::QuicheStringPiece(not_expected, 12));
+  EXPECT_FALSE(absl::string_view(not_expected, 12) == val);
+  EXPECT_FALSE(val == absl::string_view(not_expected, 12));
 
   const auto& val2 = block["foo2"];
-  EXPECT_FALSE(quiche::QuicheStringPiece(expected, 7) == val2);
-  EXPECT_FALSE(val2 == quiche::QuicheStringPiece(expected, 7));
-  EXPECT_FALSE(quiche::QuicheStringPiece("") == val2);
-  EXPECT_FALSE(val2 == quiche::QuicheStringPiece(""));
+  EXPECT_FALSE(absl::string_view(expected, 7) == val2);
+  EXPECT_FALSE(val2 == absl::string_view(expected, 7));
+  EXPECT_FALSE(absl::string_view("") == val2);
+  EXPECT_FALSE(val2 == absl::string_view(""));
 }
 
 // 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 90493e1..29ed0a4 100644
--- a/spdy/core/spdy_header_storage.cc
+++ b/spdy/core/spdy_header_storage.cc
@@ -14,34 +14,33 @@
 
 SpdyHeaderStorage::SpdyHeaderStorage() : arena_(kDefaultStorageBlockSize) {}
 
-quiche::QuicheStringPiece SpdyHeaderStorage::Write(
-    const quiche::QuicheStringPiece s) {
-  return quiche::QuicheStringPiece(arena_.Memdup(s.data(), s.size()), s.size());
+absl::string_view SpdyHeaderStorage::Write(const absl::string_view s) {
+  return absl::string_view(arena_.Memdup(s.data(), s.size()), s.size());
 }
 
-void SpdyHeaderStorage::Rewind(const quiche::QuicheStringPiece s) {
+void SpdyHeaderStorage::Rewind(const absl::string_view s) {
   arena_.Free(const_cast<char*>(s.data()), s.size());
 }
 
-quiche::QuicheStringPiece SpdyHeaderStorage::WriteFragments(
-    const std::vector<quiche::QuicheStringPiece>& fragments,
-    quiche::QuicheStringPiece separator) {
+absl::string_view SpdyHeaderStorage::WriteFragments(
+    const std::vector<absl::string_view>& fragments,
+    absl::string_view separator) {
   if (fragments.empty()) {
-    return quiche::QuicheStringPiece();
+    return absl::string_view();
   }
   size_t total_size = separator.size() * (fragments.size() - 1);
-  for (const quiche::QuicheStringPiece& fragment : fragments) {
+  for (const absl::string_view& fragment : fragments) {
     total_size += fragment.size();
   }
   char* dst = arena_.Alloc(total_size);
   size_t written = Join(dst, fragments, separator);
   DCHECK_EQ(written, total_size);
-  return quiche::QuicheStringPiece(dst, total_size);
+  return absl::string_view(dst, total_size);
 }
 
 size_t Join(char* dst,
-            const std::vector<quiche::QuicheStringPiece>& fragments,
-            quiche::QuicheStringPiece separator) {
+            const std::vector<absl::string_view>& fragments,
+            absl::string_view separator) {
   if (fragments.empty()) {
     return 0;
   }
diff --git a/spdy/core/spdy_header_storage.h b/spdy/core/spdy_header_storage.h
index aace3c0..4e5a6ab 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 "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_export.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"
 
 namespace spdy {
 
-// This class provides a backing store for QuicheStringPieces. It previously
+// This class provides a backing store for absl::string_views. 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
+// property that absl::string_views that refer to data in SpdyHeaderStorage are
 // never invalidated until the SpdyHeaderStorage is deleted or Clear() is
 // called.
 //
@@ -26,20 +26,20 @@
   SpdyHeaderStorage(SpdyHeaderStorage&& other) = default;
   SpdyHeaderStorage& operator=(SpdyHeaderStorage&& other) = default;
 
-  quiche::QuicheStringPiece Write(quiche::QuicheStringPiece s);
+  absl::string_view Write(absl::string_view 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(quiche::QuicheStringPiece s);
+  void Rewind(absl::string_view 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 QuicheStringPiece
+  // the separator to a contiguous region of memory. Returns a absl::string_view
   // pointing to the region of memory.
-  quiche::QuicheStringPiece WriteFragments(
-      const std::vector<quiche::QuicheStringPiece>& fragments,
-      quiche::QuicheStringPiece separator);
+  absl::string_view WriteFragments(
+      const std::vector<absl::string_view>& fragments,
+      absl::string_view separator);
 
   size_t bytes_allocated() const { return arena_.status().bytes_allocated(); }
 
@@ -53,8 +53,8 @@
 // enough to hold the result. Returns the number of bytes written.
 QUICHE_EXPORT_PRIVATE size_t
 Join(char* dst,
-     const std::vector<quiche::QuicheStringPiece>& fragments,
-     quiche::QuicheStringPiece separator);
+     const std::vector<absl::string_view>& fragments,
+     absl::string_view separator);
 
 }  // namespace spdy
 
diff --git a/spdy/core/spdy_header_storage_test.cc b/spdy/core/spdy_header_storage_test.cc
index 71af6be..af8cd06 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<quiche::QuicheStringPiece> empty;
-  quiche::QuicheStringPiece separator = ", ";
+  std::vector<absl::string_view> empty;
+  absl::string_view separator = ", ";
   char buf[10] = "";
   size_t written = Join(buf, empty, separator);
   EXPECT_EQ(0u, written);
 }
 
 TEST(JoinTest, JoinOne) {
-  std::vector<quiche::QuicheStringPiece> v = {"one"};
-  quiche::QuicheStringPiece separator = ", ";
+  std::vector<absl::string_view> v = {"one"};
+  absl::string_view separator = ", ";
   char buf[15];
   size_t written = Join(buf, v, separator);
   EXPECT_EQ(3u, written);
-  EXPECT_EQ("one", quiche::QuicheStringPiece(buf, written));
+  EXPECT_EQ("one", absl::string_view(buf, written));
 }
 
 TEST(JoinTest, JoinMultiple) {
-  std::vector<quiche::QuicheStringPiece> v = {"one", "two", "three"};
-  quiche::QuicheStringPiece separator = ", ";
+  std::vector<absl::string_view> v = {"one", "two", "three"};
+  absl::string_view separator = ", ";
   char buf[15];
   size_t written = Join(buf, v, separator);
   EXPECT_EQ(15u, written);
-  EXPECT_EQ("one, two, three", quiche::QuicheStringPiece(buf, written));
+  EXPECT_EQ("one, two, three", absl::string_view(buf, written));
 }
 
 }  // namespace test
diff --git a/spdy/core/spdy_headers_handler_interface.h b/spdy/core/spdy_headers_handler_interface.h
index 8709977..39bda07 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 "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace spdy {
 
@@ -25,8 +25,7 @@
 
   // 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(quiche::QuicheStringPiece key,
-                        quiche::QuicheStringPiece value) = 0;
+  virtual void OnHeader(absl::string_view key, absl::string_view 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 93a3235..26bab9c 100644
--- a/spdy/core/spdy_no_op_visitor.h
+++ b/spdy/core/spdy_no_op_visitor.h
@@ -11,7 +11,7 @@
 
 #include <cstdint>
 
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "absl/strings/string_view.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"
 
@@ -61,7 +61,7 @@
                      bool /*end*/) override {}
   void OnContinuation(SpdyStreamId /*stream_id*/, bool /*end*/) override {}
   void OnAltSvc(SpdyStreamId /*stream_id*/,
-                quiche::QuicheStringPiece /*origin*/,
+                absl::string_view /*origin*/,
                 const SpdyAltSvcWireFormat::AlternativeServiceVector&
                 /*altsvc_vector*/) override {}
   void OnPriority(SpdyStreamId /*stream_id*/,
@@ -82,8 +82,8 @@
 
   // SpdyHeadersHandlerInterface methods:
   void OnHeaderBlockStart() override {}
-  void OnHeader(quiche::QuicheStringPiece /*key*/,
-                quiche::QuicheStringPiece /*value*/) override {}
+  void OnHeader(absl::string_view /*key*/,
+                absl::string_view /*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 fe9639f..2822410 100644
--- a/spdy/core/spdy_pinnable_buffer_piece.h
+++ b/spdy/core/spdy_pinnable_buffer_piece.h
@@ -9,8 +9,8 @@
 
 #include <memory>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
 
 namespace spdy {
 
@@ -27,8 +27,8 @@
 
   const char* buffer() const { return buffer_; }
 
-  explicit operator quiche::QuicheStringPiece() const {
-    return quiche::QuicheStringPiece(buffer_, length_);
+  explicit operator absl::string_view() const {
+    return absl::string_view(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 b30a7c0..42329d7 100644
--- a/spdy/core/spdy_pinnable_buffer_piece_test.cc
+++ b/spdy/core/spdy_pinnable_buffer_piece_test.cc
@@ -31,16 +31,14 @@
   EXPECT_TRUE(reader.ReadN(6, &piece));
 
   // Piece points to underlying prefix storage.
-  EXPECT_EQ(quiche::QuicheStringPiece("foobar"),
-            quiche::QuicheStringPiece(piece));
+  EXPECT_EQ(absl::string_view("foobar"), absl::string_view(piece));
   EXPECT_FALSE(piece.IsPinned());
   EXPECT_EQ(prefix_.data(), piece.buffer());
 
   piece.Pin();
 
   // Piece now points to allocated storage.
-  EXPECT_EQ(quiche::QuicheStringPiece("foobar"),
-            quiche::QuicheStringPiece(piece));
+  EXPECT_EQ(absl::string_view("foobar"), absl::string_view(piece));
   EXPECT_TRUE(piece.IsPinned());
   EXPECT_NE(prefix_.data(), piece.buffer());
 
@@ -58,24 +56,22 @@
 
   piece1.Pin();
 
-  EXPECT_EQ(quiche::QuicheStringPiece("foob"),
-            quiche::QuicheStringPiece(piece1));
+  EXPECT_EQ(absl::string_view("foob"), absl::string_view(piece1));
   EXPECT_TRUE(piece1.IsPinned());
-  EXPECT_EQ(quiche::QuicheStringPiece("ar"), quiche::QuicheStringPiece(piece2));
+  EXPECT_EQ(absl::string_view("ar"), absl::string_view(piece2));
   EXPECT_FALSE(piece2.IsPinned());
 
   piece1.Swap(&piece2);
 
-  EXPECT_EQ(quiche::QuicheStringPiece("ar"), quiche::QuicheStringPiece(piece1));
+  EXPECT_EQ(absl::string_view("ar"), absl::string_view(piece1));
   EXPECT_FALSE(piece1.IsPinned());
-  EXPECT_EQ(quiche::QuicheStringPiece("foob"),
-            quiche::QuicheStringPiece(piece2));
+  EXPECT_EQ(absl::string_view("foob"), absl::string_view(piece2));
   EXPECT_TRUE(piece2.IsPinned());
 
   SpdyPinnableBufferPiece empty;
   piece2.Swap(&empty);
 
-  EXPECT_EQ(quiche::QuicheStringPiece(""), quiche::QuicheStringPiece(piece2));
+  EXPECT_EQ(absl::string_view(""), absl::string_view(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 d48fde1..8355956 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/common/platform/api/quiche_string_piece.h"
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_test.h"
 
 namespace spdy {
@@ -46,8 +46,7 @@
   EXPECT_FALSE(reader.ReadN(10, &piece));  // Not enough buffer.
   EXPECT_TRUE(reader.ReadN(6, &piece));
   EXPECT_FALSE(piece.IsPinned());
-  EXPECT_EQ(quiche::QuicheStringPiece("foobar"),
-            quiche::QuicheStringPiece(piece));
+  EXPECT_EQ(absl::string_view("foobar"), absl::string_view(piece));
   EXPECT_EQ(0u, reader.Available());
 }
 
@@ -70,8 +69,7 @@
   EXPECT_FALSE(reader.ReadN(10, &piece));  // Not enough buffer.
   EXPECT_TRUE(reader.ReadN(6, &piece));
   EXPECT_FALSE(piece.IsPinned());
-  EXPECT_EQ(quiche::QuicheStringPiece("foobar"),
-            quiche::QuicheStringPiece(piece));
+  EXPECT_EQ(absl::string_view("foobar"), absl::string_view(piece));
   EXPECT_EQ(0u, reader.Available());
 }
 
@@ -94,8 +92,7 @@
   EXPECT_FALSE(reader.ReadN(10, &piece));  // Not enough buffer.
   EXPECT_TRUE(reader.ReadN(6, &piece));
   EXPECT_TRUE(piece.IsPinned());
-  EXPECT_EQ(quiche::QuicheStringPiece("foobar"),
-            quiche::QuicheStringPiece(piece));
+  EXPECT_EQ(absl::string_view("foobar"), absl::string_view(piece));
   EXPECT_EQ(0u, reader.Available());
 }
 
@@ -115,12 +112,12 @@
   EXPECT_EQ(6u, reader.Available());
 
   EXPECT_TRUE(reader.ReadN(3, &piece));
-  EXPECT_EQ(quiche::QuicheStringPiece("fhi"), quiche::QuicheStringPiece(piece));
+  EXPECT_EQ(absl::string_view("fhi"), absl::string_view(piece));
   EXPECT_TRUE(piece.IsPinned());
   EXPECT_EQ(3u, reader.Available());
 
   EXPECT_TRUE(reader.ReadN(2, &piece));
-  EXPECT_EQ(quiche::QuicheStringPiece("jk"), quiche::QuicheStringPiece(piece));
+  EXPECT_EQ(absl::string_view("jk"), absl::string_view(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 a4a72d6..53901ab 100644
--- a/spdy/core/spdy_protocol.cc
+++ b/spdy/core/spdy_protocol.cc
@@ -281,7 +281,7 @@
 
 SpdyFrameWithHeaderBlockIR::~SpdyFrameWithHeaderBlockIR() = default;
 
-SpdyDataIR::SpdyDataIR(SpdyStreamId stream_id, quiche::QuicheStringPiece data)
+SpdyDataIR::SpdyDataIR(SpdyStreamId stream_id, absl::string_view data)
     : SpdyFrameWithFinIR(stream_id),
       data_(nullptr),
       data_len_(0),
@@ -291,7 +291,7 @@
 }
 
 SpdyDataIR::SpdyDataIR(SpdyStreamId stream_id, const char* data)
-    : SpdyDataIR(stream_id, quiche::QuicheStringPiece(data)) {}
+    : SpdyDataIR(stream_id, absl::string_view(data)) {}
 
 SpdyDataIR::SpdyDataIR(SpdyStreamId stream_id, std::string data)
     : SpdyFrameWithFinIR(stream_id),
@@ -377,7 +377,7 @@
 
 SpdyGoAwayIR::SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
                            SpdyErrorCode error_code,
-                           quiche::QuicheStringPiece description)
+                           absl::string_view description)
     : description_(description) {
   set_last_good_stream_id(last_good_stream_id);
   set_error_code(error_code);
@@ -388,7 +388,7 @@
                            const char* description)
     : SpdyGoAwayIR(last_good_stream_id,
                    error_code,
-                   quiche::QuicheStringPiece(description)) {}
+                   absl::string_view(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 0bf8bb9..4c9c79a 100644
--- a/spdy/core/spdy_protocol.h
+++ b/spdy/core/spdy_protocol.h
@@ -19,8 +19,8 @@
 #include <string>
 #include <utility>
 
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_export.h"
-#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"
@@ -497,8 +497,7 @@
     // Deep copy.
     header_block_ = std::move(header_block);
   }
-  void SetHeader(quiche::QuicheStringPiece name,
-                 quiche::QuicheStringPiece value) {
+  void SetHeader(absl::string_view name, absl::string_view value) {
     header_block_[name] = value;
   }
 
@@ -516,7 +515,7 @@
 class QUICHE_EXPORT_PRIVATE SpdyDataIR : public SpdyFrameWithFinIR {
  public:
   // Performs a deep copy on data.
-  SpdyDataIR(SpdyStreamId stream_id, quiche::QuicheStringPiece data);
+  SpdyDataIR(SpdyStreamId stream_id, absl::string_view data);
 
   // Performs a deep copy on data.
   SpdyDataIR(SpdyStreamId stream_id, const char* data);
@@ -547,14 +546,14 @@
   }
 
   // Deep-copy of data (keep private copy).
-  void SetDataDeep(quiche::QuicheStringPiece data) {
+  void SetDataDeep(absl::string_view 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(quiche::QuicheStringPiece data) {
+  void SetDataShallow(absl::string_view data) {
     data_store_.reset();
     data_ = data.data();
     data_len_ = data.size();
@@ -660,7 +659,7 @@
   // this SpdyGoAwayIR.
   SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
                SpdyErrorCode error_code,
-               quiche::QuicheStringPiece description);
+               absl::string_view description);
 
   // References description, doesn't copy it, so description must outlast
   // this SpdyGoAwayIR.
@@ -689,7 +688,7 @@
     error_code_ = error_code;
   }
 
-  const quiche::QuicheStringPiece& description() const { return description_; }
+  const absl::string_view& description() const { return description_; }
 
   void Visit(SpdyFrameVisitor* visitor) const override;
 
@@ -701,7 +700,7 @@
   SpdyStreamId last_good_stream_id_;
   SpdyErrorCode error_code_;
   const std::string description_store_;
-  const quiche::QuicheStringPiece description_;
+  const absl::string_view description_;
 };
 
 class QUICHE_EXPORT_PRIVATE SpdyHeadersIR : public SpdyFrameWithHeaderBlockIR {
diff --git a/spdy/core/spdy_protocol_test.cc b/spdy/core/spdy_protocol_test.cc
index c952bce..f4cbc42 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
-  // QuicheStringPiece(nullptr).
-  quiche::QuicheStringPiece s1;
+  // absl::string_view(nullptr).
+  absl::string_view 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(quiche::QuicheStringPiece(d2.data(), d2.data_len()), s2);
-  EXPECT_NE(quiche::QuicheStringPiece(d1.data(), d1.data_len()), s2);
+  EXPECT_EQ(absl::string_view(d2.data(), d2.data_len()), s2);
+  EXPECT_NE(absl::string_view(d1.data(), d1.data_len()), s2);
   EXPECT_EQ((int)d1.data_len(), d1.flow_control_window_consumed());
 
   // Confirm copies a const string.
@@ -249,20 +249,18 @@
   std::string bar = "bar";
   SpdyDataIR d4(/* stream_id = */ 4, bar);
   EXPECT_EQ("bar", bar);
-  EXPECT_EQ("bar", quiche::QuicheStringPiece(d4.data(), d4.data_len()));
+  EXPECT_EQ("bar", absl::string_view(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(quiche::QuicheStringPiece(d5.data(), d5.data_len()),
-            "the quick brown fox");
+  EXPECT_EQ(absl::string_view(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(quiche::QuicheStringPiece(d7.data(), d7.data_len()),
-            "something else");
+  EXPECT_EQ(absl::string_view(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 7390f50..37199f6 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/common/platform/api/quiche_string_piece.h"
+#include "absl/strings/string_view.h"
 
 namespace spdy {
 namespace test {
@@ -47,8 +47,8 @@
   if (expected.data() == nullptr) {
     VERIFY_EQ(nullptr, actual.data());
   } else {
-    VERIFY_EQ(quiche::QuicheStringPiece(expected.data(), expected.data_len()),
-              quiche::QuicheStringPiece(actual.data(), actual.data_len()));
+    VERIFY_EQ(absl::string_view(expected.data(), expected.data_len()),
+              absl::string_view(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 7e66567..b9e9f75 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/common/platform/api/quiche_string_piece.h"
+#include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/common/platform/api/quiche_test.h"
 
 namespace spdy {
@@ -27,7 +27,7 @@
   char* c = arena.Memdup(kTestString, length);
   EXPECT_NE(nullptr, c);
   EXPECT_NE(c, kTestString);
-  EXPECT_EQ(quiche::QuicheStringPiece(c, length), kTestString);
+  EXPECT_EQ(absl::string_view(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(quiche::QuicheStringPiece(c, length), kTestString);
+  EXPECT_EQ(absl::string_view(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<quiche::QuicheStringPiece> copies;
+  std::vector<absl::string_view> copies;
   for (const std::string& s : strings) {
-    quiche::QuicheStringPiece sp(arena.Memdup(s.data(), s.size()), s.size());
+    absl::string_view 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(quiche::QuicheStringPiece(c, length), kTestString);
+  EXPECT_EQ(absl::string_view(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(quiche::QuicheStringPiece(c4, length), kTestString);
+  EXPECT_EQ(absl::string_view(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(quiche::QuicheStringPiece(c1, length), kTestString);
+  EXPECT_EQ(absl::string_view(c1, length), kTestString);
   // Multiple reallocs.
   char* c3 = arena.Memdup(kTestString, length);
   EXPECT_EQ(c2 + 2 * length, c3);
-  EXPECT_EQ(quiche::QuicheStringPiece(c3, length), kTestString);
+  EXPECT_EQ(absl::string_view(c3, length), kTestString);
   char* c4 = arena.Realloc(c3, length, 2 * length);
   EXPECT_EQ(c3, c4);
-  EXPECT_EQ(quiche::QuicheStringPiece(c4, length), kTestString);
+  EXPECT_EQ(absl::string_view(c4, length), kTestString);
   char* c5 = arena.Realloc(c4, 2 * length, 3 * length);
   EXPECT_EQ(c4, c5);
-  EXPECT_EQ(quiche::QuicheStringPiece(c5, length), kTestString);
+  EXPECT_EQ(absl::string_view(c5, length), kTestString);
   char* c6 = arena.Memdup(kTestString, length);
   EXPECT_EQ(c5 + 3 * length, c6);
-  EXPECT_EQ(quiche::QuicheStringPiece(c6, length), kTestString);
+  EXPECT_EQ(absl::string_view(c6, length), kTestString);
   // Realloc that does not fit in the remainder of the first block.
   char* c7 = arena.Realloc(c6, length, kDefaultBlockSize);
-  EXPECT_EQ(quiche::QuicheStringPiece(c7, length), kTestString);
+  EXPECT_EQ(absl::string_view(c7, length), kTestString);
   arena.Free(c7, kDefaultBlockSize);
   char* c8 = arena.Memdup(kTestString, length);
   EXPECT_NE(c6, c7);
   EXPECT_EQ(c7, c8);
-  EXPECT_EQ(quiche::QuicheStringPiece(c8, length), kTestString);
+  EXPECT_EQ(absl::string_view(c8, length), kTestString);
 }
 
 }  // namespace
diff --git a/spdy/core/spdy_test_utils.cc b/spdy/core/spdy_test_utils.cc
index 1d8db97..cf926b4 100644
--- a/spdy/core/spdy_test_utils.cc
+++ b/spdy/core/spdy_test_utils.cc
@@ -104,8 +104,8 @@
   block_.clear();
 }
 
-void TestHeadersHandler::OnHeader(quiche::QuicheStringPiece name,
-                                  quiche::QuicheStringPiece value) {
+void TestHeadersHandler::OnHeader(absl::string_view name,
+                                  absl::string_view value) {
   block_.AppendValueOrAddHeader(name, value);
 }
 
diff --git a/spdy/core/spdy_test_utils.h b/spdy/core/spdy_test_utils.h
index b3c3aa5..aaaa65a 100644
--- a/spdy/core/spdy_test_utils.h
+++ b/spdy/core/spdy_test_utils.h
@@ -9,7 +9,7 @@
 #include <cstdint>
 #include <string>
 
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
+#include "absl/strings/string_view.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"
@@ -17,7 +17,7 @@
 
 namespace spdy {
 
-inline bool operator==(quiche::QuicheStringPiece x,
+inline bool operator==(absl::string_view x,
                        const SpdyHeaderBlock::ValueProxy& y) {
   return y.operator==(x);
 }
@@ -49,8 +49,7 @@
 
   void OnHeaderBlockStart() override;
 
-  void OnHeader(quiche::QuicheStringPiece name,
-                quiche::QuicheStringPiece value) override;
+  void OnHeader(absl::string_view name, absl::string_view value) override;
 
   void OnHeaderBlockEnd(size_t header_bytes_parsed,
                         size_t compressed_header_bytes_parsed) override;