diff --git a/quiche/http2/hpack/decoder/hpack_decoder_state_test.cc b/quiche/http2/hpack/decoder/hpack_decoder_state_test.cc
index 46872aa..419dd8d 100644
--- a/quiche/http2/hpack/decoder/hpack_decoder_state_test.cc
+++ b/quiche/http2/hpack/decoder/hpack_decoder_state_test.cc
@@ -43,7 +43,7 @@
               (override));
 };
 
-enum StringBacking { STATIC, UNBUFFERED, BUFFERED };
+enum StringBacking { UNBUFFERED, BUFFERED };
 
 class HpackDecoderStateTest : public quiche::test::QuicheTest {
  protected:
@@ -69,27 +69,21 @@
     GetDecoderTables()->DynamicTableSizeUpdate(size);
   }
 
-  void SetStringBuffer(const char* s, StringBacking backing,
+  void SetStringBuffer(absl::string_view s, StringBacking backing,
                        HpackDecoderStringBuffer* string_buffer) {
-    switch (backing) {
-      case STATIC:
-        string_buffer->Set(s, true);
-        break;
-      case UNBUFFERED:
-        string_buffer->Set(s, false);
-        break;
-      case BUFFERED:
-        string_buffer->Set(s, false);
-        string_buffer->BufferStringIfUnbuffered();
-        break;
+    string_buffer->OnStart(false, s.size());
+    EXPECT_TRUE(string_buffer->OnData(s.data(), s.size()));
+    EXPECT_TRUE(string_buffer->OnEnd());
+    if (backing == BUFFERED) {
+      string_buffer->BufferStringIfUnbuffered();
     }
   }
 
-  void SetName(const char* s, StringBacking backing) {
+  void SetName(absl::string_view s, StringBacking backing) {
     SetStringBuffer(s, backing, &name_buffer_);
   }
 
-  void SetValue(const char* s, StringBacking backing) {
+  void SetValue(absl::string_view s, StringBacking backing) {
     SetStringBuffer(s, backing, &value_buffer_);
   }
 
@@ -106,15 +100,16 @@
 
   void SendIndexAndVerifyCallback(size_t index,
                                   HpackEntryType /*expected_type*/,
-                                  const char* expected_name,
-                                  const char* expected_value) {
+                                  absl::string_view expected_name,
+                                  absl::string_view expected_value) {
     EXPECT_CALL(listener_, OnHeader(Eq(expected_name), Eq(expected_value)));
     decoder_state_.OnIndexedHeader(index);
     Mock::VerifyAndClearExpectations(&listener_);
   }
 
   void SendValueAndVerifyCallback(size_t name_index, HpackEntryType entry_type,
-                                  const char* name, const char* value,
+                                  absl::string_view name,
+                                  absl::string_view value,
                                   StringBacking value_backing) {
     SetValue(value, value_backing);
     EXPECT_CALL(listener_, OnHeader(Eq(name), Eq(value)));
@@ -124,9 +119,9 @@
   }
 
   void SendNameAndValueAndVerifyCallback(HpackEntryType entry_type,
-                                         const char* name,
+                                         absl::string_view name,
                                          StringBacking name_backing,
-                                         const char* value,
+                                         absl::string_view value,
                                          StringBacking value_backing) {
     SetName(name, name_backing);
     SetValue(value, value_backing);
@@ -143,8 +138,8 @@
   }
 
   // dynamic_index is one-based, because that is the way RFC 7541 shows it.
-  AssertionResult VerifyEntry(size_t dynamic_index, const char* name,
-                              const char* value) {
+  AssertionResult VerifyEntry(size_t dynamic_index, absl::string_view name,
+                              absl::string_view value) {
     const HpackStringPair* entry =
         Lookup(dynamic_index + kFirstDynamicTableIndex - 1);
     HTTP2_VERIFY_NE(entry, nullptr);
@@ -159,7 +154,8 @@
     return AssertionSuccess();
   }
   AssertionResult VerifyDynamicTableContents(
-      const std::vector<std::pair<const char*, const char*>>& entries) {
+      const std::vector<std::pair<absl::string_view, absl::string_view>>&
+          entries) {
     size_t index = 1;
     for (const auto& entry : entries) {
       HTTP2_VERIFY_SUCCESS(VerifyEntry(index, entry.first, entry.second));
diff --git a/quiche/http2/hpack/decoder/hpack_decoder_string_buffer.cc b/quiche/http2/hpack/decoder/hpack_decoder_string_buffer.cc
index c57da8e..ab2bb12 100644
--- a/quiche/http2/hpack/decoder/hpack_decoder_string_buffer.cc
+++ b/quiche/http2/hpack/decoder/hpack_decoder_string_buffer.cc
@@ -38,8 +38,6 @@
       return out << "UNBUFFERED";
     case HpackDecoderStringBuffer::Backing::BUFFERED:
       return out << "BUFFERED";
-    case HpackDecoderStringBuffer::Backing::STATIC:
-      return out << "STATIC";
   }
   // Since the value doesn't come over the wire, only a programming bug should
   // result in reaching this point.
@@ -61,17 +59,6 @@
   state_ = State::RESET;
 }
 
-void HpackDecoderStringBuffer::Set(absl::string_view value, bool is_static) {
-  QUICHE_DVLOG(2) << "HpackDecoderStringBuffer::Set";
-  QUICHE_DCHECK_EQ(state_, State::RESET);
-  value_ = value;
-  state_ = State::COMPLETE;
-  backing_ = is_static ? Backing::STATIC : Backing::UNBUFFERED;
-  // TODO(jamessynge): Determine which of these two fields must be set.
-  remaining_len_ = 0;
-  is_huffman_encoded_ = false;
-}
-
 void HpackDecoderStringBuffer::OnStart(bool huffman_encoded, size_t len) {
   QUICHE_DVLOG(2) << "HpackDecoderStringBuffer::OnStart";
   QUICHE_DCHECK_EQ(state_, State::RESET);
diff --git a/quiche/http2/hpack/decoder/hpack_decoder_string_buffer.h b/quiche/http2/hpack/decoder/hpack_decoder_string_buffer.h
index a2b8605..ede1e71 100644
--- a/quiche/http2/hpack/decoder/hpack_decoder_string_buffer.h
+++ b/quiche/http2/hpack/decoder/hpack_decoder_string_buffer.h
@@ -23,7 +23,7 @@
 class QUICHE_EXPORT HpackDecoderStringBuffer {
  public:
   enum class State : uint8_t { RESET, COLLECTING, COMPLETE };
-  enum class Backing : uint8_t { RESET, UNBUFFERED, BUFFERED, STATIC };
+  enum class Backing : uint8_t { RESET, UNBUFFERED, BUFFERED };
 
   HpackDecoderStringBuffer();
   ~HpackDecoderStringBuffer();
@@ -32,7 +32,6 @@
   HpackDecoderStringBuffer& operator=(const HpackDecoderStringBuffer&) = delete;
 
   void Reset();
-  void Set(absl::string_view value, bool is_static);
 
   // Note that for Huffman encoded strings the length of the string after
   // decoding may be larger (expected), the same or even smaller; the latter
diff --git a/quiche/http2/hpack/decoder/hpack_decoder_string_buffer_test.cc b/quiche/http2/hpack/decoder/hpack_decoder_string_buffer_test.cc
index 299391f..c5eba14 100644
--- a/quiche/http2/hpack/decoder/hpack_decoder_string_buffer_test.cc
+++ b/quiche/http2/hpack/decoder/hpack_decoder_string_buffer_test.cc
@@ -46,31 +46,6 @@
   HpackDecoderStringBuffer buf_;
 };
 
-TEST_F(HpackDecoderStringBufferTest, SetStatic) {
-  absl::string_view data("static string");
-
-  EXPECT_EQ(state(), State::RESET);
-  EXPECT_TRUE(VerifyLogHasSubstrs({"state=RESET"}));
-
-  buf_.Set(data, /*is_static*/ true);
-  QUICHE_LOG(INFO) << buf_;
-  EXPECT_EQ(state(), State::COMPLETE);
-  EXPECT_EQ(backing(), Backing::STATIC);
-  EXPECT_EQ(data, buf_.str());
-  EXPECT_EQ(data.data(), buf_.str().data());
-  EXPECT_TRUE(VerifyLogHasSubstrs(
-      {"state=COMPLETE", "backing=STATIC", "value: static string"}));
-
-  // The string is static, so BufferStringIfUnbuffered won't change anything.
-  buf_.BufferStringIfUnbuffered();
-  EXPECT_EQ(state(), State::COMPLETE);
-  EXPECT_EQ(backing(), Backing::STATIC);
-  EXPECT_EQ(data, buf_.str());
-  EXPECT_EQ(data.data(), buf_.str().data());
-  EXPECT_TRUE(VerifyLogHasSubstrs(
-      {"state=COMPLETE", "backing=STATIC", "value: static string"}));
-}
-
 TEST_F(HpackDecoderStringBufferTest, PlainWhole) {
   absl::string_view data("some text.");